diff options
| author | Peter Varga <pvarga@inf.u-szeged.hu> | 2012-11-23 15:47:13 +0100 |
|---|---|---|
| committer | The Qt Project <gerrit-noreply@qt-project.org> | 2013-01-09 13:05:41 +0100 |
| commit | 29614f3a7f84955e75dbdacdaa0abb18fc9e5231 (patch) | |
| tree | a9a7d039ce37ae3af3b20699e732b8e7de496805 /src/3rdparty/v8/test | |
| parent | f3e57accf67099f668b069b1e248b4d4e424385b (diff) | |
| download | qtjsbackend-29614f3a7f84955e75dbdacdaa0abb18fc9e5231.tar.gz | |
Updated V8 from git://github.com/v8/v8.git to 2215c442af2f0a4fce076e35ea061486d62778a1
Update V8 source to version 3.15.2
* Performance and stability improvements on all platforms.
* Avoid overdeep recursion in regexp where a guarded expression with a
minimum repetition count is inside another quantifier.
* Exposed last seen heap object id via v8 public api.
* Implemented heap profiler memory usage reporting.
* Preserved error message during finally block in try..finally.
* Improved heuristics to keep objects in fast mode with inherited
constructors.
* Fixed lazy sweeping heuristics to prevent old-space expansion.
* Fixed sharing of literal boilerplates for optimized code.
* Expose more detailed memory statistics.
* Cleaned up hardfp ABI detection for ARM (V8 issue 2140).
* Report "hidden properties" in heap profiler for properties case.
* Added optimizing compiler support for JavaScript getters.
* Fixed computation of call targets on prototypes in Crankshaft.
* Fixed ICs for slow objects with native accessor.
* Fixed transcendental cache on ARM in optimized code (issue 2234).
* New heap inspection tools: counters for object sizes and counts,
histograms for external fragmentation.
* Added more support for heap analysis.
* Interpret negative hexadecimal literals as NaN. (issue 2240)
* Improved API calls that return empty handles.
* Added checks for interceptors to negative lookup code in Crankshaft.
* Introduced global contexts to represent lexical global scope(s).
* Allocate block-scoped global bindings to global context.
* Add empty-handle checks to API functions (#ifdef ENABLE_EXTRA_CHECKS)
* Check the return value of API calls on ia32 and x64.
* Activated fixed ES5 readonly semantics by default.
* Added validity checking to API functions and calls.
* Switched on code compaction on incremental GCs.
* ARM: allowed VFP3 instructions when hardfloat is enabled. (Chromium issue 152506)
* Killed off the SCons based build. (relevant for testing)
* Added a faster API for creating v8::Integer objects.
* Speeded up function deoptimization by avoiding quadratic pass over optimized function list. (Chromium issue 155270)
* ES6: Added support for size to Set and Map (issue 2395)
* ES6: Added support for Set and Map clear method (issue 2400)
* Made formatting error message side-effect-free. (issue 2398)
* Fixed V8 issues: 915, 1374, 1465, 1569, 1591, 1609 1645, 1804, 1914, 1981, 1991, 2016, 2017,
2034, 2077, 2087, 2094, 2119, 2120, 2133, 2134, 2139, 2143, 2151, 2156, 2166, 2170, 2172,
2177, 2179, 2185, 2193, 2194, 2201, 2210, 2212, 2219, 2220, 2225, 2239, 2245, 2252, 2260,
2261, 2294, 2297, 2308, 2312, 2313, 2317, 2318, 2322, 2326, 2364, 2372, 2380
Change-Id: Ifa82ec37b6150fdf1c4364c93987a32bbbf6bfd1
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
Diffstat (limited to 'src/3rdparty/v8/test')
253 files changed, 25089 insertions, 15773 deletions
diff --git a/src/3rdparty/v8/test/benchmarks/testcfg.py b/src/3rdparty/v8/test/benchmarks/testcfg.py index ab9d40f..5bbad7a 100644 --- a/src/3rdparty/v8/test/benchmarks/testcfg.py +++ b/src/3rdparty/v8/test/benchmarks/testcfg.py @@ -30,6 +30,11 @@ import test import os from os.path import join, split +def GetSuite(name, root): + # Not implemented. + return None + + def IsNumber(string): try: float(string) diff --git a/src/3rdparty/v8/test/cctest/cctest.gyp b/src/3rdparty/v8/test/cctest/cctest.gyp index a242fe3..80eecfd 100644 --- a/src/3rdparty/v8/test/cctest/cctest.gyp +++ b/src/3rdparty/v8/test/cctest/cctest.gyp @@ -79,6 +79,7 @@ 'test-lockers.cc', 'test-log.cc', 'test-mark-compact.cc', + 'test-object-observe.cc', 'test-parsing.cc', 'test-platform-tls.cc', 'test-profile-generator.cc', @@ -118,7 +119,7 @@ 'test-disasm-arm.cc' ], }], - ['v8_target_arch=="mips"', { + ['v8_target_arch=="mipsel"', { 'sources': [ 'test-assembler-mips.cc', 'test-disasm-mips.cc', diff --git a/src/3rdparty/v8/test/cctest/cctest.h b/src/3rdparty/v8/test/cctest/cctest.h index 0b93562..f3961a4 100644 --- a/src/3rdparty/v8/test/cctest/cctest.h +++ b/src/3rdparty/v8/test/cctest/cctest.h @@ -214,4 +214,23 @@ static inline v8::Local<v8::Value> CompileRun(const char* source) { } +// Helper function that compiles and runs the source with given origin. +static inline v8::Local<v8::Value> CompileRunWithOrigin(const char* source, + const char* origin_url, + int line_number, + int column_number) { + v8::ScriptOrigin origin(v8::String::New(origin_url), + v8::Integer::New(line_number), + v8::Integer::New(column_number)); + return v8::Script::Compile(v8::String::New(source), &origin)->Run(); +} + + +// Pick a slightly different port to allow tests to be run in parallel. +static inline int FlagDependentPortOffset() { + return ::v8::internal::FLAG_crankshaft == false ? 100 : + ::v8::internal::FLAG_always_opt ? 200 : 0; +} + + #endif // ifndef CCTEST_H_ diff --git a/src/3rdparty/v8/test/cctest/cctest.status b/src/3rdparty/v8/test/cctest/cctest.status index af28be1..ab59e33 100644 --- a/src/3rdparty/v8/test/cctest/cctest.status +++ b/src/3rdparty/v8/test/cctest/cctest.status @@ -27,6 +27,7 @@ prefix cctest +# All tests prefixed with 'Bug' are expected to fail. test-api/Bug*: FAIL ############################################################################## @@ -43,6 +44,9 @@ test-heap-profiler/HeapSnapshotsDiff: PASS || FAIL test-serialize/TestThatAlwaysFails: FAIL test-serialize/DependentTestThatAlwaysFails: FAIL +# This test always fails. It tests that LiveEdit causes abort when turned off. +test-debug/LiveEditDisabled: FAIL + # TODO(gc): Temporarily disabled in the GC branch. test-log/EquivalenceOfLoggingAndTraversal: PASS || FAIL @@ -64,11 +68,6 @@ test-api/OutOfMemoryNested: SKIP # BUG(355): Test crashes on ARM. test-log/ProfLazyMode: SKIP -# BUG(945): Socket connect fails on ARM -test-debug/DebuggerAgent: SKIP -test-debug/DebuggerAgentProtocolOverflowHeader: SKIP -test-sockets/Socket: SKIP - # BUG(1075): Unresolved crashes. test-serialize/Deserialize: SKIP test-serialize/DeserializeFromSecondSerializationAndRunScript2: SKIP @@ -76,16 +75,15 @@ test-serialize/DeserializeAndRunScript2: SKIP test-serialize/DeserializeFromSecondSerialization: SKIP ############################################################################## -[ $arch == arm && $crankshaft ] - -# Tests that time out with crankshaft. -test-debug/ThreadedDebugging: SKIP -test-debug/DebugBreakLoop: SKIP +[ $arch == android_arm || $arch == android_ia32 ] +# Tests crash as there is no /tmp directory in Android. +test-log/LogAccessorCallbacks: SKIP +test-log/LogCallbacks: SKIP +test-log/ProfLazyMode: SKIP -############################################################################## -[ $arch == mips && $crankshaft ] +# platform-tls.h does not contain an ANDROID-related header. +test-platform-tls/FastTLS: SKIP -# Tests that time out with crankshaft. -test-debug/ThreadedDebugging: SKIP -test-debug/DebugBreakLoop: SKIP +# This test times out. +test-threads/ThreadJoinSelf: SKIP diff --git a/src/3rdparty/v8/test/cctest/test-alloc.cc b/src/3rdparty/v8/test/cctest/test-alloc.cc index e195d14..7ba2583 100644 --- a/src/3rdparty/v8/test/cctest/test-alloc.cc +++ b/src/3rdparty/v8/test/cctest/test-alloc.cc @@ -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: @@ -34,7 +34,8 @@ using namespace v8::internal; -static inline void SimulateFullSpace(PagedSpace* space) { +// Also used in test-heap.cc test cases. +void SimulateFullSpace(PagedSpace* space) { int old_linear_size = static_cast<int>(space->limit() - space->top()); space->Free(space->top(), old_linear_size); space->SetTop(space->limit(), space->limit()); @@ -150,12 +151,21 @@ TEST(StressJS) { Handle<Map> map(function->initial_map()); Handle<DescriptorArray> instance_descriptors(map->instance_descriptors()); Handle<Foreign> foreign = FACTORY->NewForeign(&kDescriptor); - instance_descriptors = FACTORY->CopyAppendForeignDescriptor( - instance_descriptors, - FACTORY->NewStringFromAscii(Vector<const char>("get", 3)), - foreign, - static_cast<PropertyAttributes>(0)); - map->set_instance_descriptors(*instance_descriptors); + Handle<String> name = + FACTORY->NewStringFromAscii(Vector<const char>("get", 3)); + ASSERT(instance_descriptors->IsEmpty()); + + Handle<DescriptorArray> new_descriptors = FACTORY->NewDescriptorArray(0, 1); + + v8::internal::DescriptorArray::WhitenessWitness witness(*new_descriptors); + map->set_instance_descriptors(*new_descriptors); + + CallbacksDescriptor d(*name, + *foreign, + static_cast<PropertyAttributes>(0), + v8::internal::PropertyDetails::kInitialIndex); + map->AppendDescriptor(&d, witness); + // Add the Foo constructor the global object. env->Global()->Set(v8::String::New("Foo"), v8::Utils::ToLocal(function)); // Call the accessor through JavaScript. diff --git a/src/3rdparty/v8/test/cctest/test-api.cc b/src/3rdparty/v8/test/cctest/test-api.cc index 9122781..41eb68f 100644 --- a/src/3rdparty/v8/test/cctest/test-api.cc +++ b/src/3rdparty/v8/test/cctest/test-api.cc @@ -27,12 +27,18 @@ #include <limits.h> +#ifndef WIN32 +#include <signal.h> // kill +#include <unistd.h> // getpid +#endif // WIN32 + #include "v8.h" #include "api.h" #include "isolate.h" #include "compilation-cache.h" #include "execution.h" +#include "objects.h" #include "snapshot.h" #include "platform.h" #include "utils.h" @@ -398,6 +404,10 @@ THREADED_TEST(ScriptUsingStringResource) { CHECK(source->IsExternal()); CHECK_EQ(resource, static_cast<TestResource*>(source->GetExternalStringResource())); + String::Encoding encoding = String::UNKNOWN_ENCODING; + CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource), + source->GetExternalStringResourceBase(&encoding)); + CHECK_EQ(String::TWO_BYTE_ENCODING, encoding); HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); CHECK_EQ(0, dispose_count); } @@ -413,9 +423,16 @@ THREADED_TEST(ScriptUsingAsciiStringResource) { { v8::HandleScope scope; LocalContext env; - Local<String> source = - String::NewExternal(new TestAsciiResource(i::StrDup(c_source), - &dispose_count)); + TestAsciiResource* resource = new TestAsciiResource(i::StrDup(c_source), + &dispose_count); + Local<String> source = String::NewExternal(resource); + CHECK(source->IsExternalAscii()); + CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource), + source->GetExternalAsciiStringResource()); + String::Encoding encoding = String::UNKNOWN_ENCODING; + CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource), + source->GetExternalStringResourceBase(&encoding)); + CHECK_EQ(String::ASCII_ENCODING, encoding); Local<Script> script = Script::Compile(source); Local<Value> value = script->Run(); CHECK(value->IsNumber()); @@ -439,6 +456,11 @@ THREADED_TEST(ScriptMakingExternalString) { // Trigger GCs so that the newly allocated string moves to old gen. HEAP->CollectGarbage(i::NEW_SPACE); // in survivor space now HEAP->CollectGarbage(i::NEW_SPACE); // in old gen now + CHECK_EQ(source->IsExternal(), false); + CHECK_EQ(source->IsExternalAscii(), false); + String::Encoding encoding = String::UNKNOWN_ENCODING; + CHECK_EQ(NULL, source->GetExternalStringResourceBase(&encoding)); + CHECK_EQ(String::ASCII_ENCODING, encoding); bool success = source->MakeExternal(new TestResource(two_byte_source, &dispose_count)); CHECK(success); @@ -947,22 +969,33 @@ THREADED_TEST(FindInstanceInPrototypeChain) { THREADED_TEST(TinyInteger) { v8::HandleScope scope; LocalContext env; + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + int32_t value = 239; Local<v8::Integer> value_obj = v8::Integer::New(value); CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); + + value_obj = v8::Integer::New(value, isolate); + CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); } THREADED_TEST(BigSmiInteger) { v8::HandleScope scope; LocalContext env; + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + int32_t value = i::Smi::kMaxValue; // We cannot add one to a Smi::kMaxValue without wrapping. if (i::kSmiValueSize < 32) { CHECK(i::Smi::IsValid(value)); CHECK(!i::Smi::IsValid(value + 1)); + Local<v8::Integer> value_obj = v8::Integer::New(value); CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); + + value_obj = v8::Integer::New(value, isolate); + CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); } } @@ -970,6 +1003,8 @@ THREADED_TEST(BigSmiInteger) { THREADED_TEST(BigInteger) { v8::HandleScope scope; LocalContext env; + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + // We cannot add one to a Smi::kMaxValue without wrapping. if (i::kSmiValueSize < 32) { // The casts allow this to compile, even if Smi::kMaxValue is 2^31-1. @@ -978,8 +1013,12 @@ THREADED_TEST(BigInteger) { static_cast<int32_t>(static_cast<uint32_t>(i::Smi::kMaxValue) + 1); CHECK(value > i::Smi::kMaxValue); CHECK(!i::Smi::IsValid(value)); + Local<v8::Integer> value_obj = v8::Integer::New(value); CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); + + value_obj = v8::Integer::New(value, isolate); + CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); } } @@ -987,42 +1026,66 @@ THREADED_TEST(BigInteger) { THREADED_TEST(TinyUnsignedInteger) { v8::HandleScope scope; LocalContext env; + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + uint32_t value = 239; + Local<v8::Integer> value_obj = v8::Integer::NewFromUnsigned(value); CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); + + value_obj = v8::Integer::NewFromUnsigned(value, isolate); + CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); } THREADED_TEST(BigUnsignedSmiInteger) { v8::HandleScope scope; LocalContext env; + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + uint32_t value = static_cast<uint32_t>(i::Smi::kMaxValue); CHECK(i::Smi::IsValid(value)); CHECK(!i::Smi::IsValid(value + 1)); + Local<v8::Integer> value_obj = v8::Integer::NewFromUnsigned(value); CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); + + value_obj = v8::Integer::NewFromUnsigned(value, isolate); + CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); } THREADED_TEST(BigUnsignedInteger) { v8::HandleScope scope; LocalContext env; + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + uint32_t value = static_cast<uint32_t>(i::Smi::kMaxValue) + 1; CHECK(value > static_cast<uint32_t>(i::Smi::kMaxValue)); CHECK(!i::Smi::IsValid(value)); + Local<v8::Integer> value_obj = v8::Integer::NewFromUnsigned(value); CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); + + value_obj = v8::Integer::NewFromUnsigned(value, isolate); + CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); } THREADED_TEST(OutOfSignedRangeUnsignedInteger) { v8::HandleScope scope; LocalContext env; + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + uint32_t INT32_MAX_AS_UINT = (1U << 31) - 1; uint32_t value = INT32_MAX_AS_UINT + 1; CHECK(value > INT32_MAX_AS_UINT); // No overflow. + Local<v8::Integer> value_obj = v8::Integer::NewFromUnsigned(value); CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); + + value_obj = v8::Integer::NewFromUnsigned(value, isolate); + CHECK_EQ(static_cast<int64_t>(value), value_obj->Value()); } @@ -2080,6 +2143,10 @@ THREADED_TEST(HiddenProperties) { HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); + CHECK(obj->SetHiddenValue(key, Handle<Value>())); + CHECK(obj->GetHiddenValue(key).IsEmpty()); + + CHECK(obj->SetHiddenValue(key, v8::Integer::New(2002))); CHECK(obj->DeleteHiddenValue(key)); CHECK(obj->GetHiddenValue(key).IsEmpty()); } @@ -2182,6 +2249,14 @@ THREADED_TEST(GlobalHandle) { } CHECK_EQ(global->Length(), 3); global.Dispose(); + + { + v8::HandleScope scope; + Local<String> str = v8_str("str"); + global = v8::Persistent<String>::New(str); + } + CHECK_EQ(global->Length(), 3); + global.Dispose(v8::Isolate::GetCurrent()); } @@ -2372,6 +2447,100 @@ THREADED_TEST(ApiObjectGroupsCycle) { } +// TODO(mstarzinger): This should be a THREADED_TEST but causes failures +// on the buildbots, so was made non-threaded for the time being. +TEST(ApiObjectGroupsCycleForScavenger) { + HandleScope scope; + LocalContext env; + + WeakCallCounter counter(1234); + + Persistent<Object> g1s1; + Persistent<Object> g1s2; + Persistent<Object> g2s1; + Persistent<Object> g2s2; + Persistent<Object> g3s1; + Persistent<Object> g3s2; + + { + HandleScope scope; + g1s1 = Persistent<Object>::New(Object::New()); + g1s2 = Persistent<Object>::New(Object::New()); + g1s1.MakeWeak(reinterpret_cast<void*>(&counter), &WeakPointerCallback); + g1s2.MakeWeak(reinterpret_cast<void*>(&counter), &WeakPointerCallback); + + g2s1 = Persistent<Object>::New(Object::New()); + g2s2 = Persistent<Object>::New(Object::New()); + g2s1.MakeWeak(reinterpret_cast<void*>(&counter), &WeakPointerCallback); + g2s2.MakeWeak(reinterpret_cast<void*>(&counter), &WeakPointerCallback); + + g3s1 = Persistent<Object>::New(Object::New()); + g3s2 = Persistent<Object>::New(Object::New()); + g3s1.MakeWeak(reinterpret_cast<void*>(&counter), &WeakPointerCallback); + g3s2.MakeWeak(reinterpret_cast<void*>(&counter), &WeakPointerCallback); + } + + // Make a root. + Persistent<Object> root = Persistent<Object>::New(g1s1); + root.MarkPartiallyDependent(); + + // Connect groups. We're building the following cycle: + // G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other + // groups. + { + g1s1.MarkPartiallyDependent(); + g1s2.MarkPartiallyDependent(); + g2s1.MarkPartiallyDependent(); + g2s2.MarkPartiallyDependent(); + g3s1.MarkPartiallyDependent(); + g3s2.MarkPartiallyDependent(); + Persistent<Value> g1_objects[] = { g1s1, g1s2 }; + Persistent<Value> g2_objects[] = { g2s1, g2s2 }; + Persistent<Value> g3_objects[] = { g3s1, g3s2 }; + V8::AddObjectGroup(g1_objects, 2); + g1s1->Set(v8_str("x"), g2s1); + V8::AddObjectGroup(g2_objects, 2); + g2s1->Set(v8_str("x"), g3s1); + V8::AddObjectGroup(g3_objects, 2); + g3s1->Set(v8_str("x"), g1s1); + } + + HEAP->CollectGarbage(i::NEW_SPACE); + + // All objects should be alive. + CHECK_EQ(0, counter.NumberOfWeakCalls()); + + // Weaken the root. + root.MakeWeak(reinterpret_cast<void*>(&counter), &WeakPointerCallback); + root.MarkPartiallyDependent(); + + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + // Groups are deleted, rebuild groups. + { + g1s1.MarkPartiallyDependent(isolate); + g1s2.MarkPartiallyDependent(isolate); + g2s1.MarkPartiallyDependent(isolate); + g2s2.MarkPartiallyDependent(isolate); + g3s1.MarkPartiallyDependent(isolate); + g3s2.MarkPartiallyDependent(isolate); + Persistent<Value> g1_objects[] = { g1s1, g1s2 }; + Persistent<Value> g2_objects[] = { g2s1, g2s2 }; + Persistent<Value> g3_objects[] = { g3s1, g3s2 }; + V8::AddObjectGroup(g1_objects, 2); + g1s1->Set(v8_str("x"), g2s1); + V8::AddObjectGroup(g2_objects, 2); + g2s1->Set(v8_str("x"), g3s1); + V8::AddObjectGroup(g3_objects, 2); + g3s1->Set(v8_str("x"), g1s1); + } + + HEAP->CollectGarbage(i::NEW_SPACE); + + // All objects should be gone. 7 global handles in total. + CHECK_EQ(7, counter.NumberOfWeakCalls()); +} + + THREADED_TEST(ScriptException) { v8::HandleScope scope; LocalContext env; @@ -2388,20 +2557,19 @@ THREADED_TEST(ScriptException) { bool message_received; -static void check_message(v8::Handle<v8::Message> message, - v8::Handle<Value> data) { - CHECK_EQ(5.76, data->NumberValue()); +static void check_message_0(v8::Handle<v8::Message> message, + v8::Handle<Value> data) { CHECK_EQ(6.75, message->GetScriptResourceName()->NumberValue()); CHECK_EQ(7.56, message->GetScriptData()->NumberValue()); message_received = true; } -THREADED_TEST(MessageHandlerData) { +THREADED_TEST(MessageHandler0) { message_received = false; v8::HandleScope scope; CHECK(!message_received); - v8::V8::AddMessageListener(check_message, v8_num(5.76)); + v8::V8::AddMessageListener(check_message_0); LocalContext context; v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("6.75")); @@ -2411,7 +2579,56 @@ THREADED_TEST(MessageHandlerData) { script->Run(); CHECK(message_received); // clear out the message listener - v8::V8::RemoveMessageListeners(check_message); + v8::V8::RemoveMessageListeners(check_message_0); +} + + +static void check_message_1(v8::Handle<v8::Message> message, + v8::Handle<Value> data) { + CHECK(data->IsNumber()); + CHECK_EQ(1337, data->Int32Value()); + message_received = true; +} + + +TEST(MessageHandler1) { + message_received = false; + v8::HandleScope scope; + CHECK(!message_received); + v8::V8::AddMessageListener(check_message_1); + LocalContext context; + CompileRun("throw 1337;"); + CHECK(message_received); + // clear out the message listener + v8::V8::RemoveMessageListeners(check_message_1); +} + + +static void check_message_2(v8::Handle<v8::Message> message, + v8::Handle<Value> data) { + LocalContext context; + CHECK(data->IsObject()); + v8::Local<v8::Value> hidden_property = + v8::Object::Cast(*data)->GetHiddenValue(v8_str("hidden key")); + CHECK(v8_str("hidden value")->Equals(hidden_property)); + message_received = true; +} + + +TEST(MessageHandler2) { + message_received = false; + v8::HandleScope scope; + CHECK(!message_received); + v8::V8::AddMessageListener(check_message_2); + LocalContext context; + v8::Local<v8::Value> error = v8::Exception::Error(v8_str("custom error")); + v8::Object::Cast(*error)->SetHiddenValue(v8_str("hidden key"), + v8_str("hidden value")); + context->Global()->Set(v8_str("error"), error); + CompileRun("throw error;"); + CHECK(message_received); + // clear out the message listener + v8::V8::RemoveMessageListeners(check_message_2); } @@ -2697,7 +2914,7 @@ TEST(HugeConsStringOutOfMemory) { static const int K = 1024; v8::ResourceConstraints constraints; constraints.set_max_young_space_size(256 * K); - constraints.set_max_old_space_size(2 * K * K); + constraints.set_max_old_space_size(3 * K * K); v8::SetResourceConstraints(&constraints); // Execute a script that causes out of memory. @@ -3052,7 +3269,33 @@ TEST(APIThrowMessageOverwrittenToString) { "Number.prototype.toString = function() { return 'Whoops'; };" "ReferenceError.prototype.toString = Object.prototype.toString;"); CompileRun("asdf;"); - v8::V8::RemoveMessageListeners(check_message); + v8::V8::RemoveMessageListeners(check_reference_error_message); +} + + +static void check_custom_error_message( + v8::Handle<v8::Message> message, + v8::Handle<v8::Value> data) { + const char* uncaught_error = "Uncaught MyError toString"; + CHECK(message->Get()->Equals(v8_str(uncaught_error))); +} + + +TEST(CustomErrorToString) { + v8::HandleScope scope; + v8::V8::AddMessageListener(check_custom_error_message); + LocalContext context; + CompileRun( + "function MyError(name, message) { " + " this.name = name; " + " this.message = message; " + "} " + "MyError.prototype = Object.create(Error.prototype); " + "MyError.prototype.toString = function() { " + " return 'MyError toString'; " + "}; " + "throw new MyError('my name', 'my message'); "); + v8::V8::RemoveMessageListeners(check_custom_error_message); } @@ -3073,7 +3316,7 @@ TEST(APIThrowMessage) { LocalContext context(0, templ); CompileRun("ThrowFromC();"); CHECK(message_received); - v8::V8::RemoveMessageListeners(check_message); + v8::V8::RemoveMessageListeners(receive_message); } @@ -3091,7 +3334,7 @@ TEST(APIThrowMessageAndVerboseTryCatch) { CHECK(try_catch.HasCaught()); CHECK(result.IsEmpty()); CHECK(message_received); - v8::V8::RemoveMessageListeners(check_message); + v8::V8::RemoveMessageListeners(receive_message); } @@ -3710,6 +3953,36 @@ THREADED_TEST(SimplePropertyWrite) { } +THREADED_TEST(SetterOnly) { + v8::HandleScope scope; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + templ->SetAccessor(v8_str("x"), NULL, SetXValue, v8_str("donut")); + LocalContext context; + context->Global()->Set(v8_str("obj"), templ->NewInstance()); + Local<Script> script = Script::Compile(v8_str("obj.x = 4; obj.x")); + for (int i = 0; i < 10; i++) { + CHECK(xValue.IsEmpty()); + script->Run(); + CHECK_EQ(v8_num(4), xValue); + xValue.Dispose(); + xValue = v8::Persistent<Value>(); + } +} + + +THREADED_TEST(NoAccessors) { + v8::HandleScope scope; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + templ->SetAccessor(v8_str("x"), NULL, NULL, v8_str("donut")); + LocalContext context; + context->Global()->Set(v8_str("obj"), templ->NewInstance()); + Local<Script> script = Script::Compile(v8_str("obj.x = 4; obj.x")); + for (int i = 0; i < 10; i++) { + script->Run(); + } +} + + static v8::Handle<Value> XPropertyGetter(Local<String> property, const AccessorInfo& info) { ApiTestFuzzer::Fuzz(); @@ -4605,6 +4878,18 @@ THREADED_TEST(SimpleExtensions) { } +THREADED_TEST(NullExtensions) { + v8::HandleScope handle_scope; + v8::RegisterExtension(new Extension("nulltest", NULL)); + const char* extension_names[] = { "nulltest" }; + v8::ExtensionConfiguration extensions(1, extension_names); + v8::Handle<Context> context = Context::New(&extensions); + Context::Scope lock(context); + v8::Handle<Value> result = Script::Compile(v8_str("1+3"))->Run(); + CHECK_EQ(result, v8::Integer::New(4)); +} + + static const char* kEmbeddedExtensionSource = "function Ret54321(){return 54321;}~~@@$" "$%% THIS IS A SERIES OF NON-NULL-TERMINATED STRINGS."; @@ -5014,7 +5299,6 @@ TEST(RegexpOutOfMemory) { static void MissingScriptInfoMessageListener(v8::Handle<v8::Message> message, v8::Handle<Value> data) { - CHECK_EQ(v8::Undefined(), data); CHECK(message->GetScriptResourceName()->IsUndefined()); CHECK_EQ(v8::Undefined(), message->GetScriptResourceName()); message->GetLineNumber(); @@ -5126,18 +5410,28 @@ THREADED_TEST(IndependentWeakHandle) { v8::Persistent<Context> context = Context::New(); Context::Scope context_scope(context); - v8::Persistent<v8::Object> object_a; + v8::Persistent<v8::Object> object_a, object_b; { v8::HandleScope handle_scope; object_a = v8::Persistent<v8::Object>::New(v8::Object::New()); + object_b = v8::Persistent<v8::Object>::New(v8::Object::New()); } + v8::Isolate* isolate = v8::Isolate::GetCurrent(); bool object_a_disposed = false; + bool object_b_disposed = false; object_a.MakeWeak(&object_a_disposed, &DisposeAndSetFlag); + object_b.MakeWeak(&object_b_disposed, &DisposeAndSetFlag); + CHECK(!object_a.IsIndependent()); + CHECK(!object_b.IsIndependent(isolate)); object_a.MarkIndependent(); + object_b.MarkIndependent(isolate); + CHECK(object_a.IsIndependent()); + CHECK(object_b.IsIndependent(isolate)); HEAP->PerformScavenge(); CHECK(object_a_disposed); + CHECK(object_b_disposed); } @@ -5218,7 +5512,7 @@ THREADED_TEST(IndependentHandleRevival) { object.MarkIndependent(); HEAP->PerformScavenge(); CHECK(revived); - HEAP->CollectAllGarbage(true); + HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); { v8::HandleScope handle_scope; v8::Local<String> y_str = v8_str("y"); @@ -5543,6 +5837,7 @@ THREADED_TEST(StringWrite) { v8::Handle<String> str = v8_str("abcde"); // abc<Icelandic eth><Unicode snowman>. v8::Handle<String> str2 = v8_str("abc\303\260\342\230\203"); + v8::Handle<String> str3 = v8::String::New("abc\0def", 7); const int kStride = 4; // Must match stride in for loops in JS below. CompileRun( "var left = '';" @@ -5753,6 +6048,28 @@ THREADED_TEST(StringWrite) { CHECK_NE(0, strcmp(utf8buf, "abc\303\260\342\230\203")); utf8buf[8] = '\0'; CHECK_EQ(0, strcmp(utf8buf, "abc\303\260\342\230\203")); + + memset(utf8buf, 0x1, sizeof(utf8buf)); + utf8buf[5] = 'X'; + len = str->WriteUtf8(utf8buf, sizeof(utf8buf), &charlen, + String::NO_NULL_TERMINATION); + CHECK_EQ(5, len); + CHECK_EQ('X', utf8buf[5]); // Test that the sixth character is untouched. + CHECK_EQ(5, charlen); + utf8buf[5] = '\0'; + CHECK_EQ(0, strcmp(utf8buf, "abcde")); + + memset(buf, 0x1, sizeof(buf)); + len = str3->WriteAscii(buf); + CHECK_EQ(7, len); + CHECK_EQ(0, strcmp("abc def", buf)); + + memset(buf, 0x1, sizeof(buf)); + len = str3->WriteAscii(buf, 0, -1, String::PRESERVE_ASCII_NULL); + CHECK_EQ(7, len); + CHECK_EQ(0, strcmp("abc", buf)); + CHECK_EQ(0, buf[3]); + CHECK_EQ(0, strcmp("def", buf + 4)); } @@ -7662,7 +7979,7 @@ THREADED_TEST(ShadowObject) { value = Script::Compile(v8_str("f()"))->Run(); CHECK_EQ(42, value->Int32Value()); - Script::Compile(v8_str("y = 42"))->Run(); + Script::Compile(v8_str("y = 43"))->Run(); CHECK_EQ(1, shadow_y_setter_call_count); value = Script::Compile(v8_str("y"))->Run(); CHECK_EQ(1, shadow_y_getter_call_count); @@ -9370,7 +9687,8 @@ static void GenerateSomeGarbage() { v8::Handle<v8::Value> DirectApiCallback(const v8::Arguments& args) { static int count = 0; if (count++ % 3 == 0) { - HEAP-> CollectAllGarbage(true); // This should move the stub + HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); + // This should move the stub GenerateSomeGarbage(); // This should ensure the old stub memory is flushed } return v8::Handle<v8::Value>(); @@ -9425,7 +9743,7 @@ THREADED_TEST(CallICFastApi_DirectCall_Throw) { v8::Handle<v8::Value> DirectGetterCallback(Local<String> name, const v8::AccessorInfo& info) { if (++p_getter_count % 3 == 0) { - HEAP->CollectAllGarbage(true); + HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); GenerateSomeGarbage(); } return v8::Handle<v8::Value>(); @@ -10260,6 +10578,7 @@ static v8::Handle<Value> ChildGetter(Local<String> name, THREADED_TEST(Overriding) { + i::FLAG_es5_readonly = true; v8::HandleScope scope; LocalContext context; @@ -10306,11 +10625,11 @@ THREADED_TEST(Overriding) { value = v8_compile("o.g")->Run(); CHECK_EQ(42, value->Int32Value()); - // Check 'h' can be shadowed. + // Check that 'h' cannot be shadowed. value = v8_compile("o.h = 3; o.h")->Run(); - CHECK_EQ(3, value->Int32Value()); + CHECK_EQ(1, value->Int32Value()); - // Check 'i' is cannot be shadowed or changed. + // Check that 'i' cannot be shadowed or changed. value = v8_compile("o.i = 3; o.i")->Run(); CHECK_EQ(42, value->Int32Value()); } @@ -10721,18 +11040,21 @@ TEST(DontLeakGlobalObjects) { { v8::HandleScope scope; LocalContext context; } + v8::V8::ContextDisposedNotification(); CheckSurvivingGlobalObjectsCount(0); { v8::HandleScope scope; LocalContext context; v8_compile("Date")->Run(); } + v8::V8::ContextDisposedNotification(); CheckSurvivingGlobalObjectsCount(0); { v8::HandleScope scope; LocalContext context; v8_compile("/aaa/")->Run(); } + v8::V8::ContextDisposedNotification(); CheckSurvivingGlobalObjectsCount(0); { v8::HandleScope scope; @@ -10741,6 +11063,7 @@ TEST(DontLeakGlobalObjects) { LocalContext context(&extensions); v8_compile("gc();")->Run(); } + v8::V8::ContextDisposedNotification(); CheckSurvivingGlobalObjectsCount(0); } } @@ -10871,6 +11194,307 @@ THREADED_TEST(NestedHandleScopeAndContexts) { } +static i::Handle<i::JSFunction>* foo_ptr = NULL; +static int foo_count = 0; +static i::Handle<i::JSFunction>* bar_ptr = NULL; +static int bar_count = 0; + + +static void entry_hook(uintptr_t function, + uintptr_t return_addr_location) { + i::Code* code = i::Code::GetCodeFromTargetAddress( + reinterpret_cast<i::Address>(function)); + CHECK(code != NULL); + + if (bar_ptr != NULL && code == (*bar_ptr)->code()) + ++bar_count; + + if (foo_ptr != NULL && code == (*foo_ptr)->code()) + ++foo_count; + + // TODO(siggi): Verify return_addr_location. + // This can be done by capturing JitCodeEvents, but requires an ordered + // collection. +} + + +static void RunLoopInNewEnv() { + bar_ptr = NULL; + foo_ptr = NULL; + + v8::HandleScope outer; + v8::Persistent<Context> env = Context::New(); + env->Enter(); + + const char* script = + "function bar() {" + " var sum = 0;" + " for (i = 0; i < 100; ++i)" + " sum = foo(i);" + " return sum;" + "}" + "function foo(i) { return i * i; }"; + CompileRun(script); + i::Handle<i::JSFunction> bar = + i::Handle<i::JSFunction>::cast( + v8::Utils::OpenHandle(*env->Global()->Get(v8_str("bar")))); + ASSERT(*bar); + + i::Handle<i::JSFunction> foo = + i::Handle<i::JSFunction>::cast( + v8::Utils::OpenHandle(*env->Global()->Get(v8_str("foo")))); + ASSERT(*foo); + + bar_ptr = &bar; + foo_ptr = &foo; + + v8::Handle<v8::Value> value = CompileRun("bar();"); + CHECK(value->IsNumber()); + CHECK_EQ(9801.0, v8::Number::Cast(*value)->Value()); + + // Test the optimized codegen path. + value = CompileRun("%OptimizeFunctionOnNextCall(foo);" + "bar();"); + CHECK(value->IsNumber()); + CHECK_EQ(9801.0, v8::Number::Cast(*value)->Value()); + + env->Exit(); +} + + +TEST(SetFunctionEntryHook) { + i::FLAG_allow_natives_syntax = true; + + // Test setting and resetting the entry hook. + // Nulling it should always succeed. + CHECK(v8::V8::SetFunctionEntryHook(NULL)); + + CHECK(v8::V8::SetFunctionEntryHook(entry_hook)); + // Setting a hook while one's active should fail. + CHECK_EQ(false, v8::V8::SetFunctionEntryHook(entry_hook)); + + CHECK(v8::V8::SetFunctionEntryHook(NULL)); + + // Reset the entry count to zero and set the entry hook. + bar_count = 0; + foo_count = 0; + CHECK(v8::V8::SetFunctionEntryHook(entry_hook)); + RunLoopInNewEnv(); + + CHECK_EQ(2, bar_count); + CHECK_EQ(200, foo_count); + + // Clear the entry hook and count. + bar_count = 0; + foo_count = 0; + v8::V8::SetFunctionEntryHook(NULL); + + // Clear the compilation cache to make sure we don't reuse the + // functions from the previous invocation. + v8::internal::Isolate::Current()->compilation_cache()->Clear(); + + // Verify that entry hooking is now disabled. + RunLoopInNewEnv(); + CHECK_EQ(0u, bar_count); + CHECK_EQ(0u, foo_count); +} + + +static i::HashMap* code_map = NULL; +static int saw_bar = 0; +static int move_events = 0; + + +static bool FunctionNameIs(const char* expected, + const v8::JitCodeEvent* event) { + // Log lines for functions are of the general form: + // "LazyCompile:<type><function_name>", where the type is one of + // "*", "~" or "". + static const char kPreamble[] = "LazyCompile:"; + static size_t kPreambleLen = sizeof(kPreamble) - 1; + + if (event->name.len < sizeof(kPreamble) - 1 || + strncmp(kPreamble, event->name.str, kPreambleLen) != 0) { + return false; + } + + const char* tail = event->name.str + kPreambleLen; + size_t tail_len = event->name.len - kPreambleLen; + size_t expected_len = strlen(expected); + if (tail_len == expected_len + 1) { + if (*tail == '*' || *tail == '~') { + --tail_len; + ++tail; + } else { + return false; + } + } + + if (tail_len != expected_len) + return false; + + return strncmp(tail, expected, expected_len) == 0; +} + + +static void event_handler(const v8::JitCodeEvent* event) { + CHECK(event != NULL); + CHECK(code_map != NULL); + + switch (event->type) { + case v8::JitCodeEvent::CODE_ADDED: { + CHECK(event->code_start != NULL); + CHECK_NE(0, static_cast<int>(event->code_len)); + CHECK(event->name.str != NULL); + i::HashMap::Entry* entry = + code_map->Lookup(event->code_start, + i::ComputePointerHash(event->code_start), + true); + entry->value = reinterpret_cast<void*>(event->code_len); + + if (FunctionNameIs("bar", event)) { + ++saw_bar; + } + } + break; + + case v8::JitCodeEvent::CODE_MOVED: { + uint32_t hash = i::ComputePointerHash(event->code_start); + // We would like to never see code move that we haven't seen before, + // but the code creation event does not happen until the line endings + // have been calculated (this is so that we can report the line in the + // script at which the function source is found, see + // Compiler::RecordFunctionCompilation) and the line endings + // calculations can cause a GC, which can move the newly created code + // before its existence can be logged. + i::HashMap::Entry* entry = + code_map->Lookup(event->code_start, hash, false); + if (entry != NULL) { + ++move_events; + + CHECK_EQ(reinterpret_cast<void*>(event->code_len), entry->value); + code_map->Remove(event->code_start, hash); + + entry = code_map->Lookup(event->new_code_start, + i::ComputePointerHash(event->new_code_start), + true); + CHECK(entry != NULL); + entry->value = reinterpret_cast<void*>(event->code_len); + } + } + break; + + case v8::JitCodeEvent::CODE_REMOVED: + // Object/code removal events are currently not dispatched from the GC. + CHECK(false); + break; + default: + // Impossible event. + CHECK(false); + break; + } +} + + +// Implemented in the test-alloc.cc test suite. +void SimulateFullSpace(i::PagedSpace* space); + + +static bool MatchPointers(void* key1, void* key2) { + return key1 == key2; +} + + +TEST(SetJitCodeEventHandler) { + const char* script = + "function bar() {" + " var sum = 0;" + " for (i = 0; i < 100; ++i)" + " sum = foo(i);" + " return sum;" + "}" + "function foo(i) { return i * i; };" + "bar();"; + + // Run this test in a new isolate to make sure we don't + // have remnants of state from other code. + v8::Isolate* isolate = v8::Isolate::New(); + isolate->Enter(); + + { + i::HashMap code(MatchPointers); + code_map = &code; + + saw_bar = 0; + move_events = 0; + + i::FLAG_stress_compaction = true; + V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault, event_handler); + + v8::HandleScope scope; + // Generate new code objects sparsely distributed across several + // different fragmented code-space pages. + const int kIterations = 10; + for (int i = 0; i < kIterations; ++i) { + LocalContext env; + + v8::Handle<v8::Script> compiled_script; + { + i::AlwaysAllocateScope always_allocate; + SimulateFullSpace(HEAP->code_space()); + compiled_script = v8_compile(script); + } + compiled_script->Run(); + + // Clear the compilation cache to get more wastage. + ISOLATE->compilation_cache()->Clear(); + } + + // Force code movement. + HEAP->CollectAllAvailableGarbage("TestSetJitCodeEventHandler"); + + CHECK_LE(kIterations, saw_bar); + CHECK_NE(0, move_events); + + code_map = NULL; + V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault, NULL); + } + + isolate->Exit(); + isolate->Dispose(); + + // Do this in a new isolate. + isolate = v8::Isolate::New(); + isolate->Enter(); + + // Verify that we get callbacks for existing code objects when we + // request enumeration of existing code. + { + v8::HandleScope scope; + LocalContext env; + CompileRun(script); + + // Now get code through initial iteration. + i::HashMap code(MatchPointers); + code_map = &code; + + V8::SetJitCodeEventHandler(v8::kJitCodeEventEnumExisting, event_handler); + V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault, NULL); + + code_map = NULL; + + // We expect that we got some events. Note that if we could get code removal + // notifications, we could compare two collections, one created by listening + // from the time of creation of an isolate, and the other by subscribing + // with EnumExisting. + CHECK_NE(0, code.occupancy()); + } + + isolate->Exit(); + isolate->Dispose(); +} + + static int64_t cast(intptr_t x) { return static_cast<int64_t>(x); } @@ -12040,7 +12664,7 @@ class RegExpStringModificationTest { // Inject the input as a global variable. i::Handle<i::String> input_name = FACTORY->NewStringFromAscii(i::Vector<const char>("input", 5)); - i::Isolate::Current()->global_context()->global()->SetProperty( + i::Isolate::Current()->native_context()->global_object()->SetProperty( *input_name, *input_, NONE, @@ -12148,9 +12772,10 @@ TEST(RegExpStringModification) { } -// Test that we can set a property on the global object even if there +// Test that we cannot set a property on the global object if there // is a read-only property in the prototype chain. TEST(ReadOnlyPropertyInGlobalProto) { + i::FLAG_es5_readonly = true; v8::HandleScope scope; v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(); LocalContext context(0, templ); @@ -12162,12 +12787,13 @@ TEST(ReadOnlyPropertyInGlobalProto) { // Check without 'eval' or 'with'. v8::Handle<v8::Value> res = CompileRun("function f() { x = 42; return x; }; f()"); + CHECK_EQ(v8::Integer::New(0), res); // Check with 'eval'. - res = CompileRun("function f() { eval('1'); y = 42; return y; }; f()"); - CHECK_EQ(v8::Integer::New(42), res); + res = CompileRun("function f() { eval('1'); y = 43; return y; }; f()"); + CHECK_EQ(v8::Integer::New(0), res); // Check with 'with'. - res = CompileRun("function f() { with (this) { y = 42 }; return y; }; f()"); - CHECK_EQ(v8::Integer::New(42), res); + res = CompileRun("function f() { with (this) { y = 44 }; return y; }; f()"); + CHECK_EQ(v8::Integer::New(0), res); } static int force_set_set_count = 0; @@ -13617,6 +14243,41 @@ THREADED_TEST(ExternalArrayInfo) { } +void ExternalArrayLimitTestHelper(v8::ExternalArrayType array_type, int size) { + v8::Handle<v8::Object> obj = v8::Object::New(); + v8::V8::SetFatalErrorHandler(StoringErrorCallback); + last_location = last_message = NULL; + obj->SetIndexedPropertiesToExternalArrayData(NULL, array_type, size); + CHECK(!obj->HasIndexedPropertiesInExternalArrayData()); + CHECK_NE(NULL, last_location); + CHECK_NE(NULL, last_message); +} + + +TEST(ExternalArrayLimits) { + v8::HandleScope scope; + LocalContext context; + ExternalArrayLimitTestHelper(v8::kExternalByteArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalByteArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalUnsignedByteArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalUnsignedByteArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalShortArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalShortArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalUnsignedShortArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalUnsignedShortArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalIntArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalIntArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalUnsignedIntArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalUnsignedIntArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalFloatArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalFloatArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalDoubleArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalDoubleArray, 0xffffffff); + ExternalArrayLimitTestHelper(v8::kExternalPixelArray, 0x40000000); + ExternalArrayLimitTestHelper(v8::kExternalPixelArray, 0xffffffff); +} + + THREADED_TEST(ScriptContextDependence) { v8::HandleScope scope; LocalContext c1; @@ -13995,6 +14656,89 @@ TEST(SourceURLInStackTrace) { } +v8::Handle<Value> AnalyzeStackOfInlineScriptWithSourceURL( + const v8::Arguments& args) { + v8::HandleScope scope; + v8::Handle<v8::StackTrace> stackTrace = + v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed); + CHECK_EQ(4, stackTrace->GetFrameCount()); + v8::Handle<v8::String> url = v8_str("url"); + for (int i = 0; i < 3; i++) { + v8::Handle<v8::String> name = + stackTrace->GetFrame(i)->GetScriptNameOrSourceURL(); + CHECK(!name.IsEmpty()); + CHECK_EQ(url, name); + } + return v8::Undefined(); +} + + +TEST(InlineScriptWithSourceURLInStackTrace) { + v8::HandleScope scope; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + templ->Set(v8_str("AnalyzeStackOfInlineScriptWithSourceURL"), + v8::FunctionTemplate::New( + AnalyzeStackOfInlineScriptWithSourceURL)); + LocalContext context(0, templ); + + const char *source = + "function outer() {\n" + "function bar() {\n" + " AnalyzeStackOfInlineScriptWithSourceURL();\n" + "}\n" + "function foo() {\n" + "\n" + " bar();\n" + "}\n" + "foo();\n" + "}\n" + "outer()\n" + "//@ sourceURL=source_url"; + CHECK(CompileRunWithOrigin(source, "url", 0, 1)->IsUndefined()); +} + + +v8::Handle<Value> AnalyzeStackOfDynamicScriptWithSourceURL( + const v8::Arguments& args) { + v8::HandleScope scope; + v8::Handle<v8::StackTrace> stackTrace = + v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed); + CHECK_EQ(4, stackTrace->GetFrameCount()); + v8::Handle<v8::String> url = v8_str("source_url"); + for (int i = 0; i < 3; i++) { + v8::Handle<v8::String> name = + stackTrace->GetFrame(i)->GetScriptNameOrSourceURL(); + CHECK(!name.IsEmpty()); + CHECK_EQ(url, name); + } + return v8::Undefined(); +} + + +TEST(DynamicWithSourceURLInStackTrace) { + v8::HandleScope scope; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + templ->Set(v8_str("AnalyzeStackOfDynamicScriptWithSourceURL"), + v8::FunctionTemplate::New( + AnalyzeStackOfDynamicScriptWithSourceURL)); + LocalContext context(0, templ); + + const char *source = + "function outer() {\n" + "function bar() {\n" + " AnalyzeStackOfDynamicScriptWithSourceURL();\n" + "}\n" + "function foo() {\n" + "\n" + " bar();\n" + "}\n" + "foo();\n" + "}\n" + "outer()\n" + "//@ sourceURL=source_url"; + CHECK(CompileRunWithOrigin(source, "url", 0, 0)->IsUndefined()); +} + static void CreateGarbageInOldSpace() { v8::HandleScope scope; i::AlwaysAllocateScope always_allocate; @@ -14182,11 +14926,12 @@ THREADED_TEST(GetHeapStatistics) { class VisitorImpl : public v8::ExternalResourceVisitor { public: - VisitorImpl(TestResource* r1, TestResource* r2) - : resource1_(r1), - resource2_(r2), - found_resource1_(false), - found_resource2_(false) {} + explicit VisitorImpl(TestResource** resource) { + for (int i = 0; i < 4; i++) { + resource_[i] = resource[i]; + found_resource_[i] = false; + } + } virtual ~VisitorImpl() {} virtual void VisitExternalString(v8::Handle<v8::String> string) { if (!string->IsExternal()) { @@ -14196,25 +14941,22 @@ class VisitorImpl : public v8::ExternalResourceVisitor { v8::String::ExternalStringResource* resource = string->GetExternalStringResource(); CHECK(resource); - if (resource1_ == resource) { - CHECK(!found_resource1_); - found_resource1_ = true; - } - if (resource2_ == resource) { - CHECK(!found_resource2_); - found_resource2_ = true; + for (int i = 0; i < 4; i++) { + if (resource_[i] == resource) { + CHECK(!found_resource_[i]); + found_resource_[i] = true; + } } } void CheckVisitedResources() { - CHECK(found_resource1_); - CHECK(found_resource2_); + for (int i = 0; i < 4; i++) { + CHECK(found_resource_[i]); + } } private: - v8::String::ExternalStringResource* resource1_; - v8::String::ExternalStringResource* resource2_; - bool found_resource1_; - bool found_resource2_; + v8::String::ExternalStringResource* resource_[4]; + bool found_resource_[4]; }; TEST(VisitExternalStrings) { @@ -14222,16 +14964,33 @@ TEST(VisitExternalStrings) { LocalContext env; const char* string = "Some string"; uint16_t* two_byte_string = AsciiToTwoByteString(string); - TestResource* resource1 = new TestResource(two_byte_string); - v8::Local<v8::String> string1 = v8::String::NewExternal(resource1); - TestResource* resource2 = new TestResource(two_byte_string); - v8::Local<v8::String> string2 = v8::String::NewExternal(resource2); - - // We need to add usages for string1 and string2 to avoid warnings in GCC 4.7 + TestResource* resource[4]; + resource[0] = new TestResource(two_byte_string); + v8::Local<v8::String> string0 = v8::String::NewExternal(resource[0]); + resource[1] = new TestResource(two_byte_string); + v8::Local<v8::String> string1 = v8::String::NewExternal(resource[1]); + + // Externalized symbol. + resource[2] = new TestResource(two_byte_string); + v8::Local<v8::String> string2 = v8::String::NewSymbol(string); + CHECK(string2->MakeExternal(resource[2])); + + // Symbolized External. + resource[3] = new TestResource(AsciiToTwoByteString("Some other string")); + v8::Local<v8::String> string3 = v8::String::NewExternal(resource[3]); + HEAP->CollectAllAvailableGarbage(); // Tenure string. + // Turn into a symbol. + i::Handle<i::String> string3_i = v8::Utils::OpenHandle(*string3); + CHECK(!HEAP->LookupSymbol(*string3_i)->IsFailure()); + CHECK(string3_i->IsSymbol()); + + // We need to add usages for string* to avoid warnings in GCC 4.7 + CHECK(string0->IsExternal()); CHECK(string1->IsExternal()); CHECK(string2->IsExternal()); + CHECK(string3->IsExternal()); - VisitorImpl visitor(resource1, resource2); + VisitorImpl visitor(resource); v8::V8::VisitExternalResources(&visitor); visitor.CheckVisitedResources(); } @@ -14396,7 +15155,6 @@ TEST(Regress528) { v8::Persistent<Context> context; v8::Persistent<Context> other_context; int gc_count; - bool snapshot_enabled = i::Snapshot::IsEnabled(); // Create a context used to keep the code from aging in the compilation // cache. @@ -14416,15 +15174,16 @@ TEST(Regress528) { context->Exit(); } context.Dispose(); + v8::V8::ContextDisposedNotification(); for (gc_count = 1; gc_count < 10; gc_count++) { other_context->Enter(); CompileRun(source_simple); other_context->Exit(); HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); - if (GetGlobalObjectsCount() == (snapshot_enabled ? 2 : 1)) break; + if (GetGlobalObjectsCount() == 1) break; } CHECK_GE(2, gc_count); - CHECK_EQ((snapshot_enabled ? 2 : 1), GetGlobalObjectsCount()); + CHECK_EQ(1, GetGlobalObjectsCount()); // Eval in a function creates reference from the compilation cache to the // global object. @@ -14438,15 +15197,16 @@ TEST(Regress528) { context->Exit(); } context.Dispose(); + v8::V8::ContextDisposedNotification(); for (gc_count = 1; gc_count < 10; gc_count++) { other_context->Enter(); CompileRun(source_eval); other_context->Exit(); HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); - if (GetGlobalObjectsCount() == (snapshot_enabled ? 2 : 1)) break; + if (GetGlobalObjectsCount() == 1) break; } CHECK_GE(2, gc_count); - CHECK_EQ((snapshot_enabled ? 2 : 1), GetGlobalObjectsCount()); + CHECK_EQ(1, GetGlobalObjectsCount()); // Looking up the line number for an exception creates reference from the // compilation cache to the global object. @@ -14465,17 +15225,19 @@ TEST(Regress528) { context->Exit(); } context.Dispose(); + v8::V8::ContextDisposedNotification(); for (gc_count = 1; gc_count < 10; gc_count++) { other_context->Enter(); CompileRun(source_exception); other_context->Exit(); HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); - if (GetGlobalObjectsCount() == (snapshot_enabled ? 2 : 1)) break; + if (GetGlobalObjectsCount() == 1) break; } CHECK_GE(2, gc_count); - CHECK_EQ((snapshot_enabled ? 2 : 1), GetGlobalObjectsCount()); + CHECK_EQ(1, GetGlobalObjectsCount()); other_context.Dispose(); + v8::V8::ContextDisposedNotification(); } @@ -14565,6 +15327,8 @@ THREADED_TEST(FunctionGetScriptId) { static v8::Handle<Value> GetterWhichReturns42(Local<String> name, const AccessorInfo& info) { + CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject()); + CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject()); return v8_num(42); } @@ -14572,7 +15336,29 @@ static v8::Handle<Value> GetterWhichReturns42(Local<String> name, static void SetterWhichSetsYOnThisTo23(Local<String> name, Local<Value> value, const AccessorInfo& info) { + CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject()); + CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject()); + info.This()->Set(v8_str("y"), v8_num(23)); +} + + +Handle<Value> FooGetInterceptor(Local<String> name, + const AccessorInfo& info) { + CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject()); + CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject()); + if (!name->Equals(v8_str("foo"))) return Handle<Value>(); + return v8_num(42); +} + + +Handle<Value> FooSetInterceptor(Local<String> name, + Local<Value> value, + const AccessorInfo& info) { + CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject()); + CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject()); + if (!name->Equals(v8_str("foo"))) return Handle<Value>(); info.This()->Set(v8_str("y"), v8_num(23)); + return v8_num(23); } @@ -15606,6 +16392,45 @@ TEST(DontDeleteCellLoadICAPI) { } +class Visitor42 : public v8::PersistentHandleVisitor { + public: + explicit Visitor42(v8::Persistent<v8::Object> object) + : counter_(0), object_(object) { } + + virtual void VisitPersistentHandle(Persistent<Value> value, + uint16_t class_id) { + if (class_id == 42) { + CHECK(value->IsObject()); + v8::Persistent<v8::Object> visited = + v8::Persistent<v8::Object>::Cast(value); + CHECK_EQ(42, visited.WrapperClassId()); + CHECK_EQ(object_, visited); + ++counter_; + } + } + + int counter_; + v8::Persistent<v8::Object> object_; +}; + + +TEST(PersistentHandleVisitor) { + v8::HandleScope scope; + LocalContext context; + v8::Persistent<v8::Object> object = + v8::Persistent<v8::Object>::New(v8::Object::New()); + CHECK_EQ(0, object.WrapperClassId()); + object.SetWrapperClassId(42); + CHECK_EQ(42, object.WrapperClassId()); + + Visitor42 visitor(object); + v8::V8::VisitHandlesWithClassIds(&visitor); + CHECK_EQ(1, visitor.counter_); + + object.Dispose(); +} + + TEST(RegExp) { v8::HandleScope scope; LocalContext context; @@ -16041,6 +16866,24 @@ THREADED_TEST(AllowCodeGenFromStrings) { } +TEST(SetErrorMessageForCodeGenFromStrings) { + v8::HandleScope scope; + LocalContext context; + TryCatch try_catch; + + Handle<String> message = v8_str("Message") ; + Handle<String> expected_message = v8_str("Uncaught EvalError: Message"); + V8::SetAllowCodeGenerationFromStringsCallback(&CodeGenerationDisallowed); + context->AllowCodeGenerationFromStrings(false); + context->SetErrorMessageForCodeGenerationFromStrings(message); + Handle<Value> result = CompileRun("eval('42')"); + CHECK(result.IsEmpty()); + CHECK(try_catch.HasCaught()); + Handle<String> actual_message = try_catch.Message()->Get(); + CHECK(expected_message->Equals(actual_message)); +} + + static v8::Handle<Value> NonObjectThis(const v8::Arguments& args) { return v8::Undefined(); } @@ -16094,7 +16937,8 @@ THREADED_TEST(Regress1516) { CHECK_LE(1, elements); } - i::Isolate::Current()->heap()->CollectAllGarbage(true); + i::Isolate::Current()->heap()->CollectAllGarbage( + i::Heap::kAbortIncrementalMarkingMask); { i::Object* raw_map_cache = i::Isolate::Current()->context()->map_cache(); if (raw_map_cache != i::Isolate::Current()->heap()->undefined_value()) { i::MapCache* map_cache = i::MapCache::cast(raw_map_cache); @@ -16594,3 +17438,459 @@ TEST(StringEmpty) { CHECK(v8::String::Empty(isolate).IsEmpty()); CHECK_EQ(3, fatal_error_callback_counter); } + + +static int instance_checked_getter_count = 0; +static Handle<Value> InstanceCheckedGetter(Local<String> name, + const AccessorInfo& info) { + CHECK_EQ(name, v8_str("foo")); + instance_checked_getter_count++; + return v8_num(11); +} + + +static int instance_checked_setter_count = 0; +static void InstanceCheckedSetter(Local<String> name, + Local<Value> value, + const AccessorInfo& info) { + CHECK_EQ(name, v8_str("foo")); + CHECK_EQ(value, v8_num(23)); + instance_checked_setter_count++; +} + + +static void CheckInstanceCheckedResult(int getters, + int setters, + bool expects_callbacks, + TryCatch* try_catch) { + if (expects_callbacks) { + CHECK(!try_catch->HasCaught()); + CHECK_EQ(getters, instance_checked_getter_count); + CHECK_EQ(setters, instance_checked_setter_count); + } else { + CHECK(try_catch->HasCaught()); + CHECK_EQ(0, instance_checked_getter_count); + CHECK_EQ(0, instance_checked_setter_count); + } + try_catch->Reset(); +} + + +static void CheckInstanceCheckedAccessors(bool expects_callbacks) { + instance_checked_getter_count = 0; + instance_checked_setter_count = 0; + TryCatch try_catch; + + // Test path through generic runtime code. + CompileRun("obj.foo"); + CheckInstanceCheckedResult(1, 0, expects_callbacks, &try_catch); + CompileRun("obj.foo = 23"); + CheckInstanceCheckedResult(1, 1, expects_callbacks, &try_catch); + + // Test path through generated LoadIC and StoredIC. + CompileRun("function test_get(o) { o.foo; }" + "test_get(obj);"); + CheckInstanceCheckedResult(2, 1, expects_callbacks, &try_catch); + CompileRun("test_get(obj);"); + CheckInstanceCheckedResult(3, 1, expects_callbacks, &try_catch); + CompileRun("test_get(obj);"); + CheckInstanceCheckedResult(4, 1, expects_callbacks, &try_catch); + CompileRun("function test_set(o) { o.foo = 23; }" + "test_set(obj);"); + CheckInstanceCheckedResult(4, 2, expects_callbacks, &try_catch); + CompileRun("test_set(obj);"); + CheckInstanceCheckedResult(4, 3, expects_callbacks, &try_catch); + CompileRun("test_set(obj);"); + CheckInstanceCheckedResult(4, 4, expects_callbacks, &try_catch); + + // Test path through optimized code. + CompileRun("%OptimizeFunctionOnNextCall(test_get);" + "test_get(obj);"); + CheckInstanceCheckedResult(5, 4, expects_callbacks, &try_catch); + CompileRun("%OptimizeFunctionOnNextCall(test_set);" + "test_set(obj);"); + CheckInstanceCheckedResult(5, 5, expects_callbacks, &try_catch); + + // Cleanup so that closures start out fresh in next check. + CompileRun("%DeoptimizeFunction(test_get);" + "%ClearFunctionTypeFeedback(test_get);" + "%DeoptimizeFunction(test_set);" + "%ClearFunctionTypeFeedback(test_set);"); +} + + +THREADED_TEST(InstanceCheckOnInstanceAccessor) { + v8::internal::FLAG_allow_natives_syntax = true; + v8::HandleScope scope; + LocalContext context; + + Local<FunctionTemplate> templ = FunctionTemplate::New(); + Local<ObjectTemplate> inst = templ->InstanceTemplate(); + inst->SetAccessor(v8_str("foo"), + InstanceCheckedGetter, InstanceCheckedSetter, + Handle<Value>(), + v8::DEFAULT, + v8::None, + v8::AccessorSignature::New(templ)); + context->Global()->Set(v8_str("f"), templ->GetFunction()); + + printf("Testing positive ...\n"); + CompileRun("var obj = new f();"); + CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj")))); + CheckInstanceCheckedAccessors(true); + + printf("Testing negative ...\n"); + CompileRun("var obj = {};" + "obj.__proto__ = new f();"); + CHECK(!templ->HasInstance(context->Global()->Get(v8_str("obj")))); + CheckInstanceCheckedAccessors(false); +} + + +THREADED_TEST(InstanceCheckOnInstanceAccessorWithInterceptor) { + v8::internal::FLAG_allow_natives_syntax = true; + v8::HandleScope scope; + LocalContext context; + + Local<FunctionTemplate> templ = FunctionTemplate::New(); + Local<ObjectTemplate> inst = templ->InstanceTemplate(); + AddInterceptor(templ, EmptyInterceptorGetter, EmptyInterceptorSetter); + inst->SetAccessor(v8_str("foo"), + InstanceCheckedGetter, InstanceCheckedSetter, + Handle<Value>(), + v8::DEFAULT, + v8::None, + v8::AccessorSignature::New(templ)); + context->Global()->Set(v8_str("f"), templ->GetFunction()); + + printf("Testing positive ...\n"); + CompileRun("var obj = new f();"); + CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj")))); + CheckInstanceCheckedAccessors(true); + + printf("Testing negative ...\n"); + CompileRun("var obj = {};" + "obj.__proto__ = new f();"); + CHECK(!templ->HasInstance(context->Global()->Get(v8_str("obj")))); + CheckInstanceCheckedAccessors(false); +} + + +THREADED_TEST(InstanceCheckOnPrototypeAccessor) { + v8::internal::FLAG_allow_natives_syntax = true; + v8::HandleScope scope; + LocalContext context; + + Local<FunctionTemplate> templ = FunctionTemplate::New(); + Local<ObjectTemplate> proto = templ->PrototypeTemplate(); + proto->SetAccessor(v8_str("foo"), + InstanceCheckedGetter, InstanceCheckedSetter, + Handle<Value>(), + v8::DEFAULT, + v8::None, + v8::AccessorSignature::New(templ)); + context->Global()->Set(v8_str("f"), templ->GetFunction()); + + printf("Testing positive ...\n"); + CompileRun("var obj = new f();"); + CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj")))); + CheckInstanceCheckedAccessors(true); + + printf("Testing negative ...\n"); + CompileRun("var obj = {};" + "obj.__proto__ = new f();"); + CHECK(!templ->HasInstance(context->Global()->Get(v8_str("obj")))); + CheckInstanceCheckedAccessors(false); + + printf("Testing positive with modified prototype chain ...\n"); + CompileRun("var obj = new f();" + "var pro = {};" + "pro.__proto__ = obj.__proto__;" + "obj.__proto__ = pro;"); + CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj")))); + CheckInstanceCheckedAccessors(true); +} + + +TEST(TryFinallyMessage) { + v8::HandleScope scope; + LocalContext context; + { + // Test that the original error message is not lost if there is a + // recursive call into Javascript is done in the finally block, e.g. to + // initialize an IC. (crbug.com/129171) + TryCatch try_catch; + const char* trigger_ic = + "try { \n" + " throw new Error('test'); \n" + "} finally { \n" + " var x = 0; \n" + " x++; \n" // Trigger an IC initialization here. + "} \n"; + CompileRun(trigger_ic); + CHECK(try_catch.HasCaught()); + Local<Message> message = try_catch.Message(); + CHECK(!message.IsEmpty()); + CHECK_EQ(2, message->GetLineNumber()); + } + + { + // Test that the original exception message is indeed overwritten if + // a new error is thrown in the finally block. + TryCatch try_catch; + const char* throw_again = + "try { \n" + " throw new Error('test'); \n" + "} finally { \n" + " var x = 0; \n" + " x++; \n" + " throw new Error('again'); \n" // This is the new uncaught error. + "} \n"; + CompileRun(throw_again); + CHECK(try_catch.HasCaught()); + Local<Message> message = try_catch.Message(); + CHECK(!message.IsEmpty()); + CHECK_EQ(6, message->GetLineNumber()); + } +} + + +static void Helper137002(bool do_store, + bool polymorphic, + bool remove_accessor, + bool interceptor) { + LocalContext context; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + if (interceptor) { + templ->SetNamedPropertyHandler(FooGetInterceptor, FooSetInterceptor); + } else { + templ->SetAccessor(v8_str("foo"), + GetterWhichReturns42, + SetterWhichSetsYOnThisTo23); + } + context->Global()->Set(v8_str("obj"), templ->NewInstance()); + + // Turn monomorphic on slow object with native accessor, then turn + // polymorphic, finally optimize to create negative lookup and fail. + CompileRun(do_store ? + "function f(x) { x.foo = void 0; }" : + "function f(x) { return x.foo; }"); + CompileRun("obj.y = void 0;"); + if (!interceptor) { + CompileRun("%OptimizeObjectForAddingMultipleProperties(obj, 1);"); + } + CompileRun("obj.__proto__ = null;" + "f(obj); f(obj); f(obj);"); + if (polymorphic) { + CompileRun("f({});"); + } + CompileRun("obj.y = void 0;" + "%OptimizeFunctionOnNextCall(f);"); + if (remove_accessor) { + CompileRun("delete obj.foo;"); + } + CompileRun("var result = f(obj);"); + if (do_store) { + CompileRun("result = obj.y;"); + } + if (remove_accessor && !interceptor) { + CHECK(context->Global()->Get(v8_str("result"))->IsUndefined()); + } else { + CHECK_EQ(do_store ? 23 : 42, + context->Global()->Get(v8_str("result"))->Int32Value()); + } +} + + +THREADED_TEST(Regress137002a) { + i::FLAG_allow_natives_syntax = true; + i::FLAG_compilation_cache = false; + v8::HandleScope scope; + for (int i = 0; i < 16; i++) { + Helper137002(i & 8, i & 4, i & 2, i & 1); + } +} + + +THREADED_TEST(Regress137002b) { + i::FLAG_allow_natives_syntax = true; + v8::HandleScope scope; + LocalContext context; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + templ->SetAccessor(v8_str("foo"), + GetterWhichReturns42, + SetterWhichSetsYOnThisTo23); + context->Global()->Set(v8_str("obj"), templ->NewInstance()); + + // Turn monomorphic on slow object with native accessor, then just + // delete the property and fail. + CompileRun("function load(x) { return x.foo; }" + "function store(x) { x.foo = void 0; }" + "function keyed_load(x, key) { return x[key]; }" + // Second version of function has a different source (add void 0) + // so that it does not share code with the first version. This + // ensures that the ICs are monomorphic. + "function load2(x) { void 0; return x.foo; }" + "function store2(x) { void 0; x.foo = void 0; }" + "function keyed_load2(x, key) { void 0; return x[key]; }" + + "obj.y = void 0;" + "obj.__proto__ = null;" + "var subobj = {};" + "subobj.y = void 0;" + "subobj.__proto__ = obj;" + "%OptimizeObjectForAddingMultipleProperties(obj, 1);" + + // Make the ICs monomorphic. + "load(obj); load(obj);" + "load2(subobj); load2(subobj);" + "store(obj); store(obj);" + "store2(subobj); store2(subobj);" + "keyed_load(obj, 'foo'); keyed_load(obj, 'foo');" + "keyed_load2(subobj, 'foo'); keyed_load2(subobj, 'foo');" + + // Actually test the shiny new ICs and better not crash. This + // serves as a regression test for issue 142088 as well. + "load(obj);" + "load2(subobj);" + "store(obj);" + "store2(subobj);" + "keyed_load(obj, 'foo');" + "keyed_load2(subobj, 'foo');" + + // Delete the accessor. It better not be called any more now. + "delete obj.foo;" + "obj.y = void 0;" + "subobj.y = void 0;" + + "var load_result = load(obj);" + "var load_result2 = load2(subobj);" + "var keyed_load_result = keyed_load(obj, 'foo');" + "var keyed_load_result2 = keyed_load2(subobj, 'foo');" + "store(obj);" + "store2(subobj);" + "var y_from_obj = obj.y;" + "var y_from_subobj = subobj.y;"); + CHECK(context->Global()->Get(v8_str("load_result"))->IsUndefined()); + CHECK(context->Global()->Get(v8_str("load_result2"))->IsUndefined()); + CHECK(context->Global()->Get(v8_str("keyed_load_result"))->IsUndefined()); + CHECK(context->Global()->Get(v8_str("keyed_load_result2"))->IsUndefined()); + CHECK(context->Global()->Get(v8_str("y_from_obj"))->IsUndefined()); + CHECK(context->Global()->Get(v8_str("y_from_subobj"))->IsUndefined()); +} + + +THREADED_TEST(Regress142088) { + i::FLAG_allow_natives_syntax = true; + v8::HandleScope scope; + LocalContext context; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + templ->SetAccessor(v8_str("foo"), + GetterWhichReturns42, + SetterWhichSetsYOnThisTo23); + context->Global()->Set(v8_str("obj"), templ->NewInstance()); + + CompileRun("function load(x) { return x.foo; }" + "var o = Object.create(obj);" + "%OptimizeObjectForAddingMultipleProperties(obj, 1);" + "load(o); load(o); load(o); load(o);"); +} + + +THREADED_TEST(Regress137496) { + i::FLAG_expose_gc = true; + v8::HandleScope scope; + LocalContext context; + + // Compile a try-finally clause where the finally block causes a GC + // while there still is a message pending for external reporting. + TryCatch try_catch; + try_catch.SetVerbose(true); + CompileRun("try { throw new Error(); } finally { gc(); }"); + CHECK(try_catch.HasCaught()); +} + + +THREADED_TEST(Regress149912) { + v8::HandleScope scope; + LocalContext context; + Handle<FunctionTemplate> templ = FunctionTemplate::New(); + AddInterceptor(templ, EmptyInterceptorGetter, EmptyInterceptorSetter); + context->Global()->Set(v8_str("Bug"), templ->GetFunction()); + CompileRun("Number.prototype.__proto__ = new Bug; var x = 0; x.foo();"); +} + + +THREADED_TEST(Regress157124) { + v8::HandleScope scope; + LocalContext context; + Local<ObjectTemplate> templ = ObjectTemplate::New(); + Local<Object> obj = templ->NewInstance(); + obj->GetIdentityHash(); + obj->DeleteHiddenValue(v8_str("Bug")); +} + + +#ifndef WIN32 +class ThreadInterruptTest { + public: + ThreadInterruptTest() : sem_(NULL), sem_value_(0) { } + ~ThreadInterruptTest() { delete sem_; } + + void RunTest() { + sem_ = i::OS::CreateSemaphore(0); + + InterruptThread i_thread(this); + i_thread.Start(); + + sem_->Wait(); + CHECK_EQ(kExpectedValue, sem_value_); + } + + private: + static const int kExpectedValue = 1; + + class InterruptThread : public i::Thread { + public: + explicit InterruptThread(ThreadInterruptTest* test) + : Thread("InterruptThread"), test_(test) {} + + virtual void Run() { + struct sigaction action; + + // Ensure that we'll enter waiting condition + i::OS::Sleep(100); + + // Setup signal handler + memset(&action, 0, sizeof(action)); + action.sa_handler = SignalHandler; + sigaction(SIGCHLD, &action, NULL); + + // Send signal + kill(getpid(), SIGCHLD); + + // Ensure that if wait has returned because of error + i::OS::Sleep(100); + + // Set value and signal semaphore + test_->sem_value_ = 1; + test_->sem_->Signal(); + } + + static void SignalHandler(int signal) { + } + + private: + ThreadInterruptTest* test_; + struct sigaction sa_; + }; + + i::Semaphore* sem_; + volatile int sem_value_; +}; + + +THREADED_TEST(SemaphoreInterruption) { + ThreadInterruptTest().RunTest(); +} +#endif // WIN32 diff --git a/src/3rdparty/v8/test/cctest/test-assembler-arm.cc b/src/3rdparty/v8/test/cctest/test-assembler-arm.cc index ecbf956..cdab1b9 100644 --- a/src/3rdparty/v8/test/cctest/test-assembler-arm.cc +++ b/src/3rdparty/v8/test/cctest/test-assembler-arm.cc @@ -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: @@ -642,8 +642,8 @@ TEST(8) { // single precision values around in memory. Assembler assm(Isolate::Current(), NULL, 0); - if (CpuFeatures::IsSupported(VFP3)) { - CpuFeatures::Scope scope(VFP3); + if (CpuFeatures::IsSupported(VFP2)) { + CpuFeatures::Scope scope(VFP2); __ mov(ip, Operand(sp)); __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit()); @@ -753,8 +753,8 @@ TEST(9) { // single precision values around in memory. Assembler assm(Isolate::Current(), NULL, 0); - if (CpuFeatures::IsSupported(VFP3)) { - CpuFeatures::Scope scope(VFP3); + if (CpuFeatures::IsSupported(VFP2)) { + CpuFeatures::Scope scope(VFP2); __ mov(ip, Operand(sp)); __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit()); @@ -868,8 +868,8 @@ TEST(10) { // single precision values around in memory. Assembler assm(Isolate::Current(), NULL, 0); - if (CpuFeatures::IsSupported(VFP3)) { - CpuFeatures::Scope scope(VFP3); + if (CpuFeatures::IsSupported(VFP2)) { + CpuFeatures::Scope scope(VFP2); __ mov(ip, Operand(sp)); __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit()); diff --git a/src/3rdparty/v8/test/cctest/test-ast.cc b/src/3rdparty/v8/test/cctest/test-ast.cc index 80c7fdf..c72f87e 100644 --- a/src/3rdparty/v8/test/cctest/test-ast.cc +++ b/src/3rdparty/v8/test/cctest/test-ast.cc @@ -39,8 +39,10 @@ TEST(List) { List<AstNode*>* list = new List<AstNode*>(0); CHECK_EQ(0, list->length()); - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); - AstNodeFactory<AstNullVisitor> factory(Isolate::Current()); + Isolate* isolate = Isolate::Current(); + Zone* zone = isolate->runtime_zone(); + ZoneScope zone_scope(zone, DELETE_ON_EXIT); + AstNodeFactory<AstNullVisitor> factory(isolate, zone); AstNode* node = factory.NewEmptyStatement(); list->Add(node); CHECK_EQ(1, list->length()); diff --git a/src/3rdparty/v8/test/cctest/test-compiler.cc b/src/3rdparty/v8/test/cctest/test-compiler.cc index 9ca0b0a..7700a98 100644 --- a/src/3rdparty/v8/test/cctest/test-compiler.cc +++ b/src/3rdparty/v8/test/cctest/test-compiler.cc @@ -68,15 +68,9 @@ v8::Handle<v8::Value> PrintExtension::Print(const v8::Arguments& args) { for (int i = 0; i < args.Length(); i++) { if (i != 0) printf(" "); v8::HandleScope scope; - v8::Handle<v8::Value> arg = args[i]; - v8::Handle<v8::String> string_obj = arg->ToString(); - if (string_obj.IsEmpty()) return string_obj; - int length = string_obj->Length(); - uint16_t* string = NewArray<uint16_t>(length + 1); - string_obj->Write(string); - for (int j = 0; j < length; j++) - printf("%lc", static_cast<wchar_t>(string[j])); - DeleteArray(string); + v8::String::Utf8Value str(args[i]); + if (*str == NULL) return v8::Undefined(); + printf("%s", *str); } printf("\n"); return v8::Undefined(); @@ -101,14 +95,14 @@ static void InitializeVM() { static MaybeObject* GetGlobalProperty(const char* name) { Handle<String> symbol = FACTORY->LookupAsciiSymbol(name); - return Isolate::Current()->context()->global()->GetProperty(*symbol); + return Isolate::Current()->context()->global_object()->GetProperty(*symbol); } static void SetGlobalProperty(const char* name, Object* value) { Handle<Object> object(value); Handle<String> symbol = FACTORY->LookupAsciiSymbol(name); - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); SetProperty(global, symbol, object, NONE, kNonStrictMode); } @@ -120,12 +114,13 @@ static Handle<JSFunction> Compile(const char* source) { Handle<String>(), 0, 0, + Handle<Context>(Isolate::Current()->native_context()), NULL, NULL, Handle<String>::null(), NOT_NATIVES_CODE); return FACTORY->NewFunctionFromSharedFunctionInfo(shared_function, - Isolate::Current()->global_context()); + Isolate::Current()->native_context()); } @@ -138,7 +133,7 @@ static double Inc(int x) { if (fun.is_null()) return -1; bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun, global, 0, NULL, &has_pending_exception); CHECK(!has_pending_exception); return GetGlobalProperty("result")->ToObjectChecked()->Number(); @@ -159,7 +154,7 @@ static double Add(int x, int y) { SetGlobalProperty("x", Smi::FromInt(x)); SetGlobalProperty("y", Smi::FromInt(y)); bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun, global, 0, NULL, &has_pending_exception); CHECK(!has_pending_exception); return GetGlobalProperty("result")->ToObjectChecked()->Number(); @@ -179,7 +174,7 @@ static double Abs(int x) { SetGlobalProperty("x", Smi::FromInt(x)); bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun, global, 0, NULL, &has_pending_exception); CHECK(!has_pending_exception); return GetGlobalProperty("result")->ToObjectChecked()->Number(); @@ -200,7 +195,7 @@ static double Sum(int n) { SetGlobalProperty("n", Smi::FromInt(n)); bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun, global, 0, NULL, &has_pending_exception); CHECK(!has_pending_exception); return GetGlobalProperty("result")->ToObjectChecked()->Number(); @@ -221,7 +216,7 @@ TEST(Print) { Handle<JSFunction> fun = Compile(source); if (fun.is_null()) return; bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun, global, 0, NULL, &has_pending_exception); CHECK(!has_pending_exception); } @@ -254,7 +249,7 @@ TEST(Stuff) { Handle<JSFunction> fun = Compile(source); CHECK(!fun.is_null()); bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun, global, 0, NULL, &has_pending_exception); CHECK(!has_pending_exception); CHECK_EQ(511.0, GetGlobalProperty("r")->ToObjectChecked()->Number()); @@ -269,7 +264,7 @@ TEST(UncaughtThrow) { Handle<JSFunction> fun = Compile(source); CHECK(!fun.is_null()); bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun, global, 0, NULL, &has_pending_exception); CHECK(has_pending_exception); CHECK_EQ(42.0, Isolate::Current()->pending_exception()-> @@ -294,12 +289,12 @@ TEST(C2JSFrames) { // Run the generated code to populate the global object with 'foo'. bool has_pending_exception; - Handle<JSObject> global(Isolate::Current()->context()->global()); + Handle<JSObject> global(Isolate::Current()->context()->global_object()); Execution::Call(fun0, global, 0, NULL, &has_pending_exception); CHECK(!has_pending_exception); Object* foo_symbol = FACTORY->LookupAsciiSymbol("foo")->ToObjectChecked(); - MaybeObject* fun1_object = Isolate::Current()->context()->global()-> + MaybeObject* fun1_object = Isolate::Current()->context()->global_object()-> GetProperty(String::cast(foo_symbol)); Handle<Object> fun1(fun1_object->ToObjectChecked()); CHECK(fun1->IsJSFunction()); @@ -352,6 +347,38 @@ TEST(GetScriptLineNumber) { } +// Test that optimized code for different closures is actually shared +// immediately by the FastNewClosureStub when run in the same context. +TEST(OptimizedCodeSharing) { + // Skip test if --cache-optimized-code is not activated by default because + // FastNewClosureStub that is baked into the snapshot is incorrect. + if (!FLAG_cache_optimized_code) return; + FLAG_allow_natives_syntax = true; + InitializeVM(); + v8::HandleScope scope; + for (int i = 0; i < 10; i++) { + LocalContext env; + env->Global()->Set(v8::String::New("x"), v8::Integer::New(i)); + CompileRun("function MakeClosure() {" + " return function() { return x; };" + "}" + "var closure0 = MakeClosure();" + "%DebugPrint(closure0());" + "%OptimizeFunctionOnNextCall(closure0);" + "%DebugPrint(closure0());" + "var closure1 = MakeClosure();" + "var closure2 = MakeClosure();"); + Handle<JSFunction> fun1 = v8::Utils::OpenHandle( + *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure1")))); + Handle<JSFunction> fun2 = v8::Utils::OpenHandle( + *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure2")))); + CHECK(fun1->IsOptimized() || !fun1->IsOptimizable()); + CHECK(fun2->IsOptimized() || !fun2->IsOptimizable()); + CHECK_EQ(fun1->code(), fun2->code()); + } +} + + #ifdef ENABLE_DISASSEMBLER static Handle<JSFunction> GetJSFunction(v8::Handle<v8::Object> obj, const char* property_name) { @@ -374,15 +401,16 @@ static void CheckCodeForUnsafeLiteral(Handle<JSFunction> f) { Address end = pc + decode_size; v8::internal::EmbeddedVector<char, 128> decode_buffer; + v8::internal::EmbeddedVector<char, 128> smi_hex_buffer; + Smi* smi = Smi::FromInt(12345678); + OS::SNPrintF(smi_hex_buffer, "0x%lx", reinterpret_cast<intptr_t>(smi)); while (pc < end) { int num_const = d.ConstantPoolSizeAt(pc); if (num_const >= 0) { pc += (num_const + 1) * kPointerSize; } else { pc += d.InstructionDecode(decode_buffer, pc); - CHECK(strstr(decode_buffer.start(), "mov eax,0x178c29c") == NULL); - CHECK(strstr(decode_buffer.start(), "push 0x178c29c") == NULL); - CHECK(strstr(decode_buffer.start(), "0x178c29c") == NULL); + CHECK(strstr(decode_buffer.start(), smi_hex_buffer.start()) == NULL); } } } diff --git a/src/3rdparty/v8/test/cctest/test-dataflow.cc b/src/3rdparty/v8/test/cctest/test-dataflow.cc index a63008d..ae33279 100644 --- a/src/3rdparty/v8/test/cctest/test-dataflow.cc +++ b/src/3rdparty/v8/test/cctest/test-dataflow.cc @@ -36,8 +36,8 @@ using namespace v8::internal; TEST(BitVector) { v8::internal::V8::Initialize(NULL); - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); - Zone* zone = ZONE; + Zone* zone = Isolate::Current()->runtime_zone(); + ZoneScope zone_scope(zone, DELETE_ON_EXIT); { BitVector v(15, zone); v.Add(1); diff --git a/src/3rdparty/v8/test/cctest/test-debug.cc b/src/3rdparty/v8/test/cctest/test-debug.cc index 9c831fb..f2253e3 100644 --- a/src/3rdparty/v8/test/cctest/test-debug.cc +++ b/src/3rdparty/v8/test/cctest/test-debug.cc @@ -197,10 +197,9 @@ static bool HasDebugInfo(v8::Handle<v8::Function> fun) { // number. static int SetBreakPoint(Handle<v8::internal::JSFunction> fun, int position) { static int break_point = 0; - Handle<v8::internal::SharedFunctionInfo> shared(fun->shared()); v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug(); debug->SetBreakPoint( - shared, + fun, Handle<Object>(v8::internal::Smi::FromInt(++break_point)), &position); return break_point; @@ -515,7 +514,7 @@ void CheckDebugBreakFunction(DebugLocalContext* env, // there ClearBreakPoint(bp); CHECK(!debug->HasDebugInfo(shared)); - CHECK(debug->EnsureDebugInfo(shared)); + CHECK(debug->EnsureDebugInfo(shared, fun)); TestBreakLocationIterator it2(Debug::GetDebugInfo(shared)); it2.FindBreakLocationFromPosition(position); actual_mode = it2.it()->rinfo()->rmode(); @@ -2300,65 +2299,6 @@ TEST(ScriptBreakPointTopLevelCrash) { CheckDebuggerUnloaded(); } -// Test that breakpoint_relocation flag is honored -TEST(ScriptBreakPointNoRelocation) { - i::FLAG_breakpoint_relocation = false; - - v8::HandleScope scope; - DebugLocalContext env; - env.ExposeDebug(); - - // Create a function for checking the function when hitting a break point. - frame_function_name = CompileFunction(&env, - frame_function_name_source, - "frame_function_name"); - - v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount, - v8::Undefined()); - - v8::Local<v8::String> script1 = v8::String::New( - "a = 0 // line 0\n" - " // line 1\n" - " // line 2\n" - " // line 3\n" - "function f() { // line 4\n" - " return 0; // line 5\n" - "} // line 6"); - - // Set the script break point on the empty line - SetScriptBreakPointByNameFromJS("test.html", 2, -1); - - // Compile the script and call the function. - v8::ScriptOrigin origin(v8::String::New("test.html"), v8::Integer::New(0)); - v8::Script::Compile(script1, &origin)->Run(); - v8::Local<v8::Function> f - = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f"))); - f->Call(env->Global(), 0, NULL); - - // Check that a break point was not hit - CHECK_EQ(0, break_point_hit_count); - - v8::Local<v8::String> script2 = v8::String::New( - "a = 0 // line 0\n" - "function g() { // line 1\n" - " return 0; // line 2\n" - "} // line 3\n" - "function f() { // line 4\n" - " return 0; // line 5\n" - "} // line 6"); - - // Compile the script and call the new function - v8::Script::Compile(script2, &origin)->Run(); - v8::Local<v8::Function> g - = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g"))); - g->Call(env->Global(), 0, NULL); - - // Check that a break point was not hit - CHECK_EQ(1, break_point_hit_count); - - v8::Debug::SetDebugEventListener(NULL); - CheckDebuggerUnloaded(); -} // Test that it is possible to remove the last break point for a function // inside the break handling of that break point. @@ -2441,7 +2381,7 @@ TEST(DebuggerStatementBreakpoint) { } -// Thest that the evaluation of expressions when a break point is hit generates +// Test that the evaluation of expressions when a break point is hit generates // the correct results. TEST(DebugEvaluate) { v8::HandleScope scope; @@ -2557,6 +2497,98 @@ TEST(DebugEvaluate) { CheckDebuggerUnloaded(); } + +int debugEventCount = 0; +static void CheckDebugEvent(const v8::Debug::EventDetails& eventDetails) { + if (eventDetails.GetEvent() == v8::Break) ++debugEventCount; +} + +// Test that the conditional breakpoints work event if code generation from +// strings is prohibited in the debugee context. +TEST(ConditionalBreakpointWithCodeGenerationDisallowed) { + v8::HandleScope scope; + DebugLocalContext env; + env.ExposeDebug(); + + v8::Debug::SetDebugEventListener2(CheckDebugEvent); + + v8::Local<v8::Function> foo = CompileFunction(&env, + "function foo(x) {\n" + " var s = 'String value2';\n" + " return s + x;\n" + "}", + "foo"); + + // Set conditional breakpoint with condition 'true'. + CompileRun("debug.Debug.setBreakPoint(foo, 2, 0, 'true')"); + + debugEventCount = 0; + env->AllowCodeGenerationFromStrings(false); + foo->Call(env->Global(), 0, NULL); + CHECK_EQ(1, debugEventCount); + + v8::Debug::SetDebugEventListener2(NULL); + CheckDebuggerUnloaded(); +} + + +bool checkedDebugEvals = true; +v8::Handle<v8::Function> checkGlobalEvalFunction; +v8::Handle<v8::Function> checkFrameEvalFunction; +static void CheckDebugEval(const v8::Debug::EventDetails& eventDetails) { + if (eventDetails.GetEvent() == v8::Break) { + ++debugEventCount; + v8::HandleScope handleScope; + + v8::Handle<v8::Value> args[] = { eventDetails.GetExecutionState() }; + CHECK(checkGlobalEvalFunction->Call( + eventDetails.GetEventContext()->Global(), 1, args)->IsTrue()); + CHECK(checkFrameEvalFunction->Call( + eventDetails.GetEventContext()->Global(), 1, args)->IsTrue()); + } +} + +// Test that the evaluation of expressions when a break point is hit generates +// the correct results in case code generation from strings is disallowed in the +// debugee context. +TEST(DebugEvaluateWithCodeGenerationDisallowed) { + v8::HandleScope scope; + DebugLocalContext env; + env.ExposeDebug(); + + v8::Debug::SetDebugEventListener2(CheckDebugEval); + + v8::Local<v8::Function> foo = CompileFunction(&env, + "var global = 'Global';\n" + "function foo(x) {\n" + " var local = 'Local';\n" + " debugger;\n" + " return local + x;\n" + "}", + "foo"); + checkGlobalEvalFunction = CompileFunction(&env, + "function checkGlobalEval(exec_state) {\n" + " return exec_state.evaluateGlobal('global').value() === 'Global';\n" + "}", + "checkGlobalEval"); + + checkFrameEvalFunction = CompileFunction(&env, + "function checkFrameEval(exec_state) {\n" + " return exec_state.frame(0).evaluate('local').value() === 'Local';\n" + "}", + "checkFrameEval"); + debugEventCount = 0; + env->AllowCodeGenerationFromStrings(false); + foo->Call(env->Global(), 0, NULL); + CHECK_EQ(1, debugEventCount); + + checkGlobalEvalFunction.Clear(); + checkFrameEvalFunction.Clear(); + v8::Debug::SetDebugEventListener2(NULL); + CheckDebuggerUnloaded(); +} + + // Copies a C string to a 16-bit string. Does not check for buffer overflow. // Does not use the V8 engine to convert strings, so it can be used // in any thread. Returns the length of the string. @@ -4086,15 +4118,12 @@ TEST(StepWithException) { TEST(DebugBreak) { +#ifdef VERIFY_HEAP + i::FLAG_verify_heap = true; +#endif v8::HandleScope scope; DebugLocalContext env; - // This test should be run with option --verify-heap. As --verify-heap is - // only available in debug mode only check for it in that case. -#ifdef DEBUG - CHECK(v8::internal::FLAG_verify_heap); -#endif - // Register a debug event listener which sets the break flag and counts. v8::Debug::SetDebugEventListener(DebugEventBreak); @@ -4333,9 +4362,9 @@ TEST(InterceptorPropertyMirror) { "named_values[%d] instanceof debug.PropertyMirror", i); CHECK(CompileRun(buffer.start())->BooleanValue()); - // 5 is PropertyType.Interceptor OS::SNPrintF(buffer, "named_values[%d].propertyType()", i); - CHECK_EQ(5, CompileRun(buffer.start())->Int32Value()); + CHECK_EQ(v8::internal::INTERCEPTOR, + CompileRun(buffer.start())->Int32Value()); OS::SNPrintF(buffer, "named_values[%d].isNative()", i); CHECK(CompileRun(buffer.start())->BooleanValue()); @@ -5893,9 +5922,9 @@ TEST(DebuggerAgent) { i::Debugger* debugger = i::Isolate::Current()->debugger(); // Make sure these ports is not used by other tests to allow tests to run in // parallel. - const int kPort1 = 5858; - const int kPort2 = 5857; - const int kPort3 = 5856; + const int kPort1 = 5858 + FlagDependentPortOffset(); + const int kPort2 = 5857 + FlagDependentPortOffset(); + const int kPort3 = 5856 + FlagDependentPortOffset(); // Make a string with the port2 number. const int kPortBufferLen = 6; @@ -5994,7 +6023,7 @@ void DebuggerAgentProtocolServerThread::Run() { TEST(DebuggerAgentProtocolOverflowHeader) { // Make sure this port is not used by other tests to allow tests to run in // parallel. - const int kPort = 5860; + const int kPort = 5860 + FlagDependentPortOffset(); static const char* kLocalhost = "localhost"; // Make a string with the port number. @@ -7409,4 +7438,94 @@ TEST(DebugBreakInline) { } +static void DebugEventStepNext(v8::DebugEvent event, + v8::Handle<v8::Object> exec_state, + v8::Handle<v8::Object> event_data, + v8::Handle<v8::Value> data) { + if (event == v8::Break) { + PrepareStep(StepNext); + } +} + + +static void RunScriptInANewCFrame(const char* source) { + v8::TryCatch try_catch; + CompileRun(source); + CHECK(try_catch.HasCaught()); +} + + +TEST(Regress131642) { + // Bug description: + // When doing StepNext through the first script, the debugger is not reset + // after exiting through exception. A flawed implementation enabling the + // debugger to step into Array.prototype.forEach breaks inside the callback + // for forEach in the second script under the assumption that we are in a + // recursive call. In an attempt to step out, we crawl the stack using the + // recorded frame pointer from the first script and fail when not finding it + // on the stack. + v8::HandleScope scope; + DebugLocalContext env; + v8::Debug::SetDebugEventListener(DebugEventStepNext); + + // We step through the first script. It exits through an exception. We run + // this inside a new frame to record a different FP than the second script + // would expect. + const char* script_1 = "debugger; throw new Error();"; + RunScriptInANewCFrame(script_1); + + // The second script uses forEach. + const char* script_2 = "[0].forEach(function() { });"; + CompileRun(script_2); + + v8::Debug::SetDebugEventListener(NULL); +} + + +// Import from test-heap.cc +int CountNativeContexts(); + + +static void NopListener(v8::DebugEvent event, + v8::Handle<v8::Object> exec_state, + v8::Handle<v8::Object> event_data, + v8::Handle<v8::Value> data) { +} + + +TEST(DebuggerCreatesContextIffActive) { + v8::HandleScope scope; + DebugLocalContext env; + CHECK_EQ(1, CountNativeContexts()); + + v8::Debug::SetDebugEventListener(NULL); + CompileRun("debugger;"); + CHECK_EQ(1, CountNativeContexts()); + + v8::Debug::SetDebugEventListener(NopListener); + CompileRun("debugger;"); + CHECK_EQ(2, CountNativeContexts()); + + v8::Debug::SetDebugEventListener(NULL); +} + + +TEST(LiveEditEnabled) { + v8::internal::FLAG_allow_natives_syntax = true; + v8::HandleScope scope; + LocalContext context; + v8::Debug::SetLiveEditEnabled(true); + CompileRun("%LiveEditCompareStrings('', '')"); +} + + +TEST(LiveEditDisabled) { + v8::internal::FLAG_allow_natives_syntax = true; + v8::HandleScope scope; + LocalContext context; + v8::Debug::SetLiveEditEnabled(false); + CompileRun("%LiveEditCompareStrings('', '')"); +} + + #endif // ENABLE_DEBUGGER_SUPPORT diff --git a/src/3rdparty/v8/test/cctest/test-decls.cc b/src/3rdparty/v8/test/cctest/test-decls.cc index e6bdc9f..6fc6012 100644 --- a/src/3rdparty/v8/test/cctest/test-decls.cc +++ b/src/3rdparty/v8/test/cctest/test-decls.cc @@ -37,7 +37,8 @@ using namespace v8; enum Expectations { EXPECT_RESULT, - EXPECT_EXCEPTION + EXPECT_EXCEPTION, + EXPECT_ERROR }; @@ -72,6 +73,10 @@ class DeclarationContext { void InitializeIfNeeded(); + // Perform optional initialization steps on the context after it has + // been created. Defaults to none but may be overwritten. + virtual void PostInitializeContext(Handle<Context> context) {} + // Get the holder for the interceptor. Default to the instance template // but may be overwritten. virtual Local<ObjectTemplate> GetHolder(Local<FunctionTemplate> function) { @@ -91,7 +96,6 @@ class DeclarationContext { private: bool is_initialized_; Persistent<Context> context_; - Local<String> property_; int get_count_; int set_count_; @@ -120,6 +124,7 @@ void DeclarationContext::InitializeIfNeeded() { context_ = Context::New(0, function->InstanceTemplate(), Local<Value>()); context_->Enter(); is_initialized_ = true; + PostInitializeContext(context_); } @@ -134,7 +139,13 @@ void DeclarationContext::Check(const char* source, HandleScope scope; TryCatch catcher; catcher.SetVerbose(true); - Local<Value> result = Script::Compile(String::New(source))->Run(); + Local<Script> script = Script::Compile(String::New(source)); + if (expectations == EXPECT_ERROR) { + CHECK(script.IsEmpty()); + return; + } + CHECK(!script.IsEmpty()); + Local<Value> result = script->Run(); CHECK_EQ(get, get_count()); CHECK_EQ(set, set_count()); CHECK_EQ(query, query_count()); @@ -536,9 +547,9 @@ TEST(ExistsInPrototype) { { ExistsInPrototypeContext context; context.Check("var x; x", - 0, // get 0, - 0, // declaration + 0, + 0, EXPECT_RESULT, Undefined()); } @@ -546,7 +557,7 @@ TEST(ExistsInPrototype) { context.Check("var x = 0; x", 0, 0, - 0, // declaration + 0, EXPECT_RESULT, Number::New(0)); } @@ -554,7 +565,7 @@ TEST(ExistsInPrototype) { context.Check("const x; x", 0, 0, - 0, // declaration + 0, EXPECT_RESULT, Undefined()); } @@ -562,7 +573,7 @@ TEST(ExistsInPrototype) { context.Check("const x = 0; x", 0, 0, - 0, // declaration + 0, EXPECT_RESULT, Number::New(0)); } } @@ -591,7 +602,305 @@ TEST(AbsentInPrototype) { context.Check("if (false) { var x = 0; }; x", 0, 0, - 0, // declaration + 0, EXPECT_RESULT, Undefined()); } } + + + +class ExistsInHiddenPrototypeContext: public DeclarationContext { + public: + ExistsInHiddenPrototypeContext() { + hidden_proto_ = FunctionTemplate::New(); + hidden_proto_->SetHiddenPrototype(true); + } + + protected: + virtual v8::Handle<Integer> Query(Local<String> key) { + // Let it seem that the property exists in the hidden prototype object. + return Integer::New(v8::None); + } + + // Install the hidden prototype after the global object has been created. + virtual void PostInitializeContext(Handle<Context> context) { + Local<Object> global_object = context->Global(); + Local<Object> hidden_proto = hidden_proto_->GetFunction()->NewInstance(); + context->DetachGlobal(); + context->Global()->SetPrototype(hidden_proto); + context->ReattachGlobal(global_object); + } + + // Use the hidden prototype as the holder for the interceptors. + virtual Local<ObjectTemplate> GetHolder(Local<FunctionTemplate> function) { + return hidden_proto_->InstanceTemplate(); + } + + private: + Local<FunctionTemplate> hidden_proto_; +}; + + +TEST(ExistsInHiddenPrototype) { + i::FLAG_es52_globals = true; + HandleScope scope; + + { ExistsInHiddenPrototypeContext context; + context.Check("var x; x", + 1, // access + 0, + 2, // declaration + initialization + EXPECT_EXCEPTION); // x is not defined! + } + + { ExistsInHiddenPrototypeContext context; + context.Check("var x = 0; x", + 1, // access + 1, // initialization + 2, // declaration + initialization + EXPECT_RESULT, Number::New(0)); + } + + { ExistsInHiddenPrototypeContext context; + context.Check("function x() { }; x", + 0, + 0, + 0, + EXPECT_RESULT); + } + + // TODO(mstarzinger): The semantics of global const is vague. + { ExistsInHiddenPrototypeContext context; + context.Check("const x; x", + 0, + 0, + 1, // (re-)declaration + EXPECT_RESULT, Undefined()); + } + + // TODO(mstarzinger): The semantics of global const is vague. + { ExistsInHiddenPrototypeContext context; + context.Check("const x = 0; x", + 0, + 0, + 1, // (re-)declaration + EXPECT_RESULT, Number::New(0)); + } +} + + + +class SimpleContext { + public: + SimpleContext() { + context_ = Context::New(0); + context_->Enter(); + } + + virtual ~SimpleContext() { + context_->Exit(); + context_.Dispose(); + } + + void Check(const char* source, + Expectations expectations, + v8::Handle<Value> value = Local<Value>()) { + HandleScope scope; + TryCatch catcher; + catcher.SetVerbose(true); + Local<Script> script = Script::Compile(String::New(source)); + if (expectations == EXPECT_ERROR) { + CHECK(script.IsEmpty()); + return; + } + CHECK(!script.IsEmpty()); + Local<Value> result = script->Run(); + if (expectations == EXPECT_RESULT) { + CHECK(!catcher.HasCaught()); + if (!value.IsEmpty()) { + CHECK_EQ(value, result); + } + } else { + CHECK(expectations == EXPECT_EXCEPTION); + CHECK(catcher.HasCaught()); + if (!value.IsEmpty()) { + CHECK_EQ(value, catcher.Exception()); + } + } + } + + private: + Persistent<Context> context_; +}; + + +TEST(MultiScriptConflicts) { + HandleScope scope; + + { SimpleContext context; + context.Check("var x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("var x = 2; x", + EXPECT_RESULT, Number::New(2)); + context.Check("const x = 3; x", + EXPECT_RESULT, Number::New(3)); + context.Check("const x = 4; x", + EXPECT_RESULT, Number::New(4)); + context.Check("x = 5; x", + EXPECT_RESULT, Number::New(5)); + context.Check("var x = 6; x", + EXPECT_RESULT, Number::New(6)); + context.Check("this.x", + EXPECT_RESULT, Number::New(6)); + context.Check("function x() { return 7 }; x()", + EXPECT_RESULT, Number::New(7)); + } + + { SimpleContext context; + context.Check("const x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("var x = 2; x", // assignment ignored + EXPECT_RESULT, Number::New(1)); + context.Check("const x = 3; x", + EXPECT_RESULT, Number::New(1)); + context.Check("x = 4; x", // assignment ignored + EXPECT_RESULT, Number::New(1)); + context.Check("var x = 5; x", // assignment ignored + EXPECT_RESULT, Number::New(1)); + context.Check("this.x", + EXPECT_RESULT, Number::New(1)); + context.Check("function x() { return 7 }; x", + EXPECT_EXCEPTION); + } + + i::FLAG_use_strict = true; + i::FLAG_harmony_scoping = true; + + { SimpleContext context; + context.Check("var x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("x", + EXPECT_RESULT, Number::New(1)); + context.Check("this.x", + EXPECT_RESULT, Number::New(1)); + } + + { SimpleContext context; + context.Check("function x() { return 4 }; x()", + EXPECT_RESULT, Number::New(4)); + context.Check("x()", + EXPECT_RESULT, Number::New(4)); + context.Check("this.x()", + EXPECT_RESULT, Number::New(4)); + } + + { SimpleContext context; + context.Check("let x = 2; x", + EXPECT_RESULT, Number::New(2)); + context.Check("x", + EXPECT_RESULT, Number::New(2)); + // TODO(rossberg): The current ES6 draft spec does not reflect lexical + // bindings on the global object. However, this will probably change, in + // which case we reactivate the following test. + // context.Check("this.x", + // EXPECT_RESULT, Number::New(2)); + } + + { SimpleContext context; + context.Check("const x = 3; x", + EXPECT_RESULT, Number::New(3)); + context.Check("x", + EXPECT_RESULT, Number::New(3)); + // TODO(rossberg): The current ES6 draft spec does not reflect lexical + // bindings on the global object. However, this will probably change, in + // which case we reactivate the following test. + // context.Check("this.x", + // EXPECT_RESULT, Number::New(3)); + } + + // TODO(rossberg): All of the below should actually be errors in Harmony. + + { SimpleContext context; + context.Check("var x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("let x = 2; x", + EXPECT_RESULT, Number::New(2)); + } + + { SimpleContext context; + context.Check("var x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("const x = 2; x", + EXPECT_RESULT, Number::New(2)); + } + + { SimpleContext context; + context.Check("function x() { return 1 }; x()", + EXPECT_RESULT, Number::New(1)); + context.Check("let x = 2; x", + EXPECT_RESULT, Number::New(2)); + } + + { SimpleContext context; + context.Check("function x() { return 1 }; x()", + EXPECT_RESULT, Number::New(1)); + context.Check("const x = 2; x", + EXPECT_RESULT, Number::New(2)); + } + + { SimpleContext context; + context.Check("let x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("var x = 2; x", + EXPECT_ERROR); + } + + { SimpleContext context; + context.Check("let x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("let x = 2; x", + EXPECT_ERROR); + } + + { SimpleContext context; + context.Check("let x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("const x = 2; x", + EXPECT_ERROR); + } + + { SimpleContext context; + context.Check("let x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("function x() { return 2 }; x()", + EXPECT_ERROR); + } + + { SimpleContext context; + context.Check("const x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("var x = 2; x", + EXPECT_ERROR); + } + + { SimpleContext context; + context.Check("const x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("let x = 2; x", + EXPECT_ERROR); + } + + { SimpleContext context; + context.Check("const x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("const x = 2; x", + EXPECT_ERROR); + } + + { SimpleContext context; + context.Check("const x = 1; x", + EXPECT_RESULT, Number::New(1)); + context.Check("function x() { return 2 }; x()", + EXPECT_ERROR); + } +} diff --git a/src/3rdparty/v8/test/cctest/test-dictionary.cc b/src/3rdparty/v8/test/cctest/test-dictionary.cc index 793e228..00e3833 100644 --- a/src/3rdparty/v8/test/cctest/test-dictionary.cc +++ b/src/3rdparty/v8/test/cctest/test-dictionary.cc @@ -48,24 +48,24 @@ TEST(ObjectHashTable) { table = PutIntoObjectHashTable(table, a, b); CHECK_EQ(table->NumberOfElements(), 1); CHECK_EQ(table->Lookup(*a), *b); - CHECK_EQ(table->Lookup(*b), HEAP->undefined_value()); + CHECK_EQ(table->Lookup(*b), HEAP->the_hole_value()); // Keys still have to be valid after objects were moved. HEAP->CollectGarbage(NEW_SPACE); CHECK_EQ(table->NumberOfElements(), 1); CHECK_EQ(table->Lookup(*a), *b); - CHECK_EQ(table->Lookup(*b), HEAP->undefined_value()); + CHECK_EQ(table->Lookup(*b), HEAP->the_hole_value()); // Keys that are overwritten should not change number of elements. table = PutIntoObjectHashTable(table, a, FACTORY->NewJSArray(13)); CHECK_EQ(table->NumberOfElements(), 1); CHECK_NE(table->Lookup(*a), *b); - // Keys mapped to undefined should be removed permanently. - table = PutIntoObjectHashTable(table, a, FACTORY->undefined_value()); + // Keys mapped to the hole should be removed permanently. + table = PutIntoObjectHashTable(table, a, FACTORY->the_hole_value()); CHECK_EQ(table->NumberOfElements(), 0); CHECK_EQ(table->NumberOfDeletedElements(), 1); - CHECK_EQ(table->Lookup(*a), HEAP->undefined_value()); + CHECK_EQ(table->Lookup(*a), HEAP->the_hole_value()); // Keys should map back to their respective values and also should get // an identity hash code generated. @@ -85,7 +85,7 @@ TEST(ObjectHashTable) { Handle<JSObject> key = FACTORY->NewJSArray(7); CHECK(key->GetIdentityHash(ALLOW_CREATION)->ToObjectChecked()->IsSmi()); CHECK_EQ(table->FindEntry(*key), ObjectHashTable::kNotFound); - CHECK_EQ(table->Lookup(*key), HEAP->undefined_value()); + CHECK_EQ(table->Lookup(*key), HEAP->the_hole_value()); CHECK(key->GetIdentityHash(OMIT_CREATION)->ToObjectChecked()->IsSmi()); } @@ -93,7 +93,7 @@ TEST(ObjectHashTable) { // should not get an identity hash code generated. for (int i = 0; i < 100; i++) { Handle<JSObject> key = FACTORY->NewJSArray(7); - CHECK_EQ(table->Lookup(*key), HEAP->undefined_value()); + CHECK_EQ(table->Lookup(*key), HEAP->the_hole_value()); CHECK_EQ(key->GetIdentityHash(OMIT_CREATION), HEAP->undefined_value()); } } @@ -105,6 +105,12 @@ TEST(ObjectHashSetCausesGC) { LocalContext context; Handle<ObjectHashSet> table = FACTORY->NewObjectHashSet(1); Handle<JSObject> key = FACTORY->NewJSArray(0); + v8::Handle<v8::Object> key_obj = v8::Utils::ToLocal(key); + + // Force allocation of hash table backing store for hidden properties. + key_obj->SetHiddenValue(v8_str("key 1"), v8_str("val 1")); + key_obj->SetHiddenValue(v8_str("key 2"), v8_str("val 2")); + key_obj->SetHiddenValue(v8_str("key 3"), v8_str("val 3")); // Simulate a full heap so that generating an identity hash code // in subsequent calls will request GC. @@ -128,13 +134,19 @@ TEST(ObjectHashTableCausesGC) { LocalContext context; Handle<ObjectHashTable> table = FACTORY->NewObjectHashTable(1); Handle<JSObject> key = FACTORY->NewJSArray(0); + v8::Handle<v8::Object> key_obj = v8::Utils::ToLocal(key); + + // Force allocation of hash table backing store for hidden properties. + key_obj->SetHiddenValue(v8_str("key 1"), v8_str("val 1")); + key_obj->SetHiddenValue(v8_str("key 2"), v8_str("val 2")); + key_obj->SetHiddenValue(v8_str("key 3"), v8_str("val 3")); // Simulate a full heap so that generating an identity hash code // in subsequent calls will request GC. FLAG_gc_interval = 0; // Calling Lookup() should not cause GC ever. - CHECK(table->Lookup(*key)->IsUndefined()); + CHECK(table->Lookup(*key)->IsTheHole()); // Calling Put() should request GC by returning a failure. CHECK(table->Put(*key, *key)->IsRetryAfterGC()); diff --git a/src/3rdparty/v8/test/cctest/test-disasm-arm.cc b/src/3rdparty/v8/test/cctest/test-disasm-arm.cc index 0e9432d..3a2d9e8 100644 --- a/src/3rdparty/v8/test/cctest/test-disasm-arm.cc +++ b/src/3rdparty/v8/test/cctest/test-disasm-arm.cc @@ -92,6 +92,10 @@ bool DisassembleAndCompare(byte* pc, const char* compare_string) { if (!DisassembleAndCompare(progcounter, compare_string)) failure = true; \ } +// Force emission of any pending literals into a pool. +#define EMIT_PENDING_LITERALS() \ + assm.CheckConstPool(true, false) + // Verify that all invocations of the COMPARE macro passed successfully. // Exit with a failure if at least one of the tests failed. @@ -280,6 +284,10 @@ TEST(Type0) { // is pretty strange anyway. COMPARE(mov(r5, Operand(0x01234), SetCC, ne), "159fc000 ldrne ip, [pc, #+0]"); + // Emit a literal pool now, otherwise this could be dumped later, in the + // middle of a different test. + EMIT_PENDING_LITERALS(); + // We only disassemble one instruction so the eor instruction is not here. // The eor does the setcc so we get a movw here. COMPARE(eor(r5, r4, Operand(0x1234), SetCC, ne), diff --git a/src/3rdparty/v8/test/cctest/test-flags.cc b/src/3rdparty/v8/test/cctest/test-flags.cc index 32f1264..9cb12c4 100644 --- a/src/3rdparty/v8/test/cctest/test-flags.cc +++ b/src/3rdparty/v8/test/cctest/test-flags.cc @@ -159,7 +159,7 @@ TEST(Flags6) { CHECK_EQ(3, FlagList::SetFlagsFromCommandLine(&argc, const_cast<char **>(argv), true)); - CHECK_EQ(4, argc); + CHECK_EQ(2, argc); } @@ -232,3 +232,16 @@ TEST(FlagsJSArguments4) { CHECK_EQ(0, FLAG_js_arguments.argc()); } + +TEST(FlagsRemoveIncomplete) { + // Test that processed command line arguments are removed, even + // if the list of arguments ends unexpectedly. + SetFlagsToDefault(); + int argc = 3; + const char* argv[] = { "", "--crankshaft", "--expose-debug-as" }; + CHECK_EQ(2, FlagList::SetFlagsFromCommandLine(&argc, + const_cast<char **>(argv), + true)); + CHECK_NE(NULL, argv[1]); + CHECK_EQ(argc, 2); +} diff --git a/src/3rdparty/v8/test/cctest/test-func-name-inference.cc b/src/3rdparty/v8/test/cctest/test-func-name-inference.cc index 8f405b7..cda6aa0 100644 --- a/src/3rdparty/v8/test/cctest/test-func-name-inference.cc +++ b/src/3rdparty/v8/test/cctest/test-func-name-inference.cc @@ -28,6 +28,7 @@ #include "v8.h" #include "api.h" +#include "debug.h" #include "runtime.h" #include "cctest.h" @@ -87,10 +88,10 @@ static void CheckFunctionName(v8::Handle<v8::Script> script, #ifdef ENABLE_DEBUGGER_SUPPORT // Obtain SharedFunctionInfo for the function. + Isolate::Current()->debug()->PrepareForBreakPoints(); Object* shared_func_info_ptr = - Runtime::FindSharedFunctionInfoInScript(Isolate::Current(), - i_script, - func_pos); + Isolate::Current()->debug()->FindSharedFunctionInfoInScript(i_script, + func_pos); CHECK(shared_func_info_ptr != HEAP->undefined_value()); Handle<SharedFunctionInfo> shared_func_info( SharedFunctionInfo::cast(shared_func_info_ptr)); @@ -398,5 +399,45 @@ TEST(AssignmentAndCall) { // The inferred name is empty, because this is an assignment of a result. CheckFunctionName(script, "return 1", ""); // See MultipleAssignments test. - CheckFunctionName(script, "return 2", "Enclosing.Bar"); + // TODO(2276): Lazy compiling the enclosing outer closure would yield + // in "Enclosing.Bar" being the inferred name here. + CheckFunctionName(script, "return 2", "Bar"); +} + + +TEST(MethodAssignmentInAnonymousFunctionCall) { + InitializeVM(); + v8::HandleScope scope; + + v8::Handle<v8::Script> script = Compile( + "(function () {\n" + " var EventSource = function () { };\n" + " EventSource.prototype.addListener = function () {\n" + " return 2012;\n" + " };\n" + " this.PublicEventSource = EventSource;\n" + "})();"); + CheckFunctionName(script, "return 2012", "EventSource.addListener"); +} + + +TEST(ReturnAnonymousFunction) { + InitializeVM(); + v8::HandleScope scope; + + v8::Handle<v8::Script> script = Compile( + "(function() {\n" + " function wrapCode() {\n" + " return function () {\n" + " return 2012;\n" + " };\n" + " };\n" + " var foo = 10;\n" + " function f() {\n" + " return wrapCode();\n" + " }\n" + " this.ref = f;\n" + "})()"); + script->Run(); + CheckFunctionName(script, "return 2012", ""); } diff --git a/src/3rdparty/v8/test/cctest/test-heap-profiler.cc b/src/3rdparty/v8/test/cctest/test-heap-profiler.cc index b5815dc..5235971 100644 --- a/src/3rdparty/v8/test/cctest/test-heap-profiler.cc +++ b/src/3rdparty/v8/test/cctest/test-heap-profiler.cc @@ -7,6 +7,7 @@ #include "v8.h" #include "cctest.h" +#include "hashmap.h" #include "heap-profiler.h" #include "snapshot.h" #include "debug.h" @@ -27,10 +28,14 @@ class NamedEntriesDetector { if (strcmp(entry->name(), "C2") == 0) has_C2 = true; } + static bool AddressesMatch(void* key1, void* key2) { + return key1 == key2; + } + void CheckAllReachables(i::HeapEntry* root) { + i::HashMap visited(AddressesMatch); i::List<i::HeapEntry*> list(10); list.Add(root); - root->paint(); CheckEntry(root); while (!list.is_empty()) { i::HeapEntry* entry = list.RemoveLast(); @@ -38,11 +43,15 @@ class NamedEntriesDetector { for (int i = 0; i < children.length(); ++i) { if (children[i]->type() == i::HeapGraphEdge::kShortcut) continue; i::HeapEntry* child = children[i]->to(); - if (!child->painted()) { - list.Add(child); - child->paint(); - CheckEntry(child); - } + i::HashMap::Entry* entry = visited.Lookup( + reinterpret_cast<void*>(child), + static_cast<uint32_t>(reinterpret_cast<uintptr_t>(child)), + true); + if (entry->value) + continue; + entry->value = reinterpret_cast<void*>(1); + list.Add(child); + CheckEntry(child); } } } @@ -57,11 +66,9 @@ class NamedEntriesDetector { static const v8::HeapGraphNode* GetGlobalObject( const v8::HeapSnapshot* snapshot) { - bool snapshot_enabled = i::Snapshot::IsEnabled(); - - CHECK_EQ((snapshot_enabled ? 3 : 2), snapshot->GetRoot()->GetChildrenCount()); + CHECK_EQ(2, snapshot->GetRoot()->GetChildrenCount()); const v8::HeapGraphNode* global_obj = - snapshot->GetRoot()->GetChild(snapshot_enabled ? 1 : 0)->GetToNode(); + snapshot->GetRoot()->GetChild(0)->GetToNode(); CHECK_EQ(0, strncmp("Object", const_cast<i::HeapEntry*>( reinterpret_cast<const i::HeapEntry*>(global_obj))->name(), 6)); return global_obj; @@ -107,9 +114,6 @@ TEST(HeapSnapshot) { "var c2 = new C2(a2);"); const v8::HeapSnapshot* snapshot_env2 = v8::HeapProfiler::TakeSnapshot(v8_str("env2")); - i::HeapSnapshot* i_snapshot_env2 = - const_cast<i::HeapSnapshot*>( - reinterpret_cast<const i::HeapSnapshot*>(snapshot_env2)); const v8::HeapGraphNode* global_env2 = GetGlobalObject(snapshot_env2); // Verify, that JS global object of env2 has '..2' properties. @@ -122,9 +126,7 @@ TEST(HeapSnapshot) { NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2")); CHECK_NE(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2")); - // Paint all nodes reachable from global object. NamedEntriesDetector det; - i_snapshot_env2->ClearPaint(); det.CheckAllReachables(const_cast<i::HeapEntry*>( reinterpret_cast<const i::HeapEntry*>(global_env2))); CHECK(det.has_A2); @@ -158,9 +160,9 @@ TEST(HeapSnapshotObjectSizes) { CHECK_NE(NULL, x2); // Test sizes. - CHECK_EQ(x->GetSelfSize() * 3, x->GetRetainedSize()); - CHECK_EQ(x1->GetSelfSize(), x1->GetRetainedSize()); - CHECK_EQ(x2->GetSelfSize(), x2->GetRetainedSize()); + CHECK_NE(0, x->GetSelfSize()); + CHECK_NE(0, x1->GetSelfSize()); + CHECK_NE(0, x2->GetSelfSize()); } @@ -479,66 +481,6 @@ TEST(HeapSnapshotRootPreservedAfterSorting) { } -TEST(HeapEntryDominator) { - // The graph looks like this: - // - // -> node1 - // a |^ - // -> node5 ba - // a v| - // node6 -> node2 - // b a |^ - // -> node4 ba - // b v| - // -> node3 - // - // The dominator for all nodes is node6. - - v8::HandleScope scope; - LocalContext env; - - CompileRun( - "function X(a, b) { this.a = a; this.b = b; }\n" - "node6 = new X(new X(new X()), new X(new X(),new X()));\n" - "(function(){\n" - "node6.a.a.b = node6.b.a; // node1 -> node2\n" - "node6.b.a.a = node6.a.a; // node2 -> node1\n" - "node6.b.a.b = node6.b.b; // node2 -> node3\n" - "node6.b.b.a = node6.b.a; // node3 -> node2\n" - "})();"); - - const v8::HeapSnapshot* snapshot = - v8::HeapProfiler::TakeSnapshot(v8_str("dominators")); - - const v8::HeapGraphNode* global = GetGlobalObject(snapshot); - CHECK_NE(NULL, global); - const v8::HeapGraphNode* node6 = - GetProperty(global, v8::HeapGraphEdge::kProperty, "node6"); - CHECK_NE(NULL, node6); - const v8::HeapGraphNode* node5 = - GetProperty(node6, v8::HeapGraphEdge::kProperty, "a"); - CHECK_NE(NULL, node5); - const v8::HeapGraphNode* node4 = - GetProperty(node6, v8::HeapGraphEdge::kProperty, "b"); - CHECK_NE(NULL, node4); - const v8::HeapGraphNode* node3 = - GetProperty(node4, v8::HeapGraphEdge::kProperty, "b"); - CHECK_NE(NULL, node3); - const v8::HeapGraphNode* node2 = - GetProperty(node4, v8::HeapGraphEdge::kProperty, "a"); - CHECK_NE(NULL, node2); - const v8::HeapGraphNode* node1 = - GetProperty(node5, v8::HeapGraphEdge::kProperty, "a"); - CHECK_NE(NULL, node1); - - CHECK_EQ(node6, node1->GetDominatorNode()); - CHECK_EQ(node6, node2->GetDominatorNode()); - CHECK_EQ(node6, node3->GetDominatorNode()); - CHECK_EQ(node6, node4->GetDominatorNode()); - CHECK_EQ(node6, node5->GetDominatorNode()); -} - - namespace { class TestJSONStream : public v8::OutputStream { @@ -623,7 +565,7 @@ TEST(HeapSnapshotJSONSerialization) { // Get node and edge "member" offsets. v8::Local<v8::Value> meta_analysis_result = CompileRun( "var meta = parsed.snapshot.meta;\n" - "var edges_index_offset = meta.node_fields.indexOf('edges_index');\n" + "var edge_count_offset = meta.node_fields.indexOf('edge_count');\n" "var node_fields_count = meta.node_fields.length;\n" "var edge_fields_count = meta.edge_fields.length;\n" "var edge_type_offset = meta.edge_fields.indexOf('type');\n" @@ -633,7 +575,13 @@ TEST(HeapSnapshotJSONSerialization) { " meta.edge_types[edge_type_offset].indexOf('property');\n" "var shortcut_type =" " meta.edge_types[edge_type_offset].indexOf('shortcut');\n" - "parsed.nodes.concat(0, 0, 0, 0, 0, 0, parsed.edges.length);"); + "var node_count = parsed.nodes.length / node_fields_count;\n" + "var first_edge_indexes = parsed.first_edge_indexes = [];\n" + "for (var i = 0, first_edge_index = 0; i < node_count; ++i) {\n" + " first_edge_indexes[i] = first_edge_index;\n" + " first_edge_index += edge_fields_count *\n" + " parsed.nodes[i * node_fields_count + edge_count_offset];\n" + "}\n"); CHECK(!meta_analysis_result.IsEmpty()); // A helper function for processing encoded nodes. @@ -642,8 +590,9 @@ TEST(HeapSnapshotJSONSerialization) { " var nodes = parsed.nodes;\n" " var edges = parsed.edges;\n" " var strings = parsed.strings;\n" - " for (var i = nodes[pos + edges_index_offset],\n" - " count = nodes[pos + node_fields_count + edges_index_offset];\n" + " var node_ordinal = pos / node_fields_count;\n" + " for (var i = parsed.first_edge_indexes[node_ordinal],\n" + " count = parsed.first_edge_indexes[node_ordinal + 1];\n" " i < count; i += edge_fields_count) {\n" " if (edges[i + edge_type_offset] === prop_type\n" " && strings[edges[i + edge_name_offset]] === prop_name)\n" @@ -652,29 +601,14 @@ TEST(HeapSnapshotJSONSerialization) { " return null;\n" "}\n"); // Get the string index using the path: <root> -> <global>.b.x.s - v8::Local<v8::Value> string_obj_pos_val; - if (i::Snapshot::IsEnabled()) { - // TODO(pvarga): Check shortcut_type issue at b when QML global object is used. - string_obj_pos_val = CompileRun( - "GetChildPosByProperty(\n" - " GetChildPosByProperty(\n" - " GetChildPosByProperty(" - " parsed.edges[parsed.nodes[edges_index_offset]" - " + edge_to_node_offset + edge_fields_count]," - " \"b\", property_type),\n" - " \"x\", property_type)," - " \"s\", property_type)"); - } else { - string_obj_pos_val = CompileRun( - "GetChildPosByProperty(\n" - " GetChildPosByProperty(\n" - " GetChildPosByProperty(" - " parsed.edges[parsed.nodes[edges_index_offset]" - " + edge_to_node_offset]," - " \"b\", property_type),\n" - " \"x\", property_type)," - " \"s\", property_type)"); - } + v8::Local<v8::Value> string_obj_pos_val = CompileRun( + "GetChildPosByProperty(\n" + " GetChildPosByProperty(\n" + " GetChildPosByProperty(" + " parsed.edges[edge_to_node_offset]," + " \"b\", property_type),\n" + " \"x\", property_type)," + " \"s\", property_type)"); CHECK(!string_obj_pos_val.IsEmpty()); int string_obj_pos = static_cast<int>(string_obj_pos_val->ToNumber()->Value()); @@ -763,9 +697,13 @@ class TestStatsStream : public v8::OutputStream { } // namespace -static TestStatsStream GetHeapStatsUpdate() { +static TestStatsStream GetHeapStatsUpdate( + v8::SnapshotObjectId* object_id = NULL) { TestStatsStream stream; - v8::HeapProfiler::PushHeapObjectsStats(&stream); + v8::SnapshotObjectId last_seen_id = + v8::HeapProfiler::PushHeapObjectsStats(&stream); + if (object_id) + *object_id = last_seen_id; CHECK_EQ(1, stream.eos_signaled()); return stream; } @@ -776,15 +714,16 @@ TEST(HeapSnapshotObjectsStats) { LocalContext env; v8::HeapProfiler::StartHeapObjectsTracking(); - // We have to call GC 5 times. In other case the garbage will be + // We have to call GC 6 times. In other case the garbage will be // the reason of flakiness. - for (int i = 0; i < 5; ++i) { + for (int i = 0; i < 6; ++i) { HEAP->CollectAllGarbage(i::Heap::kNoGCFlags); } + v8::SnapshotObjectId initial_id; { // Single chunk of data expected in update. Initial data. - TestStatsStream stats_update = GetHeapStatsUpdate(); + TestStatsStream stats_update = GetHeapStatsUpdate(&initial_id); CHECK_EQ(1, stats_update.intervals_count()); CHECK_EQ(1, stats_update.updates_written()); CHECK_LT(0, stats_update.entries_size()); @@ -792,13 +731,18 @@ TEST(HeapSnapshotObjectsStats) { } // No data expected in update because nothing has happened. - CHECK_EQ(0, GetHeapStatsUpdate().updates_written()); + v8::SnapshotObjectId same_id; + CHECK_EQ(0, GetHeapStatsUpdate(&same_id).updates_written()); + CHECK_EQ_SNAPSHOT_OBJECT_ID(initial_id, same_id); + { + v8::SnapshotObjectId additional_string_id; v8::HandleScope inner_scope_1; v8_str("string1"); { // Single chunk of data with one new entry expected in update. - TestStatsStream stats_update = GetHeapStatsUpdate(); + TestStatsStream stats_update = GetHeapStatsUpdate(&additional_string_id); + CHECK_LT(same_id, additional_string_id); CHECK_EQ(1, stats_update.intervals_count()); CHECK_EQ(1, stats_update.updates_written()); CHECK_LT(0, stats_update.entries_size()); @@ -807,7 +751,9 @@ TEST(HeapSnapshotObjectsStats) { } // No data expected in update because nothing happened. - CHECK_EQ(0, GetHeapStatsUpdate().updates_written()); + v8::SnapshotObjectId last_id; + CHECK_EQ(0, GetHeapStatsUpdate(&last_id).updates_written()); + CHECK_EQ_SNAPSHOT_OBJECT_ID(additional_string_id, last_id); { v8::HandleScope inner_scope_2; @@ -1503,6 +1449,36 @@ TEST(FastCaseGetter) { CHECK_NE(NULL, setterFunction); } +TEST(HiddenPropertiesFastCase) { + v8::HandleScope scope; + LocalContext env; + + CompileRun( + "function C(x) { this.a = this; this.b = x; }\n" + "c = new C(2012);\n"); + const v8::HeapSnapshot* snapshot = + v8::HeapProfiler::TakeSnapshot(v8_str("HiddenPropertiesFastCase1")); + const v8::HeapGraphNode* global = GetGlobalObject(snapshot); + const v8::HeapGraphNode* c = + GetProperty(global, v8::HeapGraphEdge::kProperty, "c"); + CHECK_NE(NULL, c); + const v8::HeapGraphNode* hidden_props = + GetProperty(c, v8::HeapGraphEdge::kInternal, "hidden_properties"); + CHECK_EQ(NULL, hidden_props); + + v8::Handle<v8::Value> cHandle = env->Global()->Get(v8::String::New("c")); + CHECK(!cHandle.IsEmpty() && cHandle->IsObject()); + cHandle->ToObject()->SetHiddenValue(v8_str("key"), v8_str("val")); + + snapshot = v8::HeapProfiler::TakeSnapshot( + v8_str("HiddenPropertiesFastCase2")); + global = GetGlobalObject(snapshot); + c = GetProperty(global, v8::HeapGraphEdge::kProperty, "c"); + CHECK_NE(NULL, c); + hidden_props = GetProperty(c, v8::HeapGraphEdge::kInternal, + "hidden_properties"); + CHECK_NE(NULL, hidden_props); +} bool HasWeakEdge(const v8::HeapGraphNode* node) { for (int i = 0; i < node->GetChildrenCount(); ++i) { @@ -1545,7 +1521,7 @@ TEST(WeakGlobalHandle) { } -TEST(WeakGlobalContextRefs) { +TEST(WeakNativeContextRefs) { v8::HandleScope scope; LocalContext env; @@ -1557,10 +1533,10 @@ TEST(WeakGlobalContextRefs) { const v8::HeapGraphNode* global_handles = GetNode( gc_roots, v8::HeapGraphNode::kObject, "(Global handles)"); CHECK_NE(NULL, global_handles); - const v8::HeapGraphNode* global_context = GetNode( - global_handles, v8::HeapGraphNode::kHidden, "system / GlobalContext"); - CHECK_NE(NULL, global_context); - CHECK(HasWeakEdge(global_context)); + const v8::HeapGraphNode* native_context = GetNode( + global_handles, v8::HeapGraphNode::kHidden, "system / NativeContext"); + CHECK_NE(NULL, native_context); + CHECK(HasWeakEdge(native_context)); } @@ -1583,6 +1559,7 @@ TEST(SfiAndJsFunctionWeakRefs) { } +#ifdef ENABLE_DEBUGGER_SUPPORT TEST(NoDebugObjectInSnapshot) { v8::HandleScope scope; LocalContext env; @@ -1594,8 +1571,6 @@ TEST(NoDebugObjectInSnapshot) { const v8::HeapGraphNode* root = snapshot->GetRoot(); int globals_count = 0; for (int i = 0; i < root->GetChildrenCount(); ++i) { - // QML global object should be skipped here when snapshot is enabled. - if (i::Snapshot::IsEnabled() && i % 2 == 0) continue; const v8::HeapGraphEdge* edge = root->GetChild(i); if (edge->GetType() == v8::HeapGraphEdge::kShortcut) { ++globals_count; @@ -1607,6 +1582,7 @@ TEST(NoDebugObjectInSnapshot) { } CHECK_EQ(1, globals_count); } +#endif // ENABLE_DEBUGGER_SUPPORT TEST(PersistentHandleCount) { @@ -1682,3 +1658,26 @@ TEST(NoRefsToNonEssentialEntries) { GetProperty(global_object, v8::HeapGraphEdge::kInternal, "elements"); CHECK_EQ(NULL, elements); } + + +TEST(MapHasDescriptorsAndTransitions) { + v8::HandleScope scope; + LocalContext env; + CompileRun("obj = { a: 10 };\n"); + const v8::HeapSnapshot* snapshot = + v8::HeapProfiler::TakeSnapshot(v8_str("snapshot")); + const v8::HeapGraphNode* global = GetGlobalObject(snapshot); + const v8::HeapGraphNode* global_object = + GetProperty(global, v8::HeapGraphEdge::kProperty, "obj"); + CHECK_NE(NULL, global_object); + + const v8::HeapGraphNode* map = + GetProperty(global_object, v8::HeapGraphEdge::kInternal, "map"); + CHECK_NE(NULL, map); + const v8::HeapGraphNode* own_descriptors = GetProperty( + map, v8::HeapGraphEdge::kInternal, "descriptors"); + CHECK_NE(NULL, own_descriptors); + const v8::HeapGraphNode* own_transitions = GetProperty( + map, v8::HeapGraphEdge::kInternal, "transitions"); + CHECK_EQ(NULL, own_transitions); +} diff --git a/src/3rdparty/v8/test/cctest/test-heap.cc b/src/3rdparty/v8/test/cctest/test-heap.cc index baee7e4..2bb3af6 100644 --- a/src/3rdparty/v8/test/cctest/test-heap.cc +++ b/src/3rdparty/v8/test/cctest/test-heap.cc @@ -4,12 +4,13 @@ #include "v8.h" +#include "compilation-cache.h" #include "execution.h" #include "factory.h" #include "macro-assembler.h" #include "global-handles.h" +#include "stub-cache.h" #include "cctest.h" -#include "snapshot.h" using namespace v8::internal; @@ -22,6 +23,19 @@ static void InitializeVM() { } +// Go through all incremental marking steps in one swoop. +static void SimulateIncrementalMarking() { + IncrementalMarking* marking = HEAP->incremental_marking(); + CHECK(marking->IsStopped()); + marking->Start(); + CHECK(marking->IsMarking()); + while (!marking->IsComplete()) { + marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD); + } + CHECK(marking->IsComplete()); +} + + static void CheckMap(Map* map, int type, int instance_size) { CHECK(map->IsHeapObject()); #ifdef DEBUG @@ -158,7 +172,8 @@ TEST(HeapObjects) { String* object_symbol = String::cast(HEAP->Object_symbol()); CHECK( - Isolate::Current()->context()->global()->HasLocalProperty(object_symbol)); + Isolate::Current()->context()->global_object()->HasLocalProperty( + object_symbol)); // Check ToString for oddballs CheckOddball(HEAP->true_value(), "true"); @@ -214,7 +229,7 @@ TEST(GarbageCollection) { Handle<Map> initial_map = FACTORY->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize); function->set_initial_map(*initial_map); - Isolate::Current()->context()->global()->SetProperty( + Isolate::Current()->context()->global_object()->SetProperty( *name, *function, NONE, kNonStrictMode)->ToObjectChecked(); // Allocate an object. Unrooted after leaving the scope. Handle<JSObject> obj = FACTORY->NewJSObject(function); @@ -230,9 +245,10 @@ TEST(GarbageCollection) { HEAP->CollectGarbage(NEW_SPACE); // Function should be alive. - CHECK(Isolate::Current()->context()->global()->HasLocalProperty(*name)); + CHECK(Isolate::Current()->context()->global_object()-> + HasLocalProperty(*name)); // Check function is retained. - Object* func_value = Isolate::Current()->context()->global()-> + Object* func_value = Isolate::Current()->context()->global_object()-> GetProperty(*name)->ToObjectChecked(); CHECK(func_value->IsJSFunction()); Handle<JSFunction> function(JSFunction::cast(func_value)); @@ -241,7 +257,7 @@ TEST(GarbageCollection) { HandleScope inner_scope; // Allocate another object, make it reachable from global. Handle<JSObject> obj = FACTORY->NewJSObject(function); - Isolate::Current()->context()->global()->SetProperty( + Isolate::Current()->context()->global_object()->SetProperty( *obj_name, *obj, NONE, kNonStrictMode)->ToObjectChecked(); obj->SetProperty( *prop_name, Smi::FromInt(23), NONE, kNonStrictMode)->ToObjectChecked(); @@ -250,10 +266,11 @@ TEST(GarbageCollection) { // After gc, it should survive. HEAP->CollectGarbage(NEW_SPACE); - CHECK(Isolate::Current()->context()->global()->HasLocalProperty(*obj_name)); - CHECK(Isolate::Current()->context()->global()-> + CHECK(Isolate::Current()->context()->global_object()-> + HasLocalProperty(*obj_name)); + CHECK(Isolate::Current()->context()->global_object()-> GetProperty(*obj_name)->ToObjectChecked()->IsJSObject()); - Object* obj = Isolate::Current()->context()->global()-> + Object* obj = Isolate::Current()->context()->global_object()-> GetProperty(*obj_name)->ToObjectChecked(); JSObject* js_obj = JSObject::cast(obj); CHECK_EQ(Smi::FromInt(23), js_obj->GetProperty(*prop_name)); @@ -416,6 +433,7 @@ TEST(WeakGlobalHandlesMark) { global_handles->Destroy(h1.location()); } + TEST(DeleteWeakGlobalHandle) { InitializeVM(); GlobalHandles* global_handles = Isolate::Current()->global_handles(); @@ -446,6 +464,7 @@ TEST(DeleteWeakGlobalHandle) { CHECK(WeakPointerCleared); } + static const char* not_so_random_string_table[] = { "abstract", "boolean", @@ -562,7 +581,7 @@ TEST(ObjectProperties) { v8::HandleScope sc; String* object_symbol = String::cast(HEAP->Object_symbol()); - Object* raw_object = Isolate::Current()->context()->global()-> + Object* raw_object = Isolate::Current()->context()->global_object()-> GetProperty(object_symbol)->ToObjectChecked(); JSFunction* object_function = JSFunction::cast(raw_object); Handle<JSFunction> constructor(object_function); @@ -659,7 +678,7 @@ TEST(JSArray) { v8::HandleScope sc; Handle<String> name = FACTORY->LookupAsciiSymbol("Array"); - Object* raw_object = Isolate::Current()->context()->global()-> + Object* raw_object = Isolate::Current()->context()->global_object()-> GetProperty(*name)->ToObjectChecked(); Handle<JSFunction> function = Handle<JSFunction>( JSFunction::cast(raw_object)); @@ -674,7 +693,7 @@ TEST(JSArray) { array->SetElementsLength(Smi::FromInt(0))->ToObjectChecked(); CHECK_EQ(Smi::FromInt(0), array->length()); // Must be in fast mode. - CHECK(array->HasFastTypeElements()); + CHECK(array->HasFastSmiOrObjectElements()); // array[length] = name. array->SetElement(0, *name, NONE, kNonStrictMode)->ToObjectChecked(); @@ -706,7 +725,7 @@ TEST(JSObjectCopy) { v8::HandleScope sc; String* object_symbol = String::cast(HEAP->Object_symbol()); - Object* raw_object = Isolate::Current()->context()->global()-> + Object* raw_object = Isolate::Current()->context()->global_object()-> GetProperty(object_symbol)->ToObjectChecked(); JSFunction* object_function = JSFunction::cast(raw_object); Handle<JSFunction> constructor(object_function); @@ -812,7 +831,9 @@ TEST(Iteration) { // Allocate a JS array to OLD_POINTER_SPACE and NEW_SPACE objs[next_objs_index++] = FACTORY->NewJSArray(10); - objs[next_objs_index++] = FACTORY->NewJSArray(10, FAST_ELEMENTS, TENURED); + objs[next_objs_index++] = FACTORY->NewJSArray(10, + FAST_HOLEY_ELEMENTS, + TENURED); // Allocate a small string to OLD_DATA_SPACE and NEW_SPACE objs[next_objs_index++] = @@ -873,7 +894,7 @@ TEST(Regression39128) { // Step 1: prepare a map for the object. We add 1 inobject property to it. Handle<JSFunction> object_ctor( - Isolate::Current()->global_context()->object_function()); + Isolate::Current()->native_context()->object_function()); CHECK(object_ctor->has_initial_map()); Handle<Map> object_map(object_ctor->initial_map()); // Create a map with single inobject property. @@ -934,9 +955,9 @@ TEST(Regression39128) { TEST(TestCodeFlushing) { - i::FLAG_allow_natives_syntax = true; // If we do not flush code this test is invalid. if (!FLAG_flush_code) return; + i::FLAG_allow_natives_syntax = true; InitializeVM(); v8::HandleScope scope; const char* source = "function foo() {" @@ -953,24 +974,22 @@ TEST(TestCodeFlushing) { } // Check function is compiled. - Object* func_value = Isolate::Current()->context()->global()-> + Object* func_value = Isolate::Current()->context()->global_object()-> GetProperty(*foo_name)->ToObjectChecked(); CHECK(func_value->IsJSFunction()); Handle<JSFunction> function(JSFunction::cast(func_value)); CHECK(function->shared()->is_compiled()); - // TODO(1609) Currently incremental marker does not support code flushing. - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); - + // The code will survive at least two GCs. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); CHECK(function->shared()->is_compiled()); - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); - HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); + // Simulate several GCs that use full marking. + const int kAgingThreshold = 6; + for (int i = 0; i < kAgingThreshold; i++) { + HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask); + } // foo should no longer be in the compilation cache CHECK(!function->shared()->is_compiled() || function->IsOptimized()); @@ -982,10 +1001,201 @@ TEST(TestCodeFlushing) { } -// Count the number of global contexts in the weak list of global contexts. -static int CountGlobalContexts() { +TEST(TestCodeFlushingIncremental) { + // If we do not flush code this test is invalid. + if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return; + i::FLAG_allow_natives_syntax = true; + InitializeVM(); + v8::HandleScope scope; + const char* source = "function foo() {" + " var x = 42;" + " var y = 42;" + " var z = x + y;" + "};" + "foo()"; + Handle<String> foo_name = FACTORY->LookupAsciiSymbol("foo"); + + // This compile will add the code to the compilation cache. + { v8::HandleScope scope; + CompileRun(source); + } + + // Check function is compiled. + Object* func_value = Isolate::Current()->context()->global_object()-> + GetProperty(*foo_name)->ToObjectChecked(); + CHECK(func_value->IsJSFunction()); + Handle<JSFunction> function(JSFunction::cast(func_value)); + CHECK(function->shared()->is_compiled()); + + // The code will survive at least two GCs. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + CHECK(function->shared()->is_compiled()); + + // Simulate several GCs that use incremental marking. + const int kAgingThreshold = 6; + for (int i = 0; i < kAgingThreshold; i++) { + HEAP->incremental_marking()->Abort(); + SimulateIncrementalMarking(); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + } + CHECK(!function->shared()->is_compiled() || function->IsOptimized()); + CHECK(!function->is_compiled() || function->IsOptimized()); + + // This compile will compile the function again. + { v8::HandleScope scope; + CompileRun("foo();"); + } + + // Simulate several GCs that use incremental marking but make sure + // the loop breaks once the function is enqueued as a candidate. + for (int i = 0; i < kAgingThreshold; i++) { + HEAP->incremental_marking()->Abort(); + SimulateIncrementalMarking(); + if (!function->next_function_link()->IsUndefined()) break; + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + } + + // Force optimization while incremental marking is active and while + // the function is enqueued as a candidate. + { v8::HandleScope scope; + CompileRun("%OptimizeFunctionOnNextCall(foo); foo();"); + } + + // Simulate one final GC to make sure the candidate queue is sane. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + CHECK(function->shared()->is_compiled() || !function->IsOptimized()); + CHECK(function->is_compiled() || !function->IsOptimized()); +} + + +TEST(TestCodeFlushingIncrementalScavenge) { + // If we do not flush code this test is invalid. + if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return; + i::FLAG_allow_natives_syntax = true; + InitializeVM(); + v8::HandleScope scope; + const char* source = "var foo = function() {" + " var x = 42;" + " var y = 42;" + " var z = x + y;" + "};" + "foo();" + "var bar = function() {" + " var x = 23;" + "};" + "bar();"; + Handle<String> foo_name = FACTORY->LookupAsciiSymbol("foo"); + Handle<String> bar_name = FACTORY->LookupAsciiSymbol("bar"); + + // Perfrom one initial GC to enable code flushing. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + // This compile will add the code to the compilation cache. + { v8::HandleScope scope; + CompileRun(source); + } + + // Check functions are compiled. + Object* func_value = Isolate::Current()->context()->global_object()-> + GetProperty(*foo_name)->ToObjectChecked(); + CHECK(func_value->IsJSFunction()); + Handle<JSFunction> function(JSFunction::cast(func_value)); + CHECK(function->shared()->is_compiled()); + Object* func_value2 = Isolate::Current()->context()->global_object()-> + GetProperty(*bar_name)->ToObjectChecked(); + CHECK(func_value2->IsJSFunction()); + Handle<JSFunction> function2(JSFunction::cast(func_value2)); + CHECK(function2->shared()->is_compiled()); + + // Clear references to functions so that one of them can die. + { v8::HandleScope scope; + CompileRun("foo = 0; bar = 0;"); + } + + // Bump the code age so that flushing is triggered while the function + // object is still located in new-space. + const int kAgingThreshold = 6; + function->shared()->set_code_age(kAgingThreshold); + function2->shared()->set_code_age(kAgingThreshold); + + // Simulate incremental marking so that the functions are enqueued as + // code flushing candidates. Then kill one of the functions. Finally + // perform a scavenge while incremental marking is still running. + SimulateIncrementalMarking(); + *function2.location() = NULL; + HEAP->CollectGarbage(NEW_SPACE, "test scavenge while marking"); + + // Simulate one final GC to make sure the candidate queue is sane. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + CHECK(!function->shared()->is_compiled() || function->IsOptimized()); + CHECK(!function->is_compiled() || function->IsOptimized()); +} + + +TEST(TestCodeFlushingIncrementalAbort) { + // If we do not flush code this test is invalid. + if (!FLAG_flush_code || !FLAG_flush_code_incrementally) return; + i::FLAG_allow_natives_syntax = true; + InitializeVM(); + v8::HandleScope scope; + const char* source = "function foo() {" + " var x = 42;" + " var y = 42;" + " var z = x + y;" + "};" + "foo()"; + Handle<String> foo_name = FACTORY->LookupAsciiSymbol("foo"); + + // This compile will add the code to the compilation cache. + { v8::HandleScope scope; + CompileRun(source); + } + + // Check function is compiled. + Object* func_value = Isolate::Current()->context()->global_object()-> + GetProperty(*foo_name)->ToObjectChecked(); + CHECK(func_value->IsJSFunction()); + Handle<JSFunction> function(JSFunction::cast(func_value)); + CHECK(function->shared()->is_compiled()); + + // The code will survive at least two GCs. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + CHECK(function->shared()->is_compiled()); + + // Bump the code age so that flushing is triggered. + const int kAgingThreshold = 6; + function->shared()->set_code_age(kAgingThreshold); + + // Simulate incremental marking so that the function is enqueued as + // code flushing candidate. + SimulateIncrementalMarking(); + + // Enable the debugger and add a breakpoint while incremental marking + // is running so that incremental marking aborts and code flushing is + // disabled. + int position = 0; + Handle<Object> breakpoint_object(Smi::FromInt(0)); + ISOLATE->debug()->SetBreakPoint(function, breakpoint_object, &position); + ISOLATE->debug()->ClearAllBreakPoints(); + + // Force optimization now that code flushing is disabled. + { v8::HandleScope scope; + CompileRun("%OptimizeFunctionOnNextCall(foo); foo();"); + } + + // Simulate one final GC to make sure the candidate queue is sane. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + CHECK(function->shared()->is_compiled() || !function->IsOptimized()); + CHECK(function->is_compiled() || !function->IsOptimized()); +} + + +// Count the number of native contexts in the weak list of native contexts. +int CountNativeContexts() { int count = 0; - Object* object = HEAP->global_contexts_list(); + Object* object = HEAP->native_contexts_list(); while (!object->IsUndefined()) { count++; object = Context::cast(object)->get(Context::NEXT_CONTEXT_LINK); @@ -995,7 +1205,7 @@ static int CountGlobalContexts() { // Count the number of user functions in the weak list of optimized -// functions attached to a global context. +// functions attached to a native context. static int CountOptimizedUserFunctions(v8::Handle<v8::Context> context) { int count = 0; Handle<Context> icontext = v8::Utils::OpenHandle(*context); @@ -1016,7 +1226,7 @@ TEST(TestInternalWeakLists) { v8::HandleScope scope; v8::Persistent<v8::Context> ctx[kNumTestContexts]; - CHECK_EQ(0, CountGlobalContexts()); + CHECK_EQ(0, CountNativeContexts()); // Create a number of global contests which gets linked together. for (int i = 0; i < kNumTestContexts; i++) { @@ -1024,7 +1234,7 @@ TEST(TestInternalWeakLists) { bool opt = (FLAG_always_opt && i::V8::UseCrankshaft()); - CHECK_EQ(i + 1, CountGlobalContexts()); + CHECK_EQ(i + 1, CountNativeContexts()); ctx[i]->Enter(); @@ -1059,6 +1269,7 @@ TEST(TestInternalWeakLists) { } // Mark compact handles the weak references. + ISOLATE->compilation_cache()->Clear(); HEAP->CollectAllGarbage(Heap::kNoGCFlags); CHECK_EQ(opt ? 4 : 0, CountOptimizedUserFunctions(ctx[i])); @@ -1084,7 +1295,7 @@ TEST(TestInternalWeakLists) { // Force compilation cache cleanup. HEAP->CollectAllGarbage(Heap::kNoGCFlags); - // Dispose the global contexts one by one. + // Dispose the native contexts one by one. for (int i = 0; i < kNumTestContexts; i++) { ctx[i].Dispose(); ctx[i].Clear(); @@ -1092,23 +1303,23 @@ TEST(TestInternalWeakLists) { // Scavenge treats these references as strong. for (int j = 0; j < 10; j++) { HEAP->PerformScavenge(); - CHECK_EQ(kNumTestContexts - i, CountGlobalContexts()); + CHECK_EQ(kNumTestContexts - i, CountNativeContexts()); } // Mark compact handles the weak references. HEAP->CollectAllGarbage(Heap::kNoGCFlags); - CHECK_EQ(kNumTestContexts - i - 1, CountGlobalContexts()); + CHECK_EQ(kNumTestContexts - i - 1, CountNativeContexts()); } - CHECK_EQ(0, CountGlobalContexts()); + CHECK_EQ(0, CountNativeContexts()); } -// Count the number of global contexts in the weak list of global contexts +// Count the number of native contexts in the weak list of native contexts // causing a GC after the specified number of elements. -static int CountGlobalContextsWithGC(int n) { +static int CountNativeContextsWithGC(int n) { int count = 0; - Handle<Object> object(HEAP->global_contexts_list()); + Handle<Object> object(HEAP->native_contexts_list()); while (!object->IsUndefined()) { count++; if (count == n) HEAP->CollectAllGarbage(Heap::kNoGCFlags); @@ -1120,7 +1331,7 @@ static int CountGlobalContextsWithGC(int n) { // Count the number of user functions in the weak list of optimized -// functions attached to a global context causing a GC after the +// functions attached to a native context causing a GC after the // specified number of elements. static int CountOptimizedUserFunctionsWithGC(v8::Handle<v8::Context> context, int n) { @@ -1146,14 +1357,14 @@ TEST(TestInternalWeakListsTraverseWithGC) { v8::HandleScope scope; v8::Persistent<v8::Context> ctx[kNumTestContexts]; - CHECK_EQ(0, CountGlobalContexts()); + CHECK_EQ(0, CountNativeContexts()); // Create an number of contexts and check the length of the weak list both // with and without GCs while iterating the list. for (int i = 0; i < kNumTestContexts; i++) { ctx[i] = v8::Context::New(); - CHECK_EQ(i + 1, CountGlobalContexts()); - CHECK_EQ(i + 1, CountGlobalContextsWithGC(i / 2 + 1)); + CHECK_EQ(i + 1, CountNativeContexts()); + CHECK_EQ(i + 1, CountNativeContextsWithGC(i / 2 + 1)); } bool opt = (FLAG_always_opt && i::V8::UseCrankshaft()); @@ -1197,6 +1408,7 @@ TEST(TestSizeOfObjects) { HEAP->CollectAllGarbage(Heap::kNoGCFlags); HEAP->CollectAllGarbage(Heap::kNoGCFlags); HEAP->CollectAllGarbage(Heap::kNoGCFlags); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); CHECK(HEAP->old_pointer_space()->IsSweepingComplete()); int initial_size = static_cast<int>(HEAP->SizeOfObjects()); @@ -1237,7 +1449,9 @@ TEST(TestSizeOfObjectsVsHeapIteratorPrecision) { for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) { - size_of_objects_2 += obj->Size(); + if (!obj->IsFreeSpace()) { + size_of_objects_2 += obj->Size(); + } } // Delta must be within 5% of the larger result. // TODO(gc): Tighten this up by distinguishing between byte @@ -1278,7 +1492,8 @@ TEST(GrowAndShrinkNewSpace) { InitializeVM(); NewSpace* new_space = HEAP->new_space(); - if (HEAP->ReservedSemiSpaceSize() == HEAP->InitialSemiSpaceSize()) { + if (HEAP->ReservedSemiSpaceSize() == HEAP->InitialSemiSpaceSize() || + HEAP->MaxSemiSpaceSize() == HEAP->InitialSemiSpaceSize()) { // The max size cannot exceed the reserved size, since semispaces must be // always within the reserved space. We can't test new space growing and // shrinking if the reserved size is the same as the minimum (initial) size. @@ -1326,7 +1541,8 @@ TEST(GrowAndShrinkNewSpace) { TEST(CollectingAllAvailableGarbageShrinksNewSpace) { InitializeVM(); - if (HEAP->ReservedSemiSpaceSize() == HEAP->InitialSemiSpaceSize()) { + if (HEAP->ReservedSemiSpaceSize() == HEAP->InitialSemiSpaceSize() || + HEAP->MaxSemiSpaceSize() == HEAP->InitialSemiSpaceSize()) { // The max size cannot exceed the reserved size, since semispaces must be // always within the reserved space. We can't test new space growing and // shrinking if the reserved size is the same as the minimum (initial) size. @@ -1359,16 +1575,15 @@ static int NumberOfGlobalObjects() { // Test that we don't embed maps from foreign contexts into // optimized code. -TEST(LeakGlobalContextViaMap) { +TEST(LeakNativeContextViaMap) { i::FLAG_allow_natives_syntax = true; - bool snapshot_enabled = i::Snapshot::IsEnabled(); v8::HandleScope outer_scope; v8::Persistent<v8::Context> ctx1 = v8::Context::New(); v8::Persistent<v8::Context> ctx2 = v8::Context::New(); ctx1->Enter(); HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 6 : 4), NumberOfGlobalObjects()); + CHECK_EQ(4, NumberOfGlobalObjects()); { v8::HandleScope inner_scope; @@ -1386,9 +1601,10 @@ TEST(LeakGlobalContextViaMap) { ctx2->Exit(); ctx1->Exit(); ctx1.Dispose(); + v8::V8::ContextDisposedNotification(); } HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 3 : 2), NumberOfGlobalObjects()); + CHECK_EQ(2, NumberOfGlobalObjects()); ctx2.Dispose(); HEAP->CollectAllAvailableGarbage(); CHECK_EQ(0, NumberOfGlobalObjects()); @@ -1397,16 +1613,15 @@ TEST(LeakGlobalContextViaMap) { // Test that we don't embed functions from foreign contexts into // optimized code. -TEST(LeakGlobalContextViaFunction) { +TEST(LeakNativeContextViaFunction) { i::FLAG_allow_natives_syntax = true; - bool snapshot_enabled = i::Snapshot::IsEnabled(); v8::HandleScope outer_scope; v8::Persistent<v8::Context> ctx1 = v8::Context::New(); v8::Persistent<v8::Context> ctx2 = v8::Context::New(); ctx1->Enter(); HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 6 : 4), NumberOfGlobalObjects()); + CHECK_EQ(4, NumberOfGlobalObjects()); { v8::HandleScope inner_scope; @@ -1424,25 +1639,25 @@ TEST(LeakGlobalContextViaFunction) { ctx2->Exit(); ctx1->Exit(); ctx1.Dispose(); + v8::V8::ContextDisposedNotification(); } HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 3 : 2), NumberOfGlobalObjects()); + CHECK_EQ(2, NumberOfGlobalObjects()); ctx2.Dispose(); HEAP->CollectAllAvailableGarbage(); CHECK_EQ(0, NumberOfGlobalObjects()); } -TEST(LeakGlobalContextViaMapKeyed) { +TEST(LeakNativeContextViaMapKeyed) { i::FLAG_allow_natives_syntax = true; - bool snapshot_enabled = i::Snapshot::IsEnabled(); v8::HandleScope outer_scope; v8::Persistent<v8::Context> ctx1 = v8::Context::New(); v8::Persistent<v8::Context> ctx2 = v8::Context::New(); ctx1->Enter(); HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 6 : 4), NumberOfGlobalObjects()); + CHECK_EQ(4, NumberOfGlobalObjects()); { v8::HandleScope inner_scope; @@ -1460,25 +1675,25 @@ TEST(LeakGlobalContextViaMapKeyed) { ctx2->Exit(); ctx1->Exit(); ctx1.Dispose(); + v8::V8::ContextDisposedNotification(); } HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 3 : 2), NumberOfGlobalObjects()); + CHECK_EQ(2, NumberOfGlobalObjects()); ctx2.Dispose(); HEAP->CollectAllAvailableGarbage(); CHECK_EQ(0, NumberOfGlobalObjects()); } -TEST(LeakGlobalContextViaMapProto) { +TEST(LeakNativeContextViaMapProto) { i::FLAG_allow_natives_syntax = true; - bool snapshot_enabled = i::Snapshot::IsEnabled(); v8::HandleScope outer_scope; v8::Persistent<v8::Context> ctx1 = v8::Context::New(); v8::Persistent<v8::Context> ctx2 = v8::Context::New(); ctx1->Enter(); HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 6 : 4), NumberOfGlobalObjects()); + CHECK_EQ(4, NumberOfGlobalObjects()); { v8::HandleScope inner_scope; @@ -1500,9 +1715,10 @@ TEST(LeakGlobalContextViaMapProto) { ctx2->Exit(); ctx1->Exit(); ctx1.Dispose(); + v8::V8::ContextDisposedNotification(); } HEAP->CollectAllAvailableGarbage(); - CHECK_EQ((snapshot_enabled ? 3 : 2), NumberOfGlobalObjects()); + CHECK_EQ(2, NumberOfGlobalObjects()); ctx2.Dispose(); HEAP->CollectAllAvailableGarbage(); CHECK_EQ(0, NumberOfGlobalObjects()); @@ -1511,9 +1727,10 @@ TEST(LeakGlobalContextViaMapProto) { TEST(InstanceOfStubWriteBarrier) { i::FLAG_allow_natives_syntax = true; -#ifdef DEBUG +#ifdef VERIFY_HEAP i::FLAG_verify_heap = true; #endif + InitializeVM(); if (!i::V8::UseCrankshaft()) return; v8::HandleScope outer_scope; @@ -1585,22 +1802,24 @@ TEST(PrototypeTransitionClearing) { // Verify that only dead prototype transitions are cleared. CHECK_EQ(10, baseObject->map()->NumberOfProtoTransitions()); HEAP->CollectAllGarbage(Heap::kNoGCFlags); - CHECK_EQ(10 - 3, baseObject->map()->NumberOfProtoTransitions()); + const int transitions = 10 - 3; + CHECK_EQ(transitions, baseObject->map()->NumberOfProtoTransitions()); // Verify that prototype transitions array was compacted. - FixedArray* trans = baseObject->map()->prototype_transitions(); - for (int i = 0; i < 10 - 3; i++) { + FixedArray* trans = baseObject->map()->GetPrototypeTransitions(); + for (int i = 0; i < transitions; i++) { int j = Map::kProtoTransitionHeaderSize + i * Map::kProtoTransitionElementsPerEntry; CHECK(trans->get(j + Map::kProtoTransitionMapOffset)->IsMap()); - CHECK(trans->get(j + Map::kProtoTransitionPrototypeOffset)->IsJSObject()); + Object* proto = trans->get(j + Map::kProtoTransitionPrototypeOffset); + CHECK(proto->IsTheHole() || proto->IsJSObject()); } // Make sure next prototype is placed on an old-space evacuation candidate. Handle<JSObject> prototype; PagedSpace* space = HEAP->old_pointer_space(); do { - prototype = FACTORY->NewJSArray(32 * KB, FAST_ELEMENTS, TENURED); + prototype = FACTORY->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS, TENURED); } while (space->FirstPage() == space->LastPage() || !space->LastPage()->Contains(prototype->address())); @@ -1608,7 +1827,8 @@ TEST(PrototypeTransitionClearing) { // clearing correctly records slots in prototype transition array. i::FLAG_always_compact = true; Handle<Map> map(baseObject->map()); - CHECK(!space->LastPage()->Contains(map->prototype_transitions()->address())); + CHECK(!space->LastPage()->Contains( + map->GetPrototypeTransitions()->address())); CHECK(space->LastPage()->Contains(prototype->address())); baseObject->SetPrototype(*prototype, false)->ToObjectChecked(); CHECK(map->GetPrototypeTransition(*prototype)->IsMap()); @@ -1619,9 +1839,10 @@ TEST(PrototypeTransitionClearing) { TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) { i::FLAG_allow_natives_syntax = true; -#ifdef DEBUG +#ifdef VERIFY_HEAP i::FLAG_verify_heap = true; #endif + InitializeVM(); if (!i::V8::UseCrankshaft()) return; v8::HandleScope outer_scope; @@ -1674,9 +1895,10 @@ TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) { TEST(ResetSharedFunctionInfoCountersDuringMarkSweep) { i::FLAG_allow_natives_syntax = true; -#ifdef DEBUG +#ifdef VERIFY_HEAP i::FLAG_verify_heap = true; #endif + InitializeVM(); if (!i::V8::UseCrankshaft()) return; v8::HandleScope outer_scope; @@ -1743,14 +1965,7 @@ TEST(OptimizedAllocationAlwaysInNewSpace) { static int CountMapTransitions(Map* map) { - int result = 0; - DescriptorArray* descs = map->instance_descriptors(); - for (int i = 0; i < descs->number_of_descriptors(); i++) { - if (descs->IsTransitionOnly(i)) { - result++; - } - } - return result; + return map->transitions()->number_of_transitions(); } @@ -1761,14 +1976,18 @@ TEST(Regress1465) { i::FLAG_trace_incremental_marking = true; InitializeVM(); v8::HandleScope scope; + static const int transitions_count = 256; - #define TRANSITION_COUNT 256 - for (int i = 0; i < TRANSITION_COUNT; i++) { - EmbeddedVector<char, 64> buffer; - OS::SNPrintF(buffer, "var o = new Object; o.prop%d = %d;", i, i); - CompileRun(buffer.start()); + { + AlwaysAllocateScope always_allocate; + for (int i = 0; i < transitions_count; i++) { + EmbeddedVector<char, 64> buffer; + OS::SNPrintF(buffer, "var o = new Object; o.prop%d = %d;", i, i); + CompileRun(buffer.start()); + } + CompileRun("var root = new Object;"); } - CompileRun("var root = new Object;"); + Handle<JSObject> root = v8::Utils::OpenHandle( *v8::Handle<v8::Object>::Cast( @@ -1777,19 +1996,10 @@ TEST(Regress1465) { // Count number of live transitions before marking. int transitions_before = CountMapTransitions(root->map()); CompileRun("%DebugPrint(root);"); - CHECK_EQ(TRANSITION_COUNT, transitions_before); + CHECK_EQ(transitions_count, transitions_before); - // Go through all incremental marking steps in one swoop. - IncrementalMarking* marking = HEAP->incremental_marking(); - CHECK(marking->IsStopped()); - marking->Start(); - CHECK(marking->IsMarking()); - while (!marking->IsComplete()) { - marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD); - } - CHECK(marking->IsComplete()); + SimulateIncrementalMarking(); HEAP->CollectAllGarbage(Heap::kNoGCFlags); - CHECK(marking->IsStopped()); // Count number of live transitions after marking. Note that one transition // is left, because 'o' still holds an instance of one transition target. @@ -1797,3 +2007,496 @@ TEST(Regress1465) { CompileRun("%DebugPrint(root);"); CHECK_EQ(1, transitions_after); } + + +TEST(Regress2143a) { + i::FLAG_collect_maps = true; + i::FLAG_incremental_marking = true; + InitializeVM(); + v8::HandleScope scope; + + // Prepare a map transition from the root object together with a yet + // untransitioned root object. + CompileRun("var root = new Object;" + "root.foo = 0;" + "root = new Object;"); + + SimulateIncrementalMarking(); + + // Compile a StoreIC that performs the prepared map transition. This + // will restart incremental marking and should make sure the root is + // marked grey again. + CompileRun("function f(o) {" + " o.foo = 0;" + "}" + "f(new Object);" + "f(root);"); + + // This bug only triggers with aggressive IC clearing. + HEAP->AgeInlineCaches(); + + // Explicitly request GC to perform final marking step and sweeping. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + Handle<JSObject> root = + v8::Utils::OpenHandle( + *v8::Handle<v8::Object>::Cast( + v8::Context::GetCurrent()->Global()->Get(v8_str("root")))); + + // The root object should be in a sane state. + CHECK(root->IsJSObject()); + CHECK(root->map()->IsMap()); +} + + +TEST(Regress2143b) { + i::FLAG_collect_maps = true; + i::FLAG_incremental_marking = true; + i::FLAG_allow_natives_syntax = true; + InitializeVM(); + v8::HandleScope scope; + + // Prepare a map transition from the root object together with a yet + // untransitioned root object. + CompileRun("var root = new Object;" + "root.foo = 0;" + "root = new Object;"); + + SimulateIncrementalMarking(); + + // Compile an optimized LStoreNamedField that performs the prepared + // map transition. This will restart incremental marking and should + // make sure the root is marked grey again. + CompileRun("function f(o) {" + " o.foo = 0;" + "}" + "f(new Object);" + "f(new Object);" + "%OptimizeFunctionOnNextCall(f);" + "f(root);" + "%DeoptimizeFunction(f);"); + + // This bug only triggers with aggressive IC clearing. + HEAP->AgeInlineCaches(); + + // Explicitly request GC to perform final marking step and sweeping. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + Handle<JSObject> root = + v8::Utils::OpenHandle( + *v8::Handle<v8::Object>::Cast( + v8::Context::GetCurrent()->Global()->Get(v8_str("root")))); + + // The root object should be in a sane state. + CHECK(root->IsJSObject()); + CHECK(root->map()->IsMap()); +} + + +// Implemented in the test-alloc.cc test suite. +void SimulateFullSpace(PagedSpace* space); + + +TEST(ReleaseOverReservedPages) { + i::FLAG_trace_gc = true; + // The optimizer can allocate stuff, messing up the test. + i::FLAG_crankshaft = false; + i::FLAG_always_opt = false; + InitializeVM(); + v8::HandleScope scope; + static const int number_of_test_pages = 20; + + // Prepare many pages with low live-bytes count. + PagedSpace* old_pointer_space = HEAP->old_pointer_space(); + CHECK_EQ(1, old_pointer_space->CountTotalPages()); + for (int i = 0; i < number_of_test_pages; i++) { + AlwaysAllocateScope always_allocate; + SimulateFullSpace(old_pointer_space); + FACTORY->NewFixedArray(1, TENURED); + } + CHECK_EQ(number_of_test_pages + 1, old_pointer_space->CountTotalPages()); + + // Triggering one GC will cause a lot of garbage to be discovered but + // even spread across all allocated pages. + HEAP->CollectAllGarbage(Heap::kNoGCFlags, "triggered for preparation"); + CHECK_EQ(number_of_test_pages + 1, old_pointer_space->CountTotalPages()); + + // Triggering subsequent GCs should cause at least half of the pages + // to be released to the OS after at most two cycles. + HEAP->CollectAllGarbage(Heap::kNoGCFlags, "triggered by test 1"); + CHECK_GE(number_of_test_pages + 1, old_pointer_space->CountTotalPages()); + HEAP->CollectAllGarbage(Heap::kNoGCFlags, "triggered by test 2"); + CHECK_GE(number_of_test_pages + 1, old_pointer_space->CountTotalPages() * 2); + + // Triggering a last-resort GC should cause all pages to be released to the + // OS so that other processes can seize the memory. If we get a failure here + // where there are 2 pages left instead of 1, then we should increase the + // size of the first page a little in SizeOfFirstPage in spaces.cc. The + // first page should be small in order to reduce memory used when the VM + // boots, but if the 20 small arrays don't fit on the first page then that's + // an indication that it is too small. + HEAP->CollectAllAvailableGarbage("triggered really hard"); + CHECK_EQ(1, old_pointer_space->CountTotalPages()); +} + + +TEST(Regress2237) { + InitializeVM(); + v8::HandleScope scope; + Handle<String> slice(HEAP->empty_string()); + + { + // Generate a parent that lives in new-space. + v8::HandleScope inner_scope; + const char* c = "This text is long enough to trigger sliced strings."; + Handle<String> s = FACTORY->NewStringFromAscii(CStrVector(c)); + CHECK(s->IsSeqAsciiString()); + CHECK(HEAP->InNewSpace(*s)); + + // Generate a sliced string that is based on the above parent and + // lives in old-space. + FillUpNewSpace(HEAP->new_space()); + AlwaysAllocateScope always_allocate; + Handle<String> t; + // TODO(mstarzinger): Unfortunately FillUpNewSpace() still leaves + // some slack, so we need to allocate a few sliced strings. + for (int i = 0; i < 16; i++) { + t = FACTORY->NewProperSubString(s, 5, 35); + } + CHECK(t->IsSlicedString()); + CHECK(!HEAP->InNewSpace(*t)); + *slice.location() = *t.location(); + } + + CHECK(SlicedString::cast(*slice)->parent()->IsSeqAsciiString()); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + CHECK(SlicedString::cast(*slice)->parent()->IsSeqAsciiString()); +} + + +#ifdef OBJECT_PRINT +TEST(PrintSharedFunctionInfo) { + InitializeVM(); + v8::HandleScope scope; + const char* source = "f = function() { return 987654321; }\n" + "g = function() { return 123456789; }\n"; + CompileRun(source); + Handle<JSFunction> g = + v8::Utils::OpenHandle( + *v8::Handle<v8::Function>::Cast( + v8::Context::GetCurrent()->Global()->Get(v8_str("g")))); + + AssertNoAllocation no_alloc; + g->shared()->PrintLn(); +} +#endif // OBJECT_PRINT + + +TEST(Regress2211) { + InitializeVM(); + v8::HandleScope scope; + + v8::Handle<v8::String> value = v8_str("val string"); + Smi* hash = Smi::FromInt(321); + Heap* heap = Isolate::Current()->heap(); + + for (int i = 0; i < 2; i++) { + // Store identity hash first and common hidden property second. + v8::Handle<v8::Object> obj = v8::Object::New(); + Handle<JSObject> internal_obj = v8::Utils::OpenHandle(*obj); + CHECK(internal_obj->HasFastProperties()); + + // In the first iteration, set hidden value first and identity hash second. + // In the second iteration, reverse the order. + if (i == 0) obj->SetHiddenValue(v8_str("key string"), value); + MaybeObject* maybe_obj = internal_obj->SetIdentityHash(hash, + ALLOW_CREATION); + CHECK(!maybe_obj->IsFailure()); + if (i == 1) obj->SetHiddenValue(v8_str("key string"), value); + + // Check values. + CHECK_EQ(hash, + internal_obj->GetHiddenProperty(heap->identity_hash_symbol())); + CHECK(value->Equals(obj->GetHiddenValue(v8_str("key string")))); + + // Check size. + DescriptorArray* descriptors = internal_obj->map()->instance_descriptors(); + ObjectHashTable* hashtable = ObjectHashTable::cast( + internal_obj->FastPropertyAt(descriptors->GetFieldIndex(0))); + // HashTable header (5) and 4 initial entries (8). + CHECK_LE(hashtable->SizeFor(hashtable->length()), 13 * kPointerSize); + } +} + + +TEST(IncrementalMarkingClearsTypeFeedbackCells) { + if (i::FLAG_always_opt) return; + InitializeVM(); + v8::HandleScope scope; + v8::Local<v8::Value> fun1, fun2; + + { + LocalContext env; + CompileRun("function fun() {};"); + fun1 = env->Global()->Get(v8_str("fun")); + } + + { + LocalContext env; + CompileRun("function fun() {};"); + fun2 = env->Global()->Get(v8_str("fun")); + } + + // Prepare function f that contains type feedback for closures + // originating from two different native contexts. + v8::Context::GetCurrent()->Global()->Set(v8_str("fun1"), fun1); + v8::Context::GetCurrent()->Global()->Set(v8_str("fun2"), fun2); + CompileRun("function f(a, b) { a(); b(); } f(fun1, fun2);"); + Handle<JSFunction> f = + v8::Utils::OpenHandle( + *v8::Handle<v8::Function>::Cast( + v8::Context::GetCurrent()->Global()->Get(v8_str("f")))); + Handle<TypeFeedbackCells> cells(TypeFeedbackInfo::cast( + f->shared()->code()->type_feedback_info())->type_feedback_cells()); + + CHECK_EQ(2, cells->CellCount()); + CHECK(cells->Cell(0)->value()->IsJSFunction()); + CHECK(cells->Cell(1)->value()->IsJSFunction()); + + SimulateIncrementalMarking(); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + CHECK_EQ(2, cells->CellCount()); + CHECK(cells->Cell(0)->value()->IsTheHole()); + CHECK(cells->Cell(1)->value()->IsTheHole()); +} + + +static Code* FindFirstIC(Code* code, Code::Kind kind) { + int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET) | + RelocInfo::ModeMask(RelocInfo::CONSTRUCT_CALL) | + RelocInfo::ModeMask(RelocInfo::CODE_TARGET_WITH_ID) | + RelocInfo::ModeMask(RelocInfo::CODE_TARGET_CONTEXT); + for (RelocIterator it(code, mask); !it.done(); it.next()) { + RelocInfo* info = it.rinfo(); + Code* target = Code::GetCodeFromTargetAddress(info->target_address()); + if (target->is_inline_cache_stub() && target->kind() == kind) { + return target; + } + } + return NULL; +} + + +TEST(IncrementalMarkingPreservesMonomorhpicIC) { + if (i::FLAG_always_opt) return; + InitializeVM(); + v8::HandleScope scope; + + // Prepare function f that contains a monomorphic IC for object + // originating from the same native context. + CompileRun("function fun() { this.x = 1; }; var obj = new fun();" + "function f(o) { return o.x; } f(obj); f(obj);"); + Handle<JSFunction> f = + v8::Utils::OpenHandle( + *v8::Handle<v8::Function>::Cast( + v8::Context::GetCurrent()->Global()->Get(v8_str("f")))); + + Code* ic_before = FindFirstIC(f->shared()->code(), Code::LOAD_IC); + CHECK(ic_before->ic_state() == MONOMORPHIC); + + SimulateIncrementalMarking(); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + Code* ic_after = FindFirstIC(f->shared()->code(), Code::LOAD_IC); + CHECK(ic_after->ic_state() == MONOMORPHIC); +} + + +TEST(IncrementalMarkingClearsMonomorhpicIC) { + if (i::FLAG_always_opt) return; + InitializeVM(); + v8::HandleScope scope; + v8::Local<v8::Value> obj1; + + { + LocalContext env; + CompileRun("function fun() { this.x = 1; }; var obj = new fun();"); + obj1 = env->Global()->Get(v8_str("obj")); + } + + // Prepare function f that contains a monomorphic IC for object + // originating from a different native context. + v8::Context::GetCurrent()->Global()->Set(v8_str("obj1"), obj1); + CompileRun("function f(o) { return o.x; } f(obj1); f(obj1);"); + Handle<JSFunction> f = + v8::Utils::OpenHandle( + *v8::Handle<v8::Function>::Cast( + v8::Context::GetCurrent()->Global()->Get(v8_str("f")))); + + Code* ic_before = FindFirstIC(f->shared()->code(), Code::LOAD_IC); + CHECK(ic_before->ic_state() == MONOMORPHIC); + + // Fire context dispose notification. + v8::V8::ContextDisposedNotification(); + SimulateIncrementalMarking(); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + Code* ic_after = FindFirstIC(f->shared()->code(), Code::LOAD_IC); + CHECK(ic_after->ic_state() == UNINITIALIZED); +} + + +TEST(IncrementalMarkingClearsPolymorhpicIC) { + if (i::FLAG_always_opt) return; + InitializeVM(); + v8::HandleScope scope; + v8::Local<v8::Value> obj1, obj2; + + { + LocalContext env; + CompileRun("function fun() { this.x = 1; }; var obj = new fun();"); + obj1 = env->Global()->Get(v8_str("obj")); + } + + { + LocalContext env; + CompileRun("function fun() { this.x = 2; }; var obj = new fun();"); + obj2 = env->Global()->Get(v8_str("obj")); + } + + // Prepare function f that contains a polymorphic IC for objects + // originating from two different native contexts. + v8::Context::GetCurrent()->Global()->Set(v8_str("obj1"), obj1); + v8::Context::GetCurrent()->Global()->Set(v8_str("obj2"), obj2); + CompileRun("function f(o) { return o.x; } f(obj1); f(obj1); f(obj2);"); + Handle<JSFunction> f = + v8::Utils::OpenHandle( + *v8::Handle<v8::Function>::Cast( + v8::Context::GetCurrent()->Global()->Get(v8_str("f")))); + + Code* ic_before = FindFirstIC(f->shared()->code(), Code::LOAD_IC); + CHECK(ic_before->ic_state() == MEGAMORPHIC); + + // Fire context dispose notification. + v8::V8::ContextDisposedNotification(); + SimulateIncrementalMarking(); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + Code* ic_after = FindFirstIC(f->shared()->code(), Code::LOAD_IC); + CHECK(ic_after->ic_state() == UNINITIALIZED); +} + + +class SourceResource: public v8::String::ExternalAsciiStringResource { + public: + explicit SourceResource(const char* data) + : data_(data), length_(strlen(data)) { } + + virtual void Dispose() { + i::DeleteArray(data_); + data_ = NULL; + } + + const char* data() const { return data_; } + + size_t length() const { return length_; } + + bool IsDisposed() { return data_ == NULL; } + + private: + const char* data_; + size_t length_; +}; + + +TEST(ReleaseStackTraceData) { + // Test that the data retained by the Error.stack accessor is released + // after the first time the accessor is fired. We use external string + // to check whether the data is being released since the external string + // resource's callback is fired when the external string is GC'ed. + InitializeVM(); + v8::HandleScope scope; + static const char* source = "var error = 1; " + "try { " + " throw new Error(); " + "} catch (e) { " + " error = e; " + "} "; + SourceResource* resource = new SourceResource(i::StrDup(source)); + { + v8::HandleScope scope; + v8::Handle<v8::String> source_string = v8::String::NewExternal(resource); + v8::Script::Compile(source_string)->Run(); + CHECK(!resource->IsDisposed()); + } + HEAP->CollectAllAvailableGarbage(); + // External source is being retained by the stack trace. + CHECK(!resource->IsDisposed()); + + CompileRun("error.stack; error.stack;"); + HEAP->CollectAllAvailableGarbage(); + // External source has been released. + CHECK(resource->IsDisposed()); + + delete resource; +} + + +TEST(Regression144230) { + InitializeVM(); + v8::HandleScope scope; + + // First make sure that the uninitialized CallIC stub is on a single page + // that will later be selected as an evacuation candidate. + { + v8::HandleScope inner_scope; + AlwaysAllocateScope always_allocate; + SimulateFullSpace(HEAP->code_space()); + ISOLATE->stub_cache()->ComputeCallInitialize(9, RelocInfo::CODE_TARGET); + } + + // Second compile a CallIC and execute it once so that it gets patched to + // the pre-monomorphic stub. These code objects are on yet another page. + { + v8::HandleScope inner_scope; + AlwaysAllocateScope always_allocate; + SimulateFullSpace(HEAP->code_space()); + CompileRun("var o = { f:function(a,b,c,d,e,f,g,h,i) {}};" + "function call() { o.f(1,2,3,4,5,6,7,8,9); };" + "call();"); + } + + // Third we fill up the last page of the code space so that it does not get + // chosen as an evacuation candidate. + { + v8::HandleScope inner_scope; + AlwaysAllocateScope always_allocate; + CompileRun("for (var i = 0; i < 2000; i++) {" + " eval('function f' + i + '() { return ' + i +'; };' +" + " 'f' + i + '();');" + "}"); + } + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + // Fourth is the tricky part. Make sure the code containing the CallIC is + // visited first without clearing the IC. The shared function info is then + // visited later, causing the CallIC to be cleared. + Handle<String> name = FACTORY->LookupAsciiSymbol("call"); + Handle<GlobalObject> global(ISOLATE->context()->global_object()); + MaybeObject* maybe_call = global->GetProperty(*name); + JSFunction* call = JSFunction::cast(maybe_call->ToObjectChecked()); + USE(global->SetProperty(*name, Smi::FromInt(0), NONE, kNonStrictMode)); + ISOLATE->compilation_cache()->Clear(); + call->shared()->set_ic_age(HEAP->global_ic_age() + 1); + Handle<Object> call_code(call->code()); + Handle<Object> call_function(call); + + // Now we are ready to mess up the heap. + HEAP->CollectAllGarbage(Heap::kReduceMemoryFootprintMask); + + // Either heap verification caught the problem already or we go kaboom once + // the CallIC is executed the next time. + USE(global->SetProperty(*name, *call_function, NONE, kNonStrictMode)); + CompileRun("call();"); +} diff --git a/src/3rdparty/v8/test/cctest/test-list.cc b/src/3rdparty/v8/test/cctest/test-list.cc index 4c78f02..740b432 100644 --- a/src/3rdparty/v8/test/cctest/test-list.cc +++ b/src/3rdparty/v8/test/cctest/test-list.cc @@ -35,7 +35,7 @@ using namespace v8::internal; // Use a testing allocator that clears memory before deletion. class ZeroingAllocationPolicy { public: - static void* New(size_t size) { + void* New(size_t size) { // Stash the size in the first word to use for Delete. size_t true_size = size + sizeof(size_t); size_t* result = reinterpret_cast<size_t*>(malloc(true_size)); diff --git a/src/3rdparty/v8/test/cctest/test-liveedit.cc b/src/3rdparty/v8/test/cctest/test-liveedit.cc index 2498fca..2c89a38 100644 --- a/src/3rdparty/v8/test/cctest/test-liveedit.cc +++ b/src/3rdparty/v8/test/cctest/test-liveedit.cc @@ -81,7 +81,8 @@ class ListDiffOutputWriter : public Comparator::Output { (*next_chunk_pointer_) = NULL; } void AddChunk(int pos1, int pos2, int len1, int len2) { - current_chunk_ = new DiffChunkStruct(pos1, pos2, len1, len2); + current_chunk_ = new(Isolate::Current()->runtime_zone()) DiffChunkStruct( + pos1, pos2, len1, len2); (*next_chunk_pointer_) = current_chunk_; next_chunk_pointer_ = ¤t_chunk_->next; } @@ -95,7 +96,7 @@ void CompareStringsOneWay(const char* s1, const char* s2, int expected_diff_parameter = -1) { StringCompareInput input(s1, s2); - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); DiffChunkStruct* first_chunk; ListDiffOutputWriter writer(&first_chunk); diff --git a/src/3rdparty/v8/test/cctest/test-mark-compact.cc b/src/3rdparty/v8/test/cctest/test-mark-compact.cc index 700f322..c0ab763 100644 --- a/src/3rdparty/v8/test/cctest/test-mark-compact.cc +++ b/src/3rdparty/v8/test/cctest/test-mark-compact.cc @@ -194,7 +194,7 @@ TEST(MarkCompactCollector) { Map::cast(HEAP->AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize)->ToObjectChecked()); function->set_initial_map(initial_map); - Isolate::Current()->context()->global()->SetProperty( + Isolate::Current()->context()->global_object()->SetProperty( func_name, function, NONE, kNonStrictMode)->ToObjectChecked(); JSObject* obj = JSObject::cast( @@ -203,8 +203,9 @@ TEST(MarkCompactCollector) { func_name = String::cast(HEAP->LookupAsciiSymbol("theFunction")->ToObjectChecked()); - CHECK(Isolate::Current()->context()->global()->HasLocalProperty(func_name)); - Object* func_value = Isolate::Current()->context()->global()-> + CHECK(Isolate::Current()->context()->global_object()-> + HasLocalProperty(func_name)); + Object* func_value = Isolate::Current()->context()->global_object()-> GetProperty(func_name)->ToObjectChecked(); CHECK(func_value->IsJSFunction()); function = JSFunction::cast(func_value); @@ -212,7 +213,7 @@ TEST(MarkCompactCollector) { obj = JSObject::cast(HEAP->AllocateJSObject(function)->ToObjectChecked()); String* obj_name = String::cast(HEAP->LookupAsciiSymbol("theObject")->ToObjectChecked()); - Isolate::Current()->context()->global()->SetProperty( + Isolate::Current()->context()->global_object()->SetProperty( obj_name, obj, NONE, kNonStrictMode)->ToObjectChecked(); String* prop_name = String::cast(HEAP->LookupAsciiSymbol("theSlot")->ToObjectChecked()); @@ -225,10 +226,11 @@ TEST(MarkCompactCollector) { obj_name = String::cast(HEAP->LookupAsciiSymbol("theObject")->ToObjectChecked()); - CHECK(Isolate::Current()->context()->global()->HasLocalProperty(obj_name)); - CHECK(Isolate::Current()->context()->global()-> + CHECK(Isolate::Current()->context()->global_object()-> + HasLocalProperty(obj_name)); + CHECK(Isolate::Current()->context()->global_object()-> GetProperty(obj_name)->ToObjectChecked()->IsJSObject()); - obj = JSObject::cast(Isolate::Current()->context()->global()-> + obj = JSObject::cast(Isolate::Current()->context()->global_object()-> GetProperty(obj_name)->ToObjectChecked()); prop_name = String::cast(HEAP->LookupAsciiSymbol("theSlot")->ToObjectChecked()); @@ -526,23 +528,26 @@ static intptr_t MemoryInUse() { TEST(BootUpMemoryUse) { intptr_t initial_memory = MemoryInUse(); - FLAG_crankshaft = false; // Avoid flakiness. + // Avoid flakiness. + FLAG_crankshaft = false; + FLAG_parallel_recompilation = false; + // Only Linux has the proc filesystem and only if it is mapped. If it's not // there we just skip the test. if (initial_memory >= 0) { InitializeVM(); - intptr_t booted_memory = MemoryInUse(); + intptr_t delta = MemoryInUse() - initial_memory; if (sizeof(initial_memory) == 8) { if (v8::internal::Snapshot::IsEnabled()) { - CHECK_LE(booted_memory - initial_memory, 3600 * 1024); // 3396. + CHECK_LE(delta, 3600 * 1024); // 3396. } else { - CHECK_LE(booted_memory - initial_memory, 3600 * 1024); // 3432. + CHECK_LE(delta, 4000 * 1024); // 3948. } } else { if (v8::internal::Snapshot::IsEnabled()) { - CHECK_LE(booted_memory - initial_memory, 2800 * 1024); // 2484. + CHECK_LE(delta, 2500 * 1024); // 2400. } else { - CHECK_LE(booted_memory - initial_memory, 2950 * 1024); // 2844 + CHECK_LE(delta, 2860 * 1024); // 2760. } } } diff --git a/src/3rdparty/v8/test/cctest/test-object-observe.cc b/src/3rdparty/v8/test/cctest/test-object-observe.cc new file mode 100644 index 0000000..374dca4 --- /dev/null +++ b/src/3rdparty/v8/test/cctest/test-object-observe.cc @@ -0,0 +1,196 @@ +// 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. + +#include "v8.h" + +#include "cctest.h" + +using namespace v8; + +namespace { +// Need to create a new isolate when FLAG_harmony_observation is on. +class HarmonyIsolate { + public: + HarmonyIsolate() { + i::FLAG_harmony_observation = true; + isolate_ = Isolate::New(); + isolate_->Enter(); + } + + ~HarmonyIsolate() { + isolate_->Exit(); + isolate_->Dispose(); + } + + private: + Isolate* isolate_; +}; +} + +TEST(PerIsolateState) { + HarmonyIsolate isolate; + HandleScope scope; + LocalContext context1; + CompileRun( + "var count = 0;" + "var calls = 0;" + "var observer = function(records) { count = records.length; calls++ };" + "var obj = {};" + "Object.observe(obj, observer);"); + Handle<Value> observer = CompileRun("observer"); + Handle<Value> obj = CompileRun("obj"); + Handle<Value> notify_fun1 = CompileRun( + "(function() { obj.foo = 'bar'; })"); + Handle<Value> notify_fun2; + { + LocalContext context2; + context2->Global()->Set(String::New("obj"), obj); + notify_fun2 = CompileRun( + "(function() { obj.foo = 'baz'; })"); + } + Handle<Value> notify_fun3; + { + LocalContext context3; + context3->Global()->Set(String::New("obj"), obj); + notify_fun3 = CompileRun( + "(function() { obj.foo = 'bat'; })"); + } + { + LocalContext context4; + context4->Global()->Set(String::New("observer"), observer); + context4->Global()->Set(String::New("fun1"), notify_fun1); + context4->Global()->Set(String::New("fun2"), notify_fun2); + context4->Global()->Set(String::New("fun3"), notify_fun3); + CompileRun("fun1(); fun2(); fun3(); Object.deliverChangeRecords(observer)"); + } + CHECK_EQ(1, CompileRun("calls")->Int32Value()); + CHECK_EQ(3, CompileRun("count")->Int32Value()); +} + +TEST(EndOfMicrotaskDelivery) { + HarmonyIsolate isolate; + HandleScope scope; + LocalContext context; + CompileRun( + "var obj = {};" + "var count = 0;" + "var observer = function(records) { count = records.length };" + "Object.observe(obj, observer);" + "obj.foo = 'bar';"); + CHECK_EQ(1, CompileRun("count")->Int32Value()); +} + +TEST(DeliveryOrdering) { + HarmonyIsolate isolate; + HandleScope scope; + LocalContext context; + CompileRun( + "var obj1 = {};" + "var obj2 = {};" + "var ordering = [];" + "function observer2() { ordering.push(2); };" + "function observer1() { ordering.push(1); };" + "function observer3() { ordering.push(3); };" + "Object.observe(obj1, observer1);" + "Object.observe(obj1, observer2);" + "Object.observe(obj1, observer3);" + "obj1.foo = 'bar';"); + CHECK_EQ(3, CompileRun("ordering.length")->Int32Value()); + CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value()); + CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value()); + CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value()); + CompileRun( + "ordering = [];" + "Object.observe(obj2, observer3);" + "Object.observe(obj2, observer2);" + "Object.observe(obj2, observer1);" + "obj2.foo = 'baz'"); + CHECK_EQ(3, CompileRun("ordering.length")->Int32Value()); + CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value()); + CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value()); + CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value()); +} + +TEST(DeliveryOrderingReentrant) { + HarmonyIsolate isolate; + HandleScope scope; + LocalContext context; + CompileRun( + "var obj = {};" + "var reentered = false;" + "var ordering = [];" + "function observer1() { ordering.push(1); };" + "function observer2() {" + " if (!reentered) {" + " obj.foo = 'baz';" + " reentered = true;" + " }" + " ordering.push(2);" + "};" + "function observer3() { ordering.push(3); };" + "Object.observe(obj, observer1);" + "Object.observe(obj, observer2);" + "Object.observe(obj, observer3);" + "obj.foo = 'bar';"); + CHECK_EQ(5, CompileRun("ordering.length")->Int32Value()); + CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value()); + CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value()); + CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value()); + // Note that we re-deliver to observers 1 and 2, while observer3 + // already received the second record during the first round. + CHECK_EQ(1, CompileRun("ordering[3]")->Int32Value()); + CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value()); +} + +TEST(ObjectHashTableGrowth) { + HarmonyIsolate isolate; + HandleScope scope; + // Initializing this context sets up initial hash tables. + LocalContext context; + Handle<Value> obj = CompileRun("obj = {};"); + Handle<Value> observer = CompileRun( + "var ran = false;" + "(function() { ran = true })"); + { + // As does initializing this context. + LocalContext context2; + context2->Global()->Set(String::New("obj"), obj); + context2->Global()->Set(String::New("observer"), observer); + CompileRun( + "var objArr = [];" + // 100 objects should be enough to make the hash table grow + // (and thus relocate). + "for (var i = 0; i < 100; ++i) {" + " objArr.push({});" + " Object.observe(objArr[objArr.length-1], function(){});" + "}" + "Object.observe(obj, observer);"); + } + // obj is now marked "is_observed", but our map has moved. + CompileRun("obj.foo = 'bar'"); + CHECK(CompileRun("ran")->BooleanValue()); +} diff --git a/src/3rdparty/v8/test/cctest/test-parsing.cc b/src/3rdparty/v8/test/cctest/test-parsing.cc index 6bcae7c..717c665 100755 --- a/src/3rdparty/v8/test/cctest/test-parsing.cc +++ b/src/3rdparty/v8/test/cctest/test-parsing.cc @@ -354,7 +354,8 @@ TEST(Regress928) { v8::HandleScope handles; i::Handle<i::String> source( FACTORY->NewStringFromAscii(i::CStrVector(program))); - i::ScriptDataImpl* data = i::ParserApi::PartialPreParse(source, NULL, false); + i::GenericStringUtf16CharacterStream stream(source, 0, source->length()); + i::ScriptDataImpl* data = i::ParserApi::PreParse(&stream, NULL, false); CHECK(!data->HasError()); data->Initialize(); @@ -1016,11 +1017,11 @@ TEST(ScopePositions) { FACTORY->NewStringFromUtf8(i::CStrVector(program.start()))); CHECK_EQ(source->length(), kProgramSize); i::Handle<i::Script> script = FACTORY->NewScript(source); - i::Parser parser(script, i::kAllowLazy | i::EXTENDED_MODE, NULL, NULL); - i::CompilationInfo info(script); + i::CompilationInfoWithZone info(script); + i::Parser parser(&info, i::kAllowLazy | i::EXTENDED_MODE, NULL, NULL); info.MarkAsGlobal(); info.SetLanguageMode(source_data[i].language_mode); - i::FunctionLiteral* function = parser.ParseProgram(&info); + i::FunctionLiteral* function = parser.ParseProgram(); CHECK(function != NULL); // Check scope types and positions. @@ -1060,10 +1061,10 @@ void TestParserSync(i::Handle<i::String> source, int flags) { i::Handle<i::Script> script = FACTORY->NewScript(source); bool save_harmony_scoping = i::FLAG_harmony_scoping; i::FLAG_harmony_scoping = harmony_scoping; - i::Parser parser(script, flags, NULL, NULL); - i::CompilationInfo info(script); + i::CompilationInfoWithZone info(script); + i::Parser parser(&info, flags, NULL, NULL); info.MarkAsGlobal(); - i::FunctionLiteral* function = parser.ParseProgram(&info); + i::FunctionLiteral* function = parser.ParseProgram(); i::FLAG_harmony_scoping = save_harmony_scoping; i::String* type_string = NULL; @@ -1147,6 +1148,7 @@ TEST(ParserSync) { { "with ({})", "" }, { "switch (12) { case 12: ", "}" }, { "switch (12) { default: ", "}" }, + { "switch (12) { ", "case 12: }" }, { "label2: ", "" }, { NULL, NULL } }; @@ -1236,3 +1238,26 @@ TEST(ParserSync) { } } } + + +TEST(PreparserStrictOctal) { + // Test that syntax error caused by octal literal is reported correctly as + // such (issue 2220). + v8::internal::FLAG_min_preparse_length = 1; // Force preparsing. + v8::V8::Initialize(); + v8::HandleScope scope; + v8::Context::Scope context_scope(v8::Context::New()); + v8::TryCatch try_catch; + const char* script = + "\"use strict\"; \n" + "a = function() { \n" + " b = function() { \n" + " 01; \n" + " }; \n" + "}; \n"; + v8::Script::Compile(v8::String::New(script)); + CHECK(try_catch.HasCaught()); + v8::String::Utf8Value exception(try_catch.Exception()); + CHECK_EQ("SyntaxError: Octal literals are not allowed in strict mode.", + *exception); +} diff --git a/src/3rdparty/v8/test/cctest/test-platform-linux.cc b/src/3rdparty/v8/test/cctest/test-platform-linux.cc index 2a8d497..47b99f0 100644 --- a/src/3rdparty/v8/test/cctest/test-platform-linux.cc +++ b/src/3rdparty/v8/test/cctest/test-platform-linux.cc @@ -79,3 +79,9 @@ TEST(VirtualMemory) { CHECK(vm->Uncommit(block_addr, block_size)); delete vm; } + + +TEST(GetCurrentProcessId) { + OS::SetUp(); + CHECK_EQ(static_cast<int>(getpid()), OS::GetCurrentProcessId()); +} diff --git a/src/3rdparty/v8/test/cctest/test-platform-win32.cc b/src/3rdparty/v8/test/cctest/test-platform-win32.cc index 36b30aa..668ccdb 100644 --- a/src/3rdparty/v8/test/cctest/test-platform-win32.cc +++ b/src/3rdparty/v8/test/cctest/test-platform-win32.cc @@ -25,3 +25,10 @@ TEST(VirtualMemory) { CHECK(vm->Uncommit(block_addr, block_size)); delete vm; } + + +TEST(GetCurrentProcessId) { + OS::SetUp(); + CHECK_EQ(static_cast<int>(::GetCurrentProcessId()), + OS::GetCurrentProcessId()); +} diff --git a/src/3rdparty/v8/test/cctest/test-random.cc b/src/3rdparty/v8/test/cctest/test-random.cc index a1f4931..86d6d8c 100644 --- a/src/3rdparty/v8/test/cctest/test-random.cc +++ b/src/3rdparty/v8/test/cctest/test-random.cc @@ -52,7 +52,7 @@ void TestSeeds(Handle<JSFunction> fun, uint32_t state0, uint32_t state1) { bool has_pending_exception; - Handle<JSObject> global(context->global()); + Handle<JSObject> global(context->global_object()); Handle<ByteArray> seeds(context->random_seed()); SetSeeds(seeds, state0, state1); @@ -77,7 +77,7 @@ TEST(CrankshaftRandom) { env->Enter(); Handle<Context> context(Isolate::Current()->context()); - Handle<JSObject> global(context->global()); + Handle<JSObject> global(context->global_object()); Handle<ByteArray> seeds(context->random_seed()); bool has_pending_exception; @@ -85,7 +85,7 @@ TEST(CrankshaftRandom) { Object* symbol = FACTORY->LookupAsciiSymbol("f")->ToObjectChecked(); MaybeObject* fun_object = - context->global()->GetProperty(String::cast(symbol)); + context->global_object()->GetProperty(String::cast(symbol)); Handle<JSFunction> fun(JSFunction::cast(fun_object->ToObjectChecked())); // Optimize function. diff --git a/src/3rdparty/v8/test/cctest/test-regexp.cc b/src/3rdparty/v8/test/cctest/test-regexp.cc index e89e6cd..e433b92 100644 --- a/src/3rdparty/v8/test/cctest/test-regexp.cc +++ b/src/3rdparty/v8/test/cctest/test-regexp.cc @@ -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: @@ -72,23 +72,26 @@ using namespace v8::internal; static bool CheckParse(const char* input) { V8::Initialize(NULL); v8::HandleScope scope; - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); FlatStringReader reader(Isolate::Current(), CStrVector(input)); RegExpCompileData result; - return v8::internal::RegExpParser::ParseRegExp(&reader, false, &result); + return v8::internal::RegExpParser::ParseRegExp( + &reader, false, &result, Isolate::Current()->runtime_zone()); } static SmartArrayPointer<const char> Parse(const char* input) { V8::Initialize(NULL); v8::HandleScope scope; - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); FlatStringReader reader(Isolate::Current(), CStrVector(input)); RegExpCompileData result; - CHECK(v8::internal::RegExpParser::ParseRegExp(&reader, false, &result)); + CHECK(v8::internal::RegExpParser::ParseRegExp( + &reader, false, &result, Isolate::Current()->runtime_zone())); CHECK(result.tree != NULL); CHECK(result.error.is_null()); - SmartArrayPointer<const char> output = result.tree->ToString(); + SmartArrayPointer<const char> output = + result.tree->ToString(Isolate::Current()->runtime_zone()); return output; } @@ -96,10 +99,11 @@ static bool CheckSimple(const char* input) { V8::Initialize(NULL); v8::HandleScope scope; unibrow::Utf8InputBuffer<> buffer(input, StrLength(input)); - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); FlatStringReader reader(Isolate::Current(), CStrVector(input)); RegExpCompileData result; - CHECK(v8::internal::RegExpParser::ParseRegExp(&reader, false, &result)); + CHECK(v8::internal::RegExpParser::ParseRegExp( + &reader, false, &result, Isolate::Current()->runtime_zone())); CHECK(result.tree != NULL); CHECK(result.error.is_null()); return result.simple; @@ -114,10 +118,11 @@ static MinMaxPair CheckMinMaxMatch(const char* input) { V8::Initialize(NULL); v8::HandleScope scope; unibrow::Utf8InputBuffer<> buffer(input, StrLength(input)); - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); FlatStringReader reader(Isolate::Current(), CStrVector(input)); RegExpCompileData result; - CHECK(v8::internal::RegExpParser::ParseRegExp(&reader, false, &result)); + CHECK(v8::internal::RegExpParser::ParseRegExp( + &reader, false, &result, Isolate::Current()->runtime_zone())); CHECK(result.tree != NULL); CHECK(result.error.is_null()); int min_match = result.tree->min_match(); @@ -262,6 +267,7 @@ TEST(Parser) { CHECK_PARSE_EQ("\\u003z", "'u003z'"); CHECK_PARSE_EQ("foo[z]*", "(: 'foo' (# 0 - g [z]))"); + CHECK_SIMPLE("", false); CHECK_SIMPLE("a", true); CHECK_SIMPLE("a|b", false); CHECK_SIMPLE("a\\n", false); @@ -385,10 +391,11 @@ static void ExpectError(const char* input, const char* expected) { V8::Initialize(NULL); v8::HandleScope scope; - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); FlatStringReader reader(Isolate::Current(), CStrVector(input)); RegExpCompileData result; - CHECK(!v8::internal::RegExpParser::ParseRegExp(&reader, false, &result)); + CHECK(!v8::internal::RegExpParser::ParseRegExp( + &reader, false, &result, Isolate::Current()->runtime_zone())); CHECK(result.tree == NULL); CHECK(!result.error.is_null()); SmartArrayPointer<char> str = result.error->ToCString(ALLOW_NULLS); @@ -468,9 +475,11 @@ static bool NotWord(uc16 c) { static void TestCharacterClassEscapes(uc16 c, bool (pred)(uc16 c)) { - ZoneScope scope(Isolate::Current(), DELETE_ON_EXIT); - ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2); - CharacterRange::AddClassEscape(c, ranges); + ZoneScope scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + Zone* zone = Isolate::Current()->runtime_zone(); + ZoneList<CharacterRange>* ranges = + new(zone) ZoneList<CharacterRange>(2, zone); + CharacterRange::AddClassEscape(c, ranges, zone); for (unsigned i = 0; i < (1 << 16); i++) { bool in_class = false; for (int j = 0; !in_class && j < ranges->length(); j++) { @@ -500,14 +509,21 @@ static RegExpNode* Compile(const char* input, bool multiline, bool is_ascii) { FlatStringReader reader(isolate, CStrVector(input)); RegExpCompileData compile_data; if (!v8::internal::RegExpParser::ParseRegExp(&reader, multiline, - &compile_data)) + &compile_data, + isolate->runtime_zone())) return NULL; Handle<String> pattern = isolate->factory()-> NewStringFromUtf8(CStrVector(input)); Handle<String> sample_subject = isolate->factory()->NewStringFromUtf8(CStrVector("")); - RegExpEngine::Compile( - &compile_data, false, multiline, pattern, sample_subject, is_ascii); + RegExpEngine::Compile(&compile_data, + false, + false, + multiline, + pattern, + sample_subject, + is_ascii, + isolate->runtime_zone()); return compile_data.node; } @@ -517,7 +533,7 @@ static void Execute(const char* input, bool is_ascii, bool dot_output = false) { v8::HandleScope scope; - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); RegExpNode* node = Compile(input, multiline, is_ascii); USE(node); #ifdef DEBUG @@ -557,8 +573,8 @@ static unsigned PseudoRandom(int i, int j) { TEST(SplayTreeSimple) { v8::internal::V8::Initialize(NULL); static const unsigned kLimit = 1000; - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); - ZoneSplayTree<TestConfig> tree; + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + ZoneSplayTree<TestConfig> tree(Isolate::Current()->runtime_zone()); bool seen[kLimit]; for (unsigned i = 0; i < kLimit; i++) seen[i] = false; #define CHECK_MAPS_EQUAL() do { \ @@ -625,12 +641,13 @@ TEST(DispatchTableConstruction) { } } // Enter test data into dispatch table. - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); - DispatchTable table; + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + DispatchTable table(Isolate::Current()->runtime_zone()); for (int i = 0; i < kRangeCount; i++) { uc16* range = ranges[i]; for (int j = 0; j < 2 * kRangeSize; j += 2) - table.AddRange(CharacterRange(range[j], range[j + 1]), i); + table.AddRange(CharacterRange(range[j], range[j + 1]), i, + Isolate::Current()->runtime_zone()); } // Check that the table looks as we would expect for (int p = 0; p < kLimit; p++) { @@ -692,7 +709,8 @@ typedef RegExpMacroAssemblerMIPS ArchRegExpMacroAssembler; class ContextInitializer { public: ContextInitializer() - : env_(), scope_(), zone_(Isolate::Current(), DELETE_ON_EXIT) { + : env_(), scope_(), zone_(Isolate::Current()->runtime_zone(), + DELETE_ON_EXIT) { env_ = v8::Context::New(); env_->Enter(); } @@ -720,6 +738,7 @@ static ArchRegExpMacroAssembler::Result Execute(Code* code, input_start, input_end, captures, + 0, Isolate::Current()); } @@ -729,7 +748,8 @@ TEST(MacroAssemblerNativeSuccess) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, + Isolate::Current()->runtime_zone()); m.Succeed(); @@ -764,7 +784,8 @@ TEST(MacroAssemblerNativeSimple) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, + Isolate::Current()->runtime_zone()); uc16 foo_chars[3] = {'f', 'o', 'o'}; Vector<const uc16> foo(foo_chars, 3); @@ -821,7 +842,8 @@ TEST(MacroAssemblerNativeSimpleUC16) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4, + Isolate::Current()->runtime_zone()); uc16 foo_chars[3] = {'f', 'o', 'o'}; Vector<const uc16> foo(foo_chars, 3); @@ -883,7 +905,8 @@ TEST(MacroAssemblerNativeBacktrack) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0, + Isolate::Current()->runtime_zone()); Label fail; Label backtrack; @@ -921,7 +944,8 @@ TEST(MacroAssemblerNativeBackReferenceASCII) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, + Isolate::Current()->runtime_zone()); m.WriteCurrentPositionToRegister(0, 0); m.AdvanceCurrentPosition(2); @@ -968,7 +992,8 @@ TEST(MacroAssemblerNativeBackReferenceUC16) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4, + Isolate::Current()->runtime_zone()); m.WriteCurrentPositionToRegister(0, 0); m.AdvanceCurrentPosition(2); @@ -998,11 +1023,11 @@ TEST(MacroAssemblerNativeBackReferenceUC16) { int output[4]; NativeRegExpMacroAssembler::Result result = Execute(*code, - *input, - 0, - start_adr, - start_adr + input->length() * 2, - output); + *input, + 0, + start_adr, + start_adr + input->length() * 2, + output); CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); CHECK_EQ(0, output[0]); @@ -1018,7 +1043,8 @@ TEST(MacroAssemblernativeAtStart) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0, + Isolate::Current()->runtime_zone()); Label not_at_start, newline, fail; m.CheckNotAtStart(¬_at_start); @@ -1075,7 +1101,8 @@ TEST(MacroAssemblerNativeBackRefNoCase) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, + Isolate::Current()->runtime_zone()); Label fail, succ; @@ -1132,7 +1159,8 @@ TEST(MacroAssemblerNativeRegisters) { ContextInitializer initializer; Factory* factory = Isolate::Current()->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 6); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 6, + Isolate::Current()->runtime_zone()); uc16 foo_chars[3] = {'f', 'o', 'o'}; Vector<const uc16> foo(foo_chars, 3); @@ -1234,7 +1262,8 @@ TEST(MacroAssemblerStackOverflow) { Isolate* isolate = Isolate::Current(); Factory* factory = isolate->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0, + Isolate::Current()->runtime_zone()); Label loop; m.Bind(&loop); @@ -1272,7 +1301,8 @@ TEST(MacroAssemblerNativeLotsOfRegisters) { Isolate* isolate = Isolate::Current(); Factory* factory = isolate->factory(); - ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 2); + ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 2, + Isolate::Current()->runtime_zone()); // At least 2048, to ensure the allocated space for registers // span one full page. @@ -1319,7 +1349,8 @@ TEST(MacroAssemblerNativeLotsOfRegisters) { TEST(MacroAssembler) { V8::Initialize(NULL); byte codes[1024]; - RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024)); + RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024), + Isolate::Current()->runtime_zone()); // ^f(o)o. Label fail, fail2, start; uc16 foo_chars[3]; @@ -1389,17 +1420,20 @@ TEST(AddInverseToTable) { static const int kLimit = 1000; static const int kRangeCount = 16; for (int t = 0; t < 10; t++) { - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + Zone* zone = Isolate::Current()->runtime_zone(); ZoneList<CharacterRange>* ranges = - new ZoneList<CharacterRange>(kRangeCount); + new(zone) + ZoneList<CharacterRange>(kRangeCount, zone); for (int i = 0; i < kRangeCount; i++) { int from = PseudoRandom(t + 87, i + 25) % kLimit; int to = from + (PseudoRandom(i + 87, t + 25) % (kLimit / 20)); if (to > kLimit) to = kLimit; - ranges->Add(CharacterRange(from, to)); + ranges->Add(CharacterRange(from, to), zone); } - DispatchTable table; - DispatchTableConstructor cons(&table, false); + DispatchTable table(zone); + DispatchTableConstructor cons(&table, false, + Isolate::Current()->runtime_zone()); cons.set_choice_index(0); cons.AddInverse(ranges); for (int i = 0; i < kLimit; i++) { @@ -1410,12 +1444,14 @@ TEST(AddInverseToTable) { CHECK_EQ(is_on, set->Get(0) == false); } } - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + Zone* zone = Isolate::Current()->runtime_zone(); ZoneList<CharacterRange>* ranges = - new ZoneList<CharacterRange>(1); - ranges->Add(CharacterRange(0xFFF0, 0xFFFE)); - DispatchTable table; - DispatchTableConstructor cons(&table, false); + new(zone) ZoneList<CharacterRange>(1, zone); + ranges->Add(CharacterRange(0xFFF0, 0xFFFE), zone); + DispatchTable table(zone); + DispatchTableConstructor cons(&table, false, + Isolate::Current()->runtime_zone()); cons.set_choice_index(0); cons.AddInverse(ranges); CHECK(!table.Get(0xFFFE)->Get(0)); @@ -1523,10 +1559,12 @@ TEST(UncanonicalizeEquivalence) { static void TestRangeCaseIndependence(CharacterRange input, Vector<CharacterRange> expected) { - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + Zone* zone = Isolate::Current()->runtime_zone(); int count = expected.length(); - ZoneList<CharacterRange>* list = new ZoneList<CharacterRange>(count); - input.AddCaseEquivalents(list, false); + ZoneList<CharacterRange>* list = + new(zone) ZoneList<CharacterRange>(count, zone); + input.AddCaseEquivalents(list, false, zone); CHECK_EQ(count, list->length()); for (int i = 0; i < list->length(); i++) { CHECK_EQ(expected[i].from(), list->at(i).from()); @@ -1587,13 +1625,16 @@ static bool InClass(uc16 c, ZoneList<CharacterRange>* ranges) { TEST(CharClassDifference) { v8::internal::V8::Initialize(NULL); - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); - ZoneList<CharacterRange>* base = new ZoneList<CharacterRange>(1); - base->Add(CharacterRange::Everything()); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + Zone* zone = Isolate::Current()->runtime_zone(); + ZoneList<CharacterRange>* base = + new(zone) ZoneList<CharacterRange>(1, zone); + base->Add(CharacterRange::Everything(), zone); Vector<const int> overlay = CharacterRange::GetWordBounds(); ZoneList<CharacterRange>* included = NULL; ZoneList<CharacterRange>* excluded = NULL; - CharacterRange::Split(base, overlay, &included, &excluded); + CharacterRange::Split(base, overlay, &included, &excluded, + Isolate::Current()->runtime_zone()); for (int i = 0; i < (1 << 16); i++) { bool in_base = InClass(i, base); if (in_base) { @@ -1614,13 +1655,15 @@ TEST(CharClassDifference) { TEST(CanonicalizeCharacterSets) { v8::internal::V8::Initialize(NULL); - ZoneScope scope(Isolate::Current(), DELETE_ON_EXIT); - ZoneList<CharacterRange>* list = new ZoneList<CharacterRange>(4); + ZoneScope scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + Zone* zone = Isolate::Current()->runtime_zone(); + ZoneList<CharacterRange>* list = + new(zone) ZoneList<CharacterRange>(4, zone); CharacterSet set(list); - list->Add(CharacterRange(10, 20)); - list->Add(CharacterRange(30, 40)); - list->Add(CharacterRange(50, 60)); + list->Add(CharacterRange(10, 20), zone); + list->Add(CharacterRange(30, 40), zone); + list->Add(CharacterRange(50, 60), zone); set.Canonicalize(); ASSERT_EQ(3, list->length()); ASSERT_EQ(10, list->at(0).from()); @@ -1631,9 +1674,9 @@ TEST(CanonicalizeCharacterSets) { ASSERT_EQ(60, list->at(2).to()); list->Rewind(0); - list->Add(CharacterRange(10, 20)); - list->Add(CharacterRange(50, 60)); - list->Add(CharacterRange(30, 40)); + list->Add(CharacterRange(10, 20), zone); + list->Add(CharacterRange(50, 60), zone); + list->Add(CharacterRange(30, 40), zone); set.Canonicalize(); ASSERT_EQ(3, list->length()); ASSERT_EQ(10, list->at(0).from()); @@ -1644,11 +1687,11 @@ TEST(CanonicalizeCharacterSets) { ASSERT_EQ(60, list->at(2).to()); list->Rewind(0); - list->Add(CharacterRange(30, 40)); - list->Add(CharacterRange(10, 20)); - list->Add(CharacterRange(25, 25)); - list->Add(CharacterRange(100, 100)); - list->Add(CharacterRange(1, 1)); + list->Add(CharacterRange(30, 40), zone); + list->Add(CharacterRange(10, 20), zone); + list->Add(CharacterRange(25, 25), zone); + list->Add(CharacterRange(100, 100), zone); + list->Add(CharacterRange(1, 1), zone); set.Canonicalize(); ASSERT_EQ(5, list->length()); ASSERT_EQ(1, list->at(0).from()); @@ -1663,9 +1706,9 @@ TEST(CanonicalizeCharacterSets) { ASSERT_EQ(100, list->at(4).to()); list->Rewind(0); - list->Add(CharacterRange(10, 19)); - list->Add(CharacterRange(21, 30)); - list->Add(CharacterRange(20, 20)); + list->Add(CharacterRange(10, 19), zone); + list->Add(CharacterRange(21, 30), zone); + list->Add(CharacterRange(20, 20), zone); set.Canonicalize(); ASSERT_EQ(1, list->length()); ASSERT_EQ(10, list->at(0).from()); @@ -1675,9 +1718,10 @@ TEST(CanonicalizeCharacterSets) { TEST(CharacterRangeMerge) { v8::internal::V8::Initialize(NULL); - ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT); - ZoneList<CharacterRange> l1(4); - ZoneList<CharacterRange> l2(4); + ZoneScope zone_scope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); + ZoneList<CharacterRange> l1(4, Isolate::Current()->runtime_zone()); + ZoneList<CharacterRange> l2(4, Isolate::Current()->runtime_zone()); + Zone* zone = Isolate::Current()->runtime_zone(); // Create all combinations of intersections of ranges, both singletons and // longer. @@ -1692,8 +1736,8 @@ TEST(CharacterRangeMerge) { // Y - outside after for (int i = 0; i < 5; i++) { - l1.Add(CharacterRange::Singleton(offset + 2)); - l2.Add(CharacterRange::Singleton(offset + i)); + l1.Add(CharacterRange::Singleton(offset + 2), zone); + l2.Add(CharacterRange::Singleton(offset + i), zone); offset += 6; } @@ -1708,8 +1752,8 @@ TEST(CharacterRangeMerge) { // Y - disjoint after for (int i = 0; i < 7; i++) { - l1.Add(CharacterRange::Range(offset + 2, offset + 4)); - l2.Add(CharacterRange::Singleton(offset + i)); + l1.Add(CharacterRange::Range(offset + 2, offset + 4), zone); + l2.Add(CharacterRange::Singleton(offset + i), zone); offset += 8; } @@ -1729,35 +1773,35 @@ TEST(CharacterRangeMerge) { // YYYYYYYYYYYY - containing entirely. for (int i = 0; i < 9; i++) { - l1.Add(CharacterRange::Range(offset + 6, offset + 15)); // Length 8. - l2.Add(CharacterRange::Range(offset + 2 * i, offset + 2 * i + 3)); + l1.Add(CharacterRange::Range(offset + 6, offset + 15), zone); // Length 8. + l2.Add(CharacterRange::Range(offset + 2 * i, offset + 2 * i + 3), zone); offset += 22; } - l1.Add(CharacterRange::Range(offset + 6, offset + 15)); - l2.Add(CharacterRange::Range(offset + 6, offset + 15)); + l1.Add(CharacterRange::Range(offset + 6, offset + 15), zone); + l2.Add(CharacterRange::Range(offset + 6, offset + 15), zone); offset += 22; - l1.Add(CharacterRange::Range(offset + 6, offset + 15)); - l2.Add(CharacterRange::Range(offset + 4, offset + 17)); + l1.Add(CharacterRange::Range(offset + 6, offset + 15), zone); + l2.Add(CharacterRange::Range(offset + 4, offset + 17), zone); offset += 22; // Different kinds of multi-range overlap: // XXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXX // YYYY Y YYYY Y YYYY Y YYYY Y YYYY Y YYYY Y - l1.Add(CharacterRange::Range(offset, offset + 21)); - l1.Add(CharacterRange::Range(offset + 31, offset + 52)); + l1.Add(CharacterRange::Range(offset, offset + 21), zone); + l1.Add(CharacterRange::Range(offset + 31, offset + 52), zone); for (int i = 0; i < 6; i++) { - l2.Add(CharacterRange::Range(offset + 2, offset + 5)); - l2.Add(CharacterRange::Singleton(offset + 8)); + l2.Add(CharacterRange::Range(offset + 2, offset + 5), zone); + l2.Add(CharacterRange::Singleton(offset + 8), zone); offset += 9; } ASSERT(CharacterRange::IsCanonical(&l1)); ASSERT(CharacterRange::IsCanonical(&l2)); - ZoneList<CharacterRange> first_only(4); - ZoneList<CharacterRange> second_only(4); - ZoneList<CharacterRange> both(4); + ZoneList<CharacterRange> first_only(4, Isolate::Current()->runtime_zone()); + ZoneList<CharacterRange> second_only(4, Isolate::Current()->runtime_zone()); + ZoneList<CharacterRange> both(4, Isolate::Current()->runtime_zone()); } diff --git a/src/3rdparty/v8/test/cctest/test-serialize.cc b/src/3rdparty/v8/test/cctest/test-serialize.cc index e426e7b..8279182 100644 --- a/src/3rdparty/v8/test/cctest/test-serialize.cc +++ b/src/3rdparty/v8/test/cctest/test-serialize.cc @@ -196,8 +196,7 @@ class FileByteSink : public SnapshotByteSink { int data_space_used, int code_space_used, int map_space_used, - int cell_space_used, - int large_space_used); + int cell_space_used); private: FILE* fp_; @@ -211,8 +210,7 @@ void FileByteSink::WriteSpaceUsed( int data_space_used, int code_space_used, int map_space_used, - int cell_space_used, - int large_space_used) { + int cell_space_used) { int file_name_length = StrLength(file_name_) + 10; Vector<char> name = Vector<char>::New(file_name_length + 1); OS::SNPrintF(name, "%s.size", file_name_); @@ -224,7 +222,6 @@ void FileByteSink::WriteSpaceUsed( fprintf(fp, "code %d\n", code_space_used); fprintf(fp, "map %d\n", map_space_used); fprintf(fp, "cell %d\n", cell_space_used); - fprintf(fp, "large %d\n", large_space_used); fclose(fp); } @@ -233,6 +230,15 @@ static bool WriteToFile(const char* snapshot_file) { FileByteSink file(snapshot_file); StartupSerializer ser(&file); ser.Serialize(); + + file.WriteSpaceUsed( + ser.CurrentAllocationAddress(NEW_SPACE), + ser.CurrentAllocationAddress(OLD_POINTER_SPACE), + ser.CurrentAllocationAddress(OLD_DATA_SPACE), + ser.CurrentAllocationAddress(CODE_SPACE), + ser.CurrentAllocationAddress(MAP_SPACE), + ser.CurrentAllocationAddress(CELL_SPACE)); + return true; } @@ -250,18 +256,22 @@ static void Serialize() { // Test that the whole heap can be serialized. TEST(Serialize) { - Serializer::Enable(); - v8::V8::Initialize(); - Serialize(); + if (!Snapshot::HaveASnapshotToStartFrom()) { + Serializer::Enable(); + v8::V8::Initialize(); + Serialize(); + } } // Test that heap serialization is non-destructive. TEST(SerializeTwice) { - Serializer::Enable(); - v8::V8::Initialize(); - Serialize(); - Serialize(); + if (!Snapshot::HaveASnapshotToStartFrom()) { + Serializer::Enable(); + v8::V8::Initialize(); + Serialize(); + Serialize(); + } } @@ -275,11 +285,11 @@ static void Deserialize() { static void SanityCheck() { v8::HandleScope scope; -#ifdef DEBUG +#ifdef VERIFY_HEAP HEAP->Verify(); #endif - CHECK(Isolate::Current()->global()->IsJSObject()); - CHECK(Isolate::Current()->global_context()->IsContext()); + CHECK(Isolate::Current()->global_object()->IsJSObject()); + CHECK(Isolate::Current()->native_context()->IsContext()); CHECK(HEAP->symbol_table()->IsSymbolTable()); CHECK(!FACTORY->LookupAsciiSymbol("Empty")->IsFailure()); } @@ -289,7 +299,7 @@ DEPENDENT_TEST(Deserialize, Serialize) { // The serialize-deserialize tests only work if the VM is built without // serialization. That doesn't matter. We don't need to be able to // serialize a snapshot in a VM that is booted from a snapshot. - if (!Snapshot::IsEnabled()) { + if (!Snapshot::HaveASnapshotToStartFrom()) { v8::HandleScope scope; Deserialize(); @@ -302,7 +312,7 @@ DEPENDENT_TEST(Deserialize, Serialize) { DEPENDENT_TEST(DeserializeFromSecondSerialization, SerializeTwice) { - if (!Snapshot::IsEnabled()) { + if (!Snapshot::HaveASnapshotToStartFrom()) { v8::HandleScope scope; Deserialize(); @@ -315,7 +325,7 @@ DEPENDENT_TEST(DeserializeFromSecondSerialization, SerializeTwice) { DEPENDENT_TEST(DeserializeAndRunScript2, Serialize) { - if (!Snapshot::IsEnabled()) { + if (!Snapshot::HaveASnapshotToStartFrom()) { v8::HandleScope scope; Deserialize(); @@ -332,7 +342,7 @@ DEPENDENT_TEST(DeserializeAndRunScript2, Serialize) { DEPENDENT_TEST(DeserializeFromSecondSerializationAndRunScript2, SerializeTwice) { - if (!Snapshot::IsEnabled()) { + if (!Snapshot::HaveASnapshotToStartFrom()) { v8::HandleScope scope; Deserialize(); @@ -348,63 +358,74 @@ DEPENDENT_TEST(DeserializeFromSecondSerializationAndRunScript2, TEST(PartialSerialization) { - Serializer::Enable(); - v8::V8::Initialize(); + if (!Snapshot::HaveASnapshotToStartFrom()) { + Serializer::Enable(); + v8::V8::Initialize(); - v8::Persistent<v8::Context> env = v8::Context::New(); - ASSERT(!env.IsEmpty()); - env->Enter(); - // Make sure all builtin scripts are cached. - { HandleScope scope; - for (int i = 0; i < Natives::GetBuiltinsCount(); i++) { - Isolate::Current()->bootstrapper()->NativesSourceLookup(i); + v8::Persistent<v8::Context> env = v8::Context::New(); + ASSERT(!env.IsEmpty()); + env->Enter(); + // Make sure all builtin scripts are cached. + { HandleScope scope; + for (int i = 0; i < Natives::GetBuiltinsCount(); i++) { + Isolate::Current()->bootstrapper()->NativesSourceLookup(i); + } } - } - HEAP->CollectAllGarbage(Heap::kNoGCFlags); - HEAP->CollectAllGarbage(Heap::kNoGCFlags); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + HEAP->CollectAllGarbage(Heap::kNoGCFlags); - Object* raw_foo; - { - v8::HandleScope handle_scope; - v8::Local<v8::String> foo = v8::String::New("foo"); - ASSERT(!foo.IsEmpty()); - raw_foo = *(v8::Utils::OpenHandle(*foo)); - } - - int file_name_length = StrLength(FLAG_testing_serialization_file) + 10; - Vector<char> startup_name = Vector<char>::New(file_name_length + 1); - OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file); + Object* raw_foo; + { + v8::HandleScope handle_scope; + v8::Local<v8::String> foo = v8::String::New("foo"); + ASSERT(!foo.IsEmpty()); + raw_foo = *(v8::Utils::OpenHandle(*foo)); + } - env->Exit(); - env.Dispose(); + int file_name_length = StrLength(FLAG_testing_serialization_file) + 10; + Vector<char> startup_name = Vector<char>::New(file_name_length + 1); + OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file); - FileByteSink startup_sink(startup_name.start()); - startup_name.Dispose(); - StartupSerializer startup_serializer(&startup_sink); - startup_serializer.SerializeStrongReferences(); - - FileByteSink partial_sink(FLAG_testing_serialization_file); - PartialSerializer p_ser(&startup_serializer, &partial_sink); - p_ser.Serialize(&raw_foo); - startup_serializer.SerializeWeakReferences(); - partial_sink.WriteSpaceUsed(p_ser.CurrentAllocationAddress(NEW_SPACE), - p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE), - p_ser.CurrentAllocationAddress(OLD_DATA_SPACE), - p_ser.CurrentAllocationAddress(CODE_SPACE), - p_ser.CurrentAllocationAddress(MAP_SPACE), - p_ser.CurrentAllocationAddress(CELL_SPACE), - p_ser.CurrentAllocationAddress(LO_SPACE)); + env->Exit(); + env.Dispose(); + + FileByteSink startup_sink(startup_name.start()); + StartupSerializer startup_serializer(&startup_sink); + startup_serializer.SerializeStrongReferences(); + + FileByteSink partial_sink(FLAG_testing_serialization_file); + PartialSerializer p_ser(&startup_serializer, &partial_sink); + p_ser.Serialize(&raw_foo); + startup_serializer.SerializeWeakReferences(); + + partial_sink.WriteSpaceUsed( + p_ser.CurrentAllocationAddress(NEW_SPACE), + p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE), + p_ser.CurrentAllocationAddress(OLD_DATA_SPACE), + p_ser.CurrentAllocationAddress(CODE_SPACE), + p_ser.CurrentAllocationAddress(MAP_SPACE), + p_ser.CurrentAllocationAddress(CELL_SPACE)); + + startup_sink.WriteSpaceUsed( + startup_serializer.CurrentAllocationAddress(NEW_SPACE), + startup_serializer.CurrentAllocationAddress(OLD_POINTER_SPACE), + startup_serializer.CurrentAllocationAddress(OLD_DATA_SPACE), + startup_serializer.CurrentAllocationAddress(CODE_SPACE), + startup_serializer.CurrentAllocationAddress(MAP_SPACE), + startup_serializer.CurrentAllocationAddress(CELL_SPACE)); + startup_name.Dispose(); + } } -static void ReserveSpaceForPartialSnapshot(const char* file_name) { +static void ReserveSpaceForSnapshot(Deserializer* deserializer, + const char* file_name) { int file_name_length = StrLength(file_name) + 10; Vector<char> name = Vector<char>::New(file_name_length + 1); OS::SNPrintF(name, "%s.size", file_name); FILE* fp = OS::FOpen(name.start(), "r"); name.Dispose(); int new_size, pointer_size, data_size, code_size, map_size, cell_size; - int large_size; #ifdef _MSC_VER // Avoid warning about unsafe fscanf from MSVC. // Please note that this is only fine if %c and %s are not being used. @@ -416,18 +437,16 @@ static void ReserveSpaceForPartialSnapshot(const char* file_name) { CHECK_EQ(1, fscanf(fp, "code %d\n", &code_size)); CHECK_EQ(1, fscanf(fp, "map %d\n", &map_size)); CHECK_EQ(1, fscanf(fp, "cell %d\n", &cell_size)); - CHECK_EQ(1, fscanf(fp, "large %d\n", &large_size)); #ifdef _MSC_VER #undef fscanf #endif fclose(fp); - HEAP->ReserveSpace(new_size, - pointer_size, - data_size, - code_size, - map_size, - cell_size, - large_size); + deserializer->set_reservation(NEW_SPACE, new_size); + deserializer->set_reservation(OLD_POINTER_SPACE, pointer_size); + deserializer->set_reservation(OLD_DATA_SPACE, data_size); + deserializer->set_reservation(CODE_SPACE, code_size); + deserializer->set_reservation(MAP_SPACE, map_size); + deserializer->set_reservation(CELL_SPACE, cell_size); } @@ -441,7 +460,6 @@ DEPENDENT_TEST(PartialDeserialization, PartialSerialization) { startup_name.Dispose(); const char* file_name = FLAG_testing_serialization_file; - ReserveSpaceForPartialSnapshot(file_name); int snapshot_size = 0; byte* snapshot = ReadBytes(file_name, &snapshot_size); @@ -450,18 +468,19 @@ DEPENDENT_TEST(PartialDeserialization, PartialSerialization) { { SnapshotByteSource source(snapshot, snapshot_size); Deserializer deserializer(&source); + ReserveSpaceForSnapshot(&deserializer, file_name); deserializer.DeserializePartial(&root); CHECK(root->IsString()); } v8::HandleScope handle_scope; Handle<Object> root_handle(root); - ReserveSpaceForPartialSnapshot(file_name); Object* root2; { SnapshotByteSource source(snapshot, snapshot_size); Deserializer deserializer(&source); + ReserveSpaceForSnapshot(&deserializer, file_name); deserializer.DeserializePartial(&root2); CHECK(root2->IsString()); CHECK(*root_handle == root2); @@ -471,53 +490,64 @@ DEPENDENT_TEST(PartialDeserialization, PartialSerialization) { TEST(ContextSerialization) { - Serializer::Enable(); - v8::V8::Initialize(); + if (!Snapshot::HaveASnapshotToStartFrom()) { + Serializer::Enable(); + v8::V8::Initialize(); - v8::Persistent<v8::Context> env = v8::Context::New(); - ASSERT(!env.IsEmpty()); - env->Enter(); - // Make sure all builtin scripts are cached. - { HandleScope scope; - for (int i = 0; i < Natives::GetBuiltinsCount(); i++) { - Isolate::Current()->bootstrapper()->NativesSourceLookup(i); + v8::Persistent<v8::Context> env = v8::Context::New(); + ASSERT(!env.IsEmpty()); + env->Enter(); + // Make sure all builtin scripts are cached. + { HandleScope scope; + for (int i = 0; i < Natives::GetBuiltinsCount(); i++) { + Isolate::Current()->bootstrapper()->NativesSourceLookup(i); + } } - } - // If we don't do this then we end up with a stray root pointing at the - // context even after we have disposed of env. - HEAP->CollectAllGarbage(Heap::kNoGCFlags); + // If we don't do this then we end up with a stray root pointing at the + // context even after we have disposed of env. + HEAP->CollectAllGarbage(Heap::kNoGCFlags); + + int file_name_length = StrLength(FLAG_testing_serialization_file) + 10; + Vector<char> startup_name = Vector<char>::New(file_name_length + 1); + OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file); - int file_name_length = StrLength(FLAG_testing_serialization_file) + 10; - Vector<char> startup_name = Vector<char>::New(file_name_length + 1); - OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file); + env->Exit(); - env->Exit(); + Object* raw_context = *(v8::Utils::OpenHandle(*env)); - Object* raw_context = *(v8::Utils::OpenHandle(*env)); + env.Dispose(); - env.Dispose(); + FileByteSink startup_sink(startup_name.start()); + StartupSerializer startup_serializer(&startup_sink); + startup_serializer.SerializeStrongReferences(); + + FileByteSink partial_sink(FLAG_testing_serialization_file); + PartialSerializer p_ser(&startup_serializer, &partial_sink); + p_ser.Serialize(&raw_context); + startup_serializer.SerializeWeakReferences(); + + partial_sink.WriteSpaceUsed( + p_ser.CurrentAllocationAddress(NEW_SPACE), + p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE), + p_ser.CurrentAllocationAddress(OLD_DATA_SPACE), + p_ser.CurrentAllocationAddress(CODE_SPACE), + p_ser.CurrentAllocationAddress(MAP_SPACE), + p_ser.CurrentAllocationAddress(CELL_SPACE)); - FileByteSink startup_sink(startup_name.start()); - startup_name.Dispose(); - StartupSerializer startup_serializer(&startup_sink); - startup_serializer.SerializeStrongReferences(); - - FileByteSink partial_sink(FLAG_testing_serialization_file); - PartialSerializer p_ser(&startup_serializer, &partial_sink); - p_ser.Serialize(&raw_context); - startup_serializer.SerializeWeakReferences(); - partial_sink.WriteSpaceUsed(p_ser.CurrentAllocationAddress(NEW_SPACE), - p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE), - p_ser.CurrentAllocationAddress(OLD_DATA_SPACE), - p_ser.CurrentAllocationAddress(CODE_SPACE), - p_ser.CurrentAllocationAddress(MAP_SPACE), - p_ser.CurrentAllocationAddress(CELL_SPACE), - p_ser.CurrentAllocationAddress(LO_SPACE)); + startup_sink.WriteSpaceUsed( + startup_serializer.CurrentAllocationAddress(NEW_SPACE), + startup_serializer.CurrentAllocationAddress(OLD_POINTER_SPACE), + startup_serializer.CurrentAllocationAddress(OLD_DATA_SPACE), + startup_serializer.CurrentAllocationAddress(CODE_SPACE), + startup_serializer.CurrentAllocationAddress(MAP_SPACE), + startup_serializer.CurrentAllocationAddress(CELL_SPACE)); + startup_name.Dispose(); + } } DEPENDENT_TEST(ContextDeserialization, ContextSerialization) { - if (!Snapshot::IsEnabled()) { + if (!Snapshot::HaveASnapshotToStartFrom()) { int file_name_length = StrLength(FLAG_testing_serialization_file) + 10; Vector<char> startup_name = Vector<char>::New(file_name_length + 1); OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file); @@ -526,7 +556,6 @@ DEPENDENT_TEST(ContextDeserialization, ContextSerialization) { startup_name.Dispose(); const char* file_name = FLAG_testing_serialization_file; - ReserveSpaceForPartialSnapshot(file_name); int snapshot_size = 0; byte* snapshot = ReadBytes(file_name, &snapshot_size); @@ -535,18 +564,19 @@ DEPENDENT_TEST(ContextDeserialization, ContextSerialization) { { SnapshotByteSource source(snapshot, snapshot_size); Deserializer deserializer(&source); + ReserveSpaceForSnapshot(&deserializer, file_name); deserializer.DeserializePartial(&root); CHECK(root->IsContext()); } v8::HandleScope handle_scope; Handle<Object> root_handle(root); - ReserveSpaceForPartialSnapshot(file_name); Object* root2; { SnapshotByteSource source(snapshot, snapshot_size); Deserializer deserializer(&source); + ReserveSpaceForSnapshot(&deserializer, file_name); deserializer.DeserializePartial(&root2); CHECK(root2->IsContext()); CHECK(*root_handle != root2); @@ -555,119 +585,6 @@ DEPENDENT_TEST(ContextDeserialization, ContextSerialization) { } -TEST(LinearAllocation) { - v8::V8::Initialize(); - int new_space_max = 512 * KB; - int paged_space_max = Page::kMaxNonCodeHeapObjectSize; - int code_space_max = HEAP->code_space()->AreaSize(); - - for (int size = 1000; size < 5 * MB; size += size >> 1) { - size &= ~8; // Round. - int new_space_size = (size < new_space_max) ? size : new_space_max; - int paged_space_size = (size < paged_space_max) ? size : paged_space_max; - HEAP->ReserveSpace( - new_space_size, - paged_space_size, // Old pointer space. - paged_space_size, // Old data space. - HEAP->code_space()->RoundSizeDownToObjectAlignment(code_space_max), - HEAP->map_space()->RoundSizeDownToObjectAlignment(paged_space_size), - HEAP->cell_space()->RoundSizeDownToObjectAlignment(paged_space_size), - size); // Large object space. - LinearAllocationScope linear_allocation_scope; - const int kSmallFixedArrayLength = 4; - const int kSmallFixedArraySize = - FixedArray::kHeaderSize + kSmallFixedArrayLength * kPointerSize; - const int kSmallStringLength = 16; - const int kSmallStringSize = - (SeqAsciiString::kHeaderSize + kSmallStringLength + - kObjectAlignmentMask) & ~kObjectAlignmentMask; - const int kMapSize = Map::kSize; - - Object* new_last = NULL; - for (int i = 0; - i + kSmallFixedArraySize <= new_space_size; - i += kSmallFixedArraySize) { - Object* obj = - HEAP->AllocateFixedArray(kSmallFixedArrayLength)->ToObjectChecked(); - if (new_last != NULL) { - CHECK(reinterpret_cast<char*>(obj) == - reinterpret_cast<char*>(new_last) + kSmallFixedArraySize); - } - new_last = obj; - } - - Object* pointer_last = NULL; - for (int i = 0; - i + kSmallFixedArraySize <= paged_space_size; - i += kSmallFixedArraySize) { - Object* obj = HEAP->AllocateFixedArray(kSmallFixedArrayLength, - TENURED)->ToObjectChecked(); - int old_page_fullness = i % Page::kPageSize; - int page_fullness = (i + kSmallFixedArraySize) % Page::kPageSize; - if (page_fullness < old_page_fullness || - page_fullness > HEAP->old_pointer_space()->AreaSize()) { - i = RoundUp(i, Page::kPageSize); - pointer_last = NULL; - } - if (pointer_last != NULL) { - CHECK(reinterpret_cast<char*>(obj) == - reinterpret_cast<char*>(pointer_last) + kSmallFixedArraySize); - } - pointer_last = obj; - } - - Object* data_last = NULL; - for (int i = 0; - i + kSmallStringSize <= paged_space_size; - i += kSmallStringSize) { - Object* obj = HEAP->AllocateRawAsciiString(kSmallStringLength, - TENURED)->ToObjectChecked(); - int old_page_fullness = i % Page::kPageSize; - int page_fullness = (i + kSmallStringSize) % Page::kPageSize; - if (page_fullness < old_page_fullness || - page_fullness > HEAP->old_data_space()->AreaSize()) { - i = RoundUp(i, Page::kPageSize); - data_last = NULL; - } - if (data_last != NULL) { - CHECK(reinterpret_cast<char*>(obj) == - reinterpret_cast<char*>(data_last) + kSmallStringSize); - } - data_last = obj; - } - - Object* map_last = NULL; - for (int i = 0; i + kMapSize <= paged_space_size; i += kMapSize) { - Object* obj = HEAP->AllocateMap(JS_OBJECT_TYPE, - 42 * kPointerSize)->ToObjectChecked(); - int old_page_fullness = i % Page::kPageSize; - int page_fullness = (i + kMapSize) % Page::kPageSize; - if (page_fullness < old_page_fullness || - page_fullness > HEAP->map_space()->AreaSize()) { - i = RoundUp(i, Page::kPageSize); - map_last = NULL; - } - if (map_last != NULL) { - CHECK(reinterpret_cast<char*>(obj) == - reinterpret_cast<char*>(map_last) + kMapSize); - } - map_last = obj; - } - - if (size > Page::kMaxNonCodeHeapObjectSize) { - // Support for reserving space in large object space is not there yet, - // but using an always-allocate scope is fine for now. - AlwaysAllocateScope always; - int large_object_array_length = - (size - FixedArray::kHeaderSize) / kPointerSize; - Object* obj = HEAP->AllocateFixedArray(large_object_array_length, - TENURED)->ToObjectChecked(); - CHECK(!obj->IsFailure()); - } - } -} - - TEST(TestThatAlwaysSucceeds) { } diff --git a/src/3rdparty/v8/test/cctest/test-sockets.cc b/src/3rdparty/v8/test/cctest/test-sockets.cc index ad73540..2f7941c 100644 --- a/src/3rdparty/v8/test/cctest/test-sockets.cc +++ b/src/3rdparty/v8/test/cctest/test-sockets.cc @@ -124,7 +124,7 @@ static void SendAndReceive(int port, char *data, int len) { TEST(Socket) { // Make sure this port is not used by other tests to allow tests to run in // parallel. - static const int kPort = 5859; + static const int kPort = 5859 + FlagDependentPortOffset(); bool ok; diff --git a/src/3rdparty/v8/test/cctest/test-strings.cc b/src/3rdparty/v8/test/cctest/test-strings.cc index d86886f..5a9ccbb 100644 --- a/src/3rdparty/v8/test/cctest/test-strings.cc +++ b/src/3rdparty/v8/test/cctest/test-strings.cc @@ -1,4 +1,4 @@ -// Copyright 2011 the V8 project authors. All rights reserved. +// Copyright 2012 the V8 project authors. All rights reserved. // Check that we can traverse very deep stacks of ConsStrings using // StringInputBuffer. Check that Get(int) works on very deep stacks @@ -11,6 +11,7 @@ #include "api.h" #include "factory.h" +#include "objects.h" #include "cctest.h" #include "zone-inl.h" @@ -82,6 +83,7 @@ static void InitializeBuildingBlocks( Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) { // A list of pointers that we don't have any interest in cleaning up. // If they are reachable from a root then leak detection won't complain. + Zone* zone = Isolate::Current()->runtime_zone(); for (int i = 0; i < NUMBER_OF_BUILDING_BLOCKS; i++) { int len = gen() % 16; if (len > 14) { @@ -113,11 +115,11 @@ static void InitializeBuildingBlocks( break; } case 2: { - uc16* buf = ZONE->NewArray<uc16>(len); + uc16* buf = zone->NewArray<uc16>(len); for (int j = 0; j < len; j++) { buf[j] = gen() % 65536; } - Resource* resource = new Resource(Vector<const uc16>(buf, len)); + Resource* resource = new(zone) Resource(Vector<const uc16>(buf, len)); building_blocks[i] = FACTORY->NewExternalStringFromTwoByte(resource); for (int j = 0; j < len; j++) { CHECK_EQ(buf[j], building_blocks[i]->Get(j)); @@ -233,7 +235,7 @@ TEST(Traverse) { InitializeVM(); v8::HandleScope scope; Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]; - ZoneScope zone(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); InitializeBuildingBlocks(building_blocks); Handle<String> flat = ConstructBalanced(building_blocks); FlattenString(flat); @@ -348,10 +350,11 @@ TEST(Utf8Conversion) { TEST(ExternalShortStringAdd) { - ZoneScope zone(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zonescope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); InitializeVM(); v8::HandleScope handle_scope; + Zone* zone = Isolate::Current()->runtime_zone(); // Make sure we cover all always-flat lengths and at least one above. static const int kMaxLength = 20; @@ -365,25 +368,25 @@ TEST(ExternalShortStringAdd) { // Generate short ascii and non-ascii external strings. for (int i = 0; i <= kMaxLength; i++) { - char* ascii = ZONE->NewArray<char>(i + 1); + char* ascii = zone->NewArray<char>(i + 1); for (int j = 0; j < i; j++) { ascii[j] = 'a'; } // Terminating '\0' is left out on purpose. It is not required for external // string data. AsciiResource* ascii_resource = - new AsciiResource(Vector<const char>(ascii, i)); + new(zone) AsciiResource(Vector<const char>(ascii, i)); v8::Local<v8::String> ascii_external_string = v8::String::NewExternal(ascii_resource); ascii_external_strings->Set(v8::Integer::New(i), ascii_external_string); - uc16* non_ascii = ZONE->NewArray<uc16>(i + 1); + uc16* non_ascii = zone->NewArray<uc16>(i + 1); for (int j = 0; j < i; j++) { non_ascii[j] = 0x1234; } // Terminating '\0' is left out on purpose. It is not required for external // string data. - Resource* resource = new Resource(Vector<const uc16>(non_ascii, i)); + Resource* resource = new(zone) Resource(Vector<const uc16>(non_ascii, i)); v8::Local<v8::String> non_ascii_external_string = v8::String::NewExternal(resource); non_ascii_external_strings->Set(v8::Integer::New(i), @@ -438,7 +441,7 @@ TEST(CachedHashOverflow) { // We incorrectly allowed strings to be tagged as array indices even if their // values didn't fit in the hash field. // See http://code.google.com/p/v8/issues/detail?id=728 - ZoneScope zone(Isolate::Current(), DELETE_ON_EXIT); + ZoneScope zone(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT); InitializeVM(); v8::HandleScope handle_scope; @@ -672,3 +675,43 @@ TEST(RobustSubStringStub) { CompileRun("var slice = long.slice(1, 15);"); CheckException("%_SubString(slice, 0, 17);"); } + + +TEST(RegExpOverflow) { + // Result string has the length 2^32, causing a 32-bit integer overflow. + InitializeVM(); + HandleScope scope; + LocalContext context; + v8::V8::IgnoreOutOfMemoryException(); + v8::Local<v8::Value> result = CompileRun( + "var a = 'a'; " + "for (var i = 0; i < 16; i++) { " + " a += a; " + "} " + "a.replace(/a/g, a); "); + CHECK(result.IsEmpty()); + CHECK(context->HasOutOfMemoryException()); +} + + +TEST(StringReplaceAtomTwoByteResult) { + InitializeVM(); + HandleScope scope; + LocalContext context; + v8::Local<v8::Value> result = CompileRun( + "var subject = 'ascii~only~string~'; " + "var replace = '\x80'; " + "subject.replace(/~/g, replace); "); + CHECK(result->IsString()); + Handle<String> string = v8::Utils::OpenHandle(v8::String::Cast(*result)); + CHECK(string->IsSeqTwoByteString()); + + v8::Local<v8::String> expected = v8_str("ascii\x80only\x80string\x80"); + CHECK(expected->Equals(result)); +} + + +TEST(IsAscii) { + CHECK(String::IsAscii(static_cast<char*>(NULL), 0)); + CHECK(String::IsAscii(static_cast<uc16*>(NULL), 0)); +} diff --git a/src/3rdparty/v8/test/cctest/test-utils.cc b/src/3rdparty/v8/test/cctest/test-utils.cc index df8ff72..c83acb9 100644 --- a/src/3rdparty/v8/test/cctest/test-utils.cc +++ b/src/3rdparty/v8/test/cctest/test-utils.cc @@ -55,6 +55,22 @@ TEST(Utils1) { CHECK_EQ(-2, -8 >> 2); CHECK_EQ(-2, static_cast<int8_t>(-8) >> 2); CHECK_EQ(-2, static_cast<int>(static_cast<intptr_t>(-8) >> 2)); + + CHECK_EQ(-1000000, FastD2IChecked(-1000000.0)); + CHECK_EQ(-1, FastD2IChecked(-1.0)); + CHECK_EQ(0, FastD2IChecked(0.0)); + CHECK_EQ(1, FastD2IChecked(1.0)); + CHECK_EQ(1000000, FastD2IChecked(1000000.0)); + + CHECK_EQ(-1000000, FastD2IChecked(-1000000.123)); + CHECK_EQ(-1, FastD2IChecked(-1.234)); + CHECK_EQ(0, FastD2IChecked(0.345)); + CHECK_EQ(1, FastD2IChecked(1.234)); + CHECK_EQ(1000000, FastD2IChecked(1000000.123)); + + CHECK_EQ(INT_MAX, FastD2IChecked(1.0e100)); + CHECK_EQ(INT_MIN, FastD2IChecked(-1.0e100)); + CHECK_EQ(INT_MIN, FastD2IChecked(OS::nan_value())); } diff --git a/src/3rdparty/v8/test/cctest/test-weakmaps.cc b/src/3rdparty/v8/test/cctest/test-weakmaps.cc index 7bba7b6..7c98c57 100644 --- a/src/3rdparty/v8/test/cctest/test-weakmaps.cc +++ b/src/3rdparty/v8/test/cctest/test-weakmaps.cc @@ -193,9 +193,10 @@ TEST(Regress2060a) { // other strong paths are correctly recorded in the slots buffer. TEST(Regress2060b) { FLAG_always_compact = true; -#ifdef DEBUG +#ifdef VERIFY_HEAP FLAG_verify_heap = true; #endif + LocalContext context; v8::HandleScope scope; Handle<JSFunction> function = diff --git a/src/3rdparty/v8/test/cctest/testcfg.py b/src/3rdparty/v8/test/cctest/testcfg.py index f1387e8..69a5db2 100644 --- a/src/3rdparty/v8/test/cctest/testcfg.py +++ b/src/3rdparty/v8/test/cctest/testcfg.py @@ -25,11 +25,70 @@ # (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 platform -import utils +import shutil + +from testrunner.local import commands +from testrunner.local import testsuite +from testrunner.local import utils +from testrunner.objects import testcase + + +class CcTestSuite(testsuite.TestSuite): + + def __init__(self, name, root): + super(CcTestSuite, self).__init__(name, root) + self.serdes_dir = os.path.normpath( + os.path.join(root, "..", "..", "out", ".serdes")) + if os.path.exists(self.serdes_dir): + shutil.rmtree(self.serdes_dir, True) + os.makedirs(self.serdes_dir) + + def ListTests(self, context): + if utils.IsWindows(): + shell += '.exe' + shell = os.path.abspath(os.path.join(context.shell_dir, self.shell())) + output = commands.Execute([context.command_prefix, + shell, + '--list', + context.extra_flags]) + if output.exit_code != 0: + print output.stdout + print output.stderr + return [] + tests = [] + for test_desc in output.stdout.strip().split(): + raw_test, dependency = test_desc.split('<') + if dependency != '': + dependency = raw_test.split('/')[0] + '/' + dependency + else: + dependency = None + test = testcase.TestCase(self, raw_test, dependency=dependency) + tests.append(test) + tests.sort() + return tests + + def GetFlagsForTestCase(self, testcase, context): + testname = testcase.path.split(os.path.sep)[-1] + serialization_file = os.path.join(self.serdes_dir, "serdes_" + testname) + serialization_file += ''.join(testcase.flags).replace('-', '_') + return (testcase.flags + [testcase.path] + context.mode_flags + + ["--testing_serialization_file=" + serialization_file]) + + def shell(self): + return "cctest" + + +def GetSuite(name, root): + return CcTestSuite(name, root) + + +# Deprecated definitions below. +# TODO(jkummerow): Remove when SCons is no longer supported. + + +from os.path import exists, join, normpath +import test class CcTestCase(test.TestCase): @@ -93,7 +152,8 @@ class CcTestConfiguration(test.TestConfiguration): if utils.IsWindows(): executable += '.exe' executable = join(self.context.buildspace, executable) - output = test.Execute([executable, '--list'], self.context) + full_command = self.context.processor([executable, '--list']) + output = test.Execute(full_command, self.context) if output.exit_code != 0: print output.stdout print output.stderr diff --git a/src/3rdparty/v8/test/es5conform/testcfg.py b/src/3rdparty/v8/test/es5conform/testcfg.py index b6a17d9..7de990d 100644 --- a/src/3rdparty/v8/test/es5conform/testcfg.py +++ b/src/3rdparty/v8/test/es5conform/testcfg.py @@ -31,6 +31,11 @@ import os from os.path import join, exists +def GetSuite(name, root): + # Not implemented. + return None + + HARNESS_FILES = ['sth.js'] diff --git a/src/3rdparty/v8/test/message/message.status b/src/3rdparty/v8/test/message/message.status index fc2896b..441f8ed 100644 --- a/src/3rdparty/v8/test/message/message.status +++ b/src/3rdparty/v8/test/message/message.status @@ -28,4 +28,4 @@ prefix message # All tests in the bug directory are expected to fail. -bugs: FAIL +bugs/*: FAIL diff --git a/src/3rdparty/v8/test/message/testcfg.py b/src/3rdparty/v8/test/message/testcfg.py index af467e6..1b788d5 100644 --- a/src/3rdparty/v8/test/message/testcfg.py +++ b/src/3rdparty/v8/test/message/testcfg.py @@ -25,13 +25,93 @@ # (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 itertools import os -from os.path import join, dirname, exists, basename, isdir import re +from testrunner.local import testsuite +from testrunner.local import utils +from testrunner.objects import testcase + + FLAGS_PATTERN = re.compile(r"//\s+Flags:(.*)") + +class MessageTestSuite(testsuite.TestSuite): + def __init__(self, name, root): + super(MessageTestSuite, 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"): + 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) + result = [] + flags_match = re.findall(FLAGS_PATTERN, source) + for match in flags_match: + result += match.strip().split() + result += context.mode_flags + result.append(os.path.join(self.root, testcase.path + ".js")) + return testcase.flags + result + + def GetSourceForTest(self, testcase): + filename = os.path.join(self.root, testcase.path + self.suffix()) + with open(filename) as f: + return f.read() + + def _IgnoreLine(self, string): + """Ignore empty lines, valgrind output and Android output.""" + if not string: return True + return (string.startswith("==") or string.startswith("**") or + string.startswith("ANDROID")) + + def IsFailureOutput(self, output, testpath): + expected_path = os.path.join(self.root, testpath + ".out") + expected_lines = [] + # Can't use utils.ReadLinesFrom() here because it strips whitespace. + with open(expected_path) as f: + for line in f: + if line.startswith("#") or not line.strip(): continue + expected_lines.append(line) + raw_lines = output.stdout.splitlines() + actual_lines = [ s for s in raw_lines if not self._IgnoreLine(s) ] + env = { "basename": os.path.basename(testpath + ".js") } + if len(expected_lines) != len(actual_lines): + return True + for (expected, actual) in itertools.izip(expected_lines, actual_lines): + pattern = re.escape(expected.rstrip() % env) + pattern = pattern.replace("\\*", ".*") + pattern = "^%s$" % pattern + if not re.match(pattern, actual): + return True + return False + + def StripOutputForTransmit(self, testcase): + pass + + +def GetSuite(name, root): + return MessageTestSuite(name, root) + + +# Deprecated definitions below. +# TODO(jkummerow): Remove when SCons is no longer supported. + + +import test +from os.path import join, exists, basename, isdir + class MessageTestCase(test.TestCase): def __init__(self, path, file, expected, mode, context, config): @@ -41,9 +121,10 @@ class MessageTestCase(test.TestCase): self.config = config def IgnoreLine(self, str): - """Ignore empty lines and valgrind output.""" + """Ignore empty lines, valgrind output and Android output.""" if not str: return True - else: return str.startswith('==') or str.startswith('**') + return (str.startswith('==') or str.startswith('**') or + str.startswith('ANDROID')) def IsFailureOutput(self, output): f = file(self.expected) @@ -62,7 +143,7 @@ class MessageTestCase(test.TestCase): pattern = '^%s$' % pattern patterns.append(pattern) # Compare actual output with the expected - raw_lines = output.stdout.split('\n') + raw_lines = output.stdout.splitlines() outlines = [ s for s in raw_lines if not self.IgnoreLine(s) ] if len(outlines) != len(patterns): return True @@ -80,9 +161,9 @@ class MessageTestCase(test.TestCase): def GetCommand(self): result = self.config.context.GetVmCommand(self, self.mode) source = open(self.file).read() - 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() result.append(self.file) return result diff --git a/src/3rdparty/v8/test/message/try-catch-finally-no-message.out b/src/3rdparty/v8/test/message/try-catch-finally-no-message.out index d85fc7d..f59f5c6 100644 --- a/src/3rdparty/v8/test/message/try-catch-finally-no-message.out +++ b/src/3rdparty/v8/test/message/try-catch-finally-no-message.out @@ -1,26 +1,26 @@ -// 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. +# 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. 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(); - diff --git a/src/3rdparty/v8/test/mozilla/mozilla.status b/src/3rdparty/v8/test/mozilla/mozilla.status index c30be5e..4f2fbde 100644 --- a/src/3rdparty/v8/test/mozilla/mozilla.status +++ b/src/3rdparty/v8/test/mozilla/mozilla.status @@ -126,13 +126,13 @@ ecma/Date/15.9.2.2-5: PASS || FAIL ecma/Date/15.9.2.2-6: PASS || FAIL # 1026139: These date tests fail on arm and mips -ecma/Date/15.9.5.29-1: PASS || (($ARM || $MIPS) && FAIL) -ecma/Date/15.9.5.34-1: PASS || (($ARM || $MIPS) && FAIL) -ecma/Date/15.9.5.28-1: PASS || (($ARM || $MIPS) && FAIL) +ecma/Date/15.9.5.29-1: PASS || FAIL if ($arch == arm || $arch == mipsel) +ecma/Date/15.9.5.34-1: PASS || FAIL if ($arch == arm || $arch == mipsel) +ecma/Date/15.9.5.28-1: PASS || FAIL if ($arch == arm || $arch == mipsel) # 1050186: Arm/MIPS vm is broken; probably unrelated to dates -ecma/Array/15.4.4.5-3: PASS || (($ARM || $MIPS) && FAIL) -ecma/Date/15.9.5.22-2: PASS || (($ARM || $MIPS) && FAIL) +ecma/Array/15.4.4.5-3: PASS || FAIL if ($arch == arm || $arch == mipsel) +ecma/Date/15.9.5.22-2: PASS || FAIL if ($arch == arm || $arch == mipsel) # Flaky test that fails due to what appears to be a bug in the test. # Occurs depending on current time @@ -245,9 +245,6 @@ js1_5/Function/regress-338121-03: FAIL_OK # Expectes 'prototype' property of functions to be enumerable. js1_5/Function/10.1.6-01: FAIL_OK -# Length of objects whose prototype chain includes a function -ecma_3/Function/regress-313570: FAIL_OK - # toPrecision argument restricted to range 1..21 in JSC/V8 js1_5/Regress/regress-452346: FAIL_OK ecma_3/Number/15.7.4.7-1: FAIL_OK @@ -371,6 +368,10 @@ ecma/GlobalObject/15.1.2.6: FAIL_OK ecma/GlobalObject/15.1.2.7: FAIL_OK +# Leading zero no longer signal octal numbers (ECMA-262 Annex E 15.1.2.2). +ecma/GlobalObject/15.1.2.2-2: FAIL_OK + + # Tests that rely on specific details of function decompilation or # print strings for errors. Non-ECMA behavior. js1_2/function/tostring-2: FAIL_OK @@ -606,6 +607,10 @@ ecma_2/RegExp/function-001: FAIL_OK ecma_2/RegExp/properties-001: FAIL_OK +# Negative hexadecimal literals are parsed as NaN. This test is outdated. +ecma/TypeConversion/9.3.1-3: FAIL_OK + + ##################### FAILING TESTS ##################### # This section is for tests that fail in V8 and pass in JSC. @@ -636,7 +641,7 @@ js1_5/Expressions/regress-394673: FAIL # Bug 762: http://code.google.com/p/v8/issues/detail?id=762 # We do not correctly handle assignments within "with" -/ecma_3/Statements/12.10-01: FAIL +ecma_3/Statements/12.10-01: FAIL # We do not throw an exception when a const is redeclared. # (We only fail section 1 of the test.) @@ -751,7 +756,6 @@ js1_5/extensions/regress-90596-001: FAIL_OK js1_5/extensions/regress-90596-002: FAIL_OK js1_5/extensions/regress-96284-001: FAIL_OK js1_5/extensions/regress-96284-002: FAIL_OK -js1_5/extensions/scope-001: FAIL_OK js1_5/extensions/toLocaleFormat-01: FAIL_OK js1_5/extensions/toLocaleFormat-02: FAIL_OK @@ -822,12 +826,6 @@ js1_5/decompilation/regress-383721: PASS || FAIL js1_5/decompilation/regress-406555: PASS || FAIL js1_5/decompilation/regress-460870: PASS || FAIL -# These tests take an unreasonable amount of time so we skip them -# in fast mode. - -js1_5/Regress/regress-312588: TIMEOUT || SKIP if $FAST == yes -js1_5/Regress/regress-271716-n: PASS || SKIP if $FAST == yes - [ $arch == arm ] @@ -852,40 +850,7 @@ js1_5/Regress/regress-451322: SKIP js1_5/GC/regress-203278-2: PASS || TIMEOUT -[ $fast == yes && $arch == arm ] - -# In fast mode on arm we try to skip all tests that would time out, -# since running the tests takes so long in the first place. - -js1_5/Regress/regress-280769-2: SKIP -js1_5/Regress/regress-280769-3: SKIP -js1_5/Regress/regress-244470: SKIP -js1_5/Regress/regress-203278-1: SKIP -js1_5/Regress/regress-290575: SKIP -js1_5/Regress/regress-159334: SKIP -js1_5/Regress/regress-321971: SKIP -js1_5/Regress/regress-347306-01: SKIP -js1_5/Regress/regress-280769-1: SKIP -js1_5/Regress/regress-280769-5: SKIP -js1_5/GC/regress-306788: SKIP -js1_5/GC/regress-278725: SKIP -js1_5/GC/regress-203278-3: SKIP -js1_5/GC/regress-311497: SKIP -js1_5/Array/regress-99120-02: SKIP -ecma/Date/15.9.5.22-1: SKIP -ecma/Date/15.9.5.20: SKIP -ecma/Date/15.9.5.12-2: SKIP -ecma/Date/15.9.5.8: SKIP -ecma/Date/15.9.5.9: SKIP -ecma/Date/15.9.5.11-2: SKIP -ecma/Expressions/11.7.2: SKIP -ecma/Expressions/11.10-2: SKIP -ecma/Expressions/11.7.3: SKIP -ecma/Expressions/11.10-3: SKIP -ecma/Expressions/11.7.1: SKIP -ecma_3/RegExp/regress-209067: SKIP - -[ $arch == mips ] +[ $arch == mipsel ] # Times out and print so much output that we need to skip it to not # hang the builder. @@ -906,37 +871,3 @@ js1_5/Regress/regress-451322: SKIP # BUG(1040): Allow this test to timeout. js1_5/GC/regress-203278-2: PASS || TIMEOUT - - -[ $fast == yes && $arch == mips ] - -# In fast mode on mips we try to skip all tests that would time out, -# since running the tests takes so long in the first place. - -js1_5/Regress/regress-280769-2: SKIP -js1_5/Regress/regress-280769-3: SKIP -js1_5/Regress/regress-244470: SKIP -js1_5/Regress/regress-203278-1: SKIP -js1_5/Regress/regress-290575: SKIP -js1_5/Regress/regress-159334: SKIP -js1_5/Regress/regress-321971: SKIP -js1_5/Regress/regress-347306-01: SKIP -js1_5/Regress/regress-280769-1: SKIP -js1_5/Regress/regress-280769-5: SKIP -js1_5/GC/regress-306788: SKIP -js1_5/GC/regress-278725: SKIP -js1_5/GC/regress-203278-3: SKIP -js1_5/GC/regress-311497: SKIP -js1_5/Array/regress-99120-02: SKIP -ecma/Date/15.9.5.22-1: SKIP -ecma/Date/15.9.5.20: SKIP -ecma/Date/15.9.5.12-2: SKIP -ecma/Date/15.9.5.8: SKIP -ecma/Date/15.9.5.9: SKIP -ecma/Date/15.9.5.11-2: SKIP -ecma/Expressions/11.7.2: SKIP -ecma/Expressions/11.10-2: SKIP -ecma/Expressions/11.7.3: SKIP -ecma/Expressions/11.10-3: SKIP -ecma/Expressions/11.7.1: SKIP -ecma_3/RegExp/regress-209067: SKIP diff --git a/src/3rdparty/v8/test/mozilla/testcfg.py b/src/3rdparty/v8/test/mozilla/testcfg.py index 587781d..5aeac4c 100644 --- a/src/3rdparty/v8/test/mozilla/testcfg.py +++ b/src/3rdparty/v8/test/mozilla/testcfg.py @@ -26,12 +26,19 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import test import os -from os.path import join, exists +import shutil +import subprocess +import tarfile + +from testrunner.local import testsuite +from testrunner.objects import testcase + +MOZILLA_VERSION = "2010-06-29" -EXCLUDED = ['CVS'] + +EXCLUDED = ["CVS"] FRAMEWORK = """ @@ -54,6 +61,117 @@ TEST_DIRS = """ """.split() +class MozillaTestSuite(testsuite.TestSuite): + + def __init__(self, name, root): + super(MozillaTestSuite, self).__init__(name, root) + self.testroot = os.path.join(root, "data") + + def ListTests(self, context): + tests = [] + for testdir in TEST_DIRS: + current_root = os.path.join(self.testroot, testdir) + for dirname, dirs, files in os.walk(current_root): + for dotted in [x for x in dirs if x.startswith(".")]: + dirs.remove(dotted) + for excluded in EXCLUDED: + if excluded in dirs: + dirs.remove(excluded) + dirs.sort() + files.sort() + for filename in files: + if filename.endswith(".js") and not filename in FRAMEWORK: + testname = os.path.join(dirname[len(self.testroot) + 1:], + filename[:-3]) + case = testcase.TestCase(self, testname) + tests.append(case) + return tests + + def GetFlagsForTestCase(self, testcase, context): + result = [] + result += context.mode_flags + result += ["--expose-gc"] + result += [os.path.join(self.root, "mozilla-shell-emulation.js")] + testfilename = testcase.path + ".js" + testfilepath = testfilename.split(os.path.sep) + for i in xrange(len(testfilepath)): + script = os.path.join(self.testroot, + reduce(os.path.join, testfilepath[:i], ""), + "shell.js") + if os.path.exists(script): + result.append(script) + result.append(os.path.join(self.testroot, testfilename)) + return testcase.flags + result + + def GetSourceForTest(self, testcase): + filename = join(self.testroot, testcase.path + ".js") + with open(filename) as f: + return f.read() + + def IsNegativeTest(self, testcase): + return testcase.path.endswith("-n") + + def IsFailureOutput(self, output, testpath): + if output.exit_code != 0: + return True + return "FAILED!" in output.stdout + + def DownloadData(self): + old_cwd = os.getcwd() + os.chdir(os.path.abspath(self.root)) + + # Maybe we're still up to date? + versionfile = "CHECKED_OUT_VERSION" + checked_out_version = None + if os.path.exists(versionfile): + with open(versionfile) as f: + checked_out_version = f.read() + if checked_out_version == MOZILLA_VERSION: + os.chdir(old_cwd) + return + + # If we have a local archive file with the test data, extract it. + directory_name = "data" + if os.path.exists(directory_name): + os.rename(directory_name, "data.old") + archive_file = "downloaded_%s.tar.gz" % MOZILLA_VERSION + if os.path.exists(archive_file): + with tarfile.open(archive_file, "r:gz") as tar: + tar.extractall() + with open(versionfile, "w") as f: + f.write(MOZILLA_VERSION) + os.chdir(old_cwd) + return + + # No cached copy. Check out via CVS, and pack as .tar.gz for later use. + command = ("cvs -d :pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot" + " co -D %s mozilla/js/tests" % MOZILLA_VERSION) + code = subprocess.call(command, shell=True) + if code != 0: + os.chdir(old_cwd) + raise Exception("Error checking out Mozilla test suite!") + os.rename(join("mozilla", "js", "tests"), directory_name) + shutil.rmtree("mozilla") + with tarfile.open(archive_file, "w:gz") as tar: + tar.add("data") + with open(versionfile, "w") as f: + f.write(MOZILLA_VERSION) + os.chdir(old_cwd) + + +def GetSuite(name, root): + return MozillaTestSuite(name, root) + + +# Deprecated definitions below. +# TODO(jkummerow): Remove when SCons is no longer supported. + + +from os.path import exists +from os.path import join +import test + + class MozillaTestCase(test.TestCase): def __init__(self, filename, path, context, root, mode, framework): @@ -76,6 +194,7 @@ class MozillaTestCase(test.TestCase): def GetCommand(self): result = self.context.GetVmCommand(self, self.mode) + \ [ '--expose-gc', join(self.root, 'mozilla-shell-emulation.js') ] + result += [ '--es5_readonly' ] # Temporary hack until we can remove flag result += self.framework result.append(self.filename) return result diff --git a/src/3rdparty/v8/test/preparser/preparser.status b/src/3rdparty/v8/test/preparser/preparser.status index 6f15fed..40c5caf 100644 --- a/src/3rdparty/v8/test/preparser/preparser.status +++ b/src/3rdparty/v8/test/preparser/preparser.status @@ -31,3 +31,8 @@ prefix preparser # escapes (we need to parse to distinguish octal escapes from valid # back-references). strict-octal-regexp: FAIL + +[ $arch == android_arm || $arch == android_ia32 ] +# Remove this once the issue above is fixed. Android test runner does not +# handle "FAIL" test expectation correctly. +strict-octal-regexp: SKIP diff --git a/src/3rdparty/v8/test/preparser/strict-identifiers.pyt b/src/3rdparty/v8/test/preparser/strict-identifiers.pyt index aa3d521..f979088 100644 --- a/src/3rdparty/v8/test/preparser/strict-identifiers.pyt +++ b/src/3rdparty/v8/test/preparser/strict-identifiers.pyt @@ -285,4 +285,4 @@ for reserved_word in reserved_words + strict_reserved_words: # Future reserved words in strict mode behave like normal identifiers # in a non strict context. for reserved_word in strict_reserved_words: - non_strict_use({"id": id}, None) + non_strict_use({"id": reserved_word}, None) diff --git a/src/3rdparty/v8/test/preparser/testcfg.py b/src/3rdparty/v8/test/preparser/testcfg.py index 88c06a3..61c14c9 100644 --- a/src/3rdparty/v8/test/preparser/testcfg.py +++ b/src/3rdparty/v8/test/preparser/testcfg.py @@ -25,13 +25,109 @@ # (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, isfile -import platform -import utils import re +from testrunner.local import testsuite +from testrunner.local import utils +from testrunner.objects import testcase + + +class PreparserTestSuite(testsuite.TestSuite): + def __init__(self, name, root): + super(PreparserTestSuite, self).__init__(name, root) + + def shell(self): + return "preparser" + + def _GetExpectations(self): + expects_file = join(self.root, "preparser.expectation") + expectations_map = {} + if not os.path.exists(expects_file): return expectations_map + rule_regex = re.compile("^([\w\-]+)(?::([\w\-]+))?(?::(\d+),(\d+))?$") + for line in utils.ReadLinesFrom(expects_file): + rule_match = rule_regex.match(line) + if not rule_match: continue + expects = [] + if (rule_match.group(2)): + expects += [rule_match.group(2)] + if (rule_match.group(3)): + expects += [rule_match.group(3), rule_match.group(4)] + expectations_map[rule_match.group(1)] = " ".join(expects) + return expectations_map + + def _ParsePythonTestTemplates(self, result, filename): + pathname = join(self.root, filename + ".pyt") + def Test(name, source, expectation): + source = source.replace("\n", " ") + testname = os.path.join(filename, name) + flags = ["-e", source] + if expectation: + flags += ["throws", expectation] + test = testcase.TestCase(self, testname, flags=flags) + result.append(test) + def Template(name, source): + def MkTest(replacement, expectation): + testname = name + testsource = source + for key in replacement.keys(): + testname = testname.replace("$" + key, replacement[key]); + testsource = testsource.replace("$" + key, replacement[key]); + Test(testname, testsource, expectation) + return MkTest + execfile(pathname, {"Test": Test, "Template": Template}) + + def ListTests(self, context): + expectations = self._GetExpectations() + result = [] + + # Find all .js files in this directory. + filenames = [f[:-3] for f in os.listdir(self.root) if f.endswith(".js")] + filenames.sort() + for f in filenames: + throws = expectations.get(f, None) + flags = [f + ".js"] + if throws: + flags += ["throws", throws] + test = testcase.TestCase(self, f, flags=flags) + result.append(test) + + # Find all .pyt files in this directory. + filenames = [f[:-4] for f in os.listdir(self.root) if f.endswith(".pyt")] + filenames.sort() + for f in filenames: + self._ParsePythonTestTemplates(result, f) + return result + + def GetFlagsForTestCase(self, testcase, context): + first = testcase.flags[0] + if first != "-e": + testcase.flags[0] = os.path.join(self.root, first) + return testcase.flags + + def GetSourceForTest(self, testcase): + if testcase.flags[0] == "-e": + return testcase.flags[1] + with open(testcase.flags[0]) as f: + return f.read() + + def VariantFlags(self): + return [[]]; + + +def GetSuite(name, root): + return PreparserTestSuite(name, root) + + +# Deprecated definitions below. +# TODO(jkummerow): Remove when SCons is no longer supported. + + +from os.path import join, exists, isfile +import test + + class PreparserTestCase(test.TestCase): def __init__(self, root, path, executable, mode, throws, context, source): @@ -50,7 +146,7 @@ class PreparserTestCase(test.TestCase): def HasSource(self): return self.source is not None - def GetSource(): + def GetSource(self): return self.source def BuildCommand(self, path): diff --git a/src/3rdparty/v8/test/sputnik/sputnik.status b/src/3rdparty/v8/test/sputnik/sputnik.status index 52d126e..67d1c75 100644 --- a/src/3rdparty/v8/test/sputnik/sputnik.status +++ b/src/3rdparty/v8/test/sputnik/sputnik.status @@ -216,7 +216,7 @@ S15.1.3.4_A2.3_T1: SKIP S15.1.3.1_A2.5_T1: SKIP S15.1.3.2_A2.5_T1: SKIP -[ $arch == mips ] +[ $arch == mipsel ] # BUG(3251225): Tests that timeout with --nocrankshaft. S15.1.3.1_A2.5_T1: SKIP diff --git a/src/3rdparty/v8/test/sputnik/testcfg.py b/src/3rdparty/v8/test/sputnik/testcfg.py index 1032c13..b6f3746 100644 --- a/src/3rdparty/v8/test/sputnik/testcfg.py +++ b/src/3rdparty/v8/test/sputnik/testcfg.py @@ -33,6 +33,11 @@ import test import time +def GetSuite(name, root): + # Not implemented. + return None + + class SputnikTestCase(test.TestCase): def __init__(self, case, path, context, mode): diff --git a/src/3rdparty/v8/test/test262/test262.status b/src/3rdparty/v8/test/test262/test262.status index c755289..06b43c7 100644 --- a/src/3rdparty/v8/test/test262/test262.status +++ b/src/3rdparty/v8/test/test262/test262.status @@ -39,23 +39,8 @@ S15.12.2_A1: FAIL # V8 Bug: http://code.google.com/p/v8/issues/detail?id=691 11.2.3-3_3: FAIL -# Prototypal inheritance of properties does not maintain accessibility. -# The [[CanPut]] operation should traverse the prototype chain to -# determine whether given property is writable or not. -# V8 Bug: http://code.google.com/p/v8/issues/detail?id=1475 -8.14.4-8-b_1: FAIL -8.14.4-8-b_2: FAIL -15.2.3.6-4-405: FAIL -15.2.3.6-4-410: FAIL -15.2.3.6-4-415: FAIL -15.2.3.6-4-420: FAIL - ##################### DELIBERATE INCOMPATIBILITIES ##################### -# We deliberately treat arguments to parseInt() with a leading zero as -# octal numbers in order to not break the web. -S15.1.2.2_A5.1_T1: FAIL_OK - # This tests precision of Math.tan and Math.sin. The implementation for those # trigonometric functions are platform/compiler dependent. Furthermore, the # expectation values by far deviates from the actual result given by an @@ -86,33 +71,19 @@ S15.9.3.1_A5_T6: PASS || FAIL_OK ############################ SKIPPED TESTS ############################# # These tests take a looong time to run in debug mode. -S15.1.3.2_A2.5_T1: PASS, SKIP if $mode == debug S15.1.3.1_A2.5_T1: PASS, SKIP if $mode == debug +S15.1.3.2_A2.5_T1: PASS, SKIP if $mode == debug -[ $arch == arm ] - -# BUG(3251225): Tests that timeout with --nocrankshaft. -S15.1.3.1_A2.5_T1: SKIP -S15.1.3.2_A2.5_T1: SKIP -S15.1.3.1_A2.4_T1: SKIP -S15.1.3.1_A2.5_T1: SKIP -S15.1.3.2_A2.4_T1: SKIP -S15.1.3.2_A2.5_T1: SKIP -S15.1.3.3_A2.3_T1: SKIP -S15.1.3.4_A2.3_T1: SKIP -S15.1.3.1_A2.5_T1: SKIP -S15.1.3.2_A2.5_T1: SKIP +[ $arch == arm || $arch == mipsel ] -[ $arch == mips ] +# TODO(mstarzinger): Causes stack overflow on simulators due to eager +# compilation of parenthesized function literals. Needs investigation. +S13.2.1_A1_T1: SKIP # BUG(3251225): Tests that timeout with --nocrankshaft. -S15.1.3.1_A2.5_T1: SKIP -S15.1.3.2_A2.5_T1: SKIP S15.1.3.1_A2.4_T1: SKIP S15.1.3.1_A2.5_T1: SKIP S15.1.3.2_A2.4_T1: SKIP S15.1.3.2_A2.5_T1: SKIP S15.1.3.3_A2.3_T1: SKIP S15.1.3.4_A2.3_T1: SKIP -S15.1.3.1_A2.5_T1: SKIP -S15.1.3.2_A2.5_T1: SKIP diff --git a/src/3rdparty/v8/test/test262/testcfg.py b/src/3rdparty/v8/test/test262/testcfg.py index 07f760c..875a4e5 100644 --- a/src/3rdparty/v8/test/test262/testcfg.py +++ b/src/3rdparty/v8/test/test262/testcfg.py @@ -26,19 +26,107 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import test -import os -from os.path import join, exists -import urllib import hashlib +import os import sys import tarfile +import urllib + +from testrunner.local import testsuite +from testrunner.objects import testcase + + +TEST_262_ARCHIVE_REVISION = "fb327c439e20" # This is the r334 revision. +TEST_262_ARCHIVE_MD5 = "307acd166ec34629592f240dc12d57ed" +TEST_262_URL = "http://hg.ecmascript.org/tests/test262/archive/%s.tar.bz2" +TEST_262_HARNESS = ["sta.js"] + + +class Test262TestSuite(testsuite.TestSuite): + + def __init__(self, name, root): + super(Test262TestSuite, self).__init__(name, root) + self.testroot = os.path.join(root, "data", "test", "suite") + self.harness = [os.path.join(self.root, "data", "test", "harness", f) + for f in TEST_262_HARNESS] + self.harness += [os.path.join(self.root, "harness-adapt.js")] + + def CommonTestName(self, testcase): + return testcase.path.split(os.path.sep)[-1] + def ListTests(self, context): + tests = [] + for dirname, dirs, files in os.walk(self.testroot): + 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"): + testname = os.path.join(dirname[len(self.testroot) + 1:], + filename[:-3]) + case = testcase.TestCase(self, testname) + tests.append(case) + return tests + + def GetFlagsForTestCase(self, testcase, context): + return (testcase.flags + context.mode_flags + self.harness + + [os.path.join(self.testroot, testcase.path + ".js")]) + + def GetSourceForTest(self, testcase): + filename = os.path.join(self.testroot, testcase.path + ".js") + with open(filename) as f: + return f.read() + + def IsNegativeTest(self, testcase): + return "@negative" in self.GetSourceForTest(testcase) + + def IsFailureOutput(self, output, testpath): + if output.exit_code != 0: + return True + return "FAILED!" in output.stdout -TEST_262_ARCHIVE_REVISION = 'fb327c439e20' # This is the r334 revision. -TEST_262_ARCHIVE_MD5 = '307acd166ec34629592f240dc12d57ed' -TEST_262_URL = 'http://hg.ecmascript.org/tests/test262/archive/%s.tar.bz2' -TEST_262_HARNESS = ['sta.js'] + def DownloadData(self): + revision = TEST_262_ARCHIVE_REVISION + archive_url = TEST_262_URL % revision + archive_name = os.path.join(self.root, "test262-%s.tar.bz2" % revision) + directory_name = os.path.join(self.root, "data") + directory_old_name = os.path.join(self.root, "data.old") + if not os.path.exists(archive_name): + print "Downloading test data from %s ..." % archive_url + urllib.urlretrieve(archive_url, archive_name) + if os.path.exists(directory_name): + os.rename(directory_name, directory_old_name) + if not os.path.exists(directory_name): + print "Extracting test262-%s.tar.bz2 ..." % revision + md5 = hashlib.md5() + with open(archive_name, "rb") as f: + for chunk in iter(lambda: f.read(8192), ""): + md5.update(chunk) + if md5.hexdigest() != TEST_262_ARCHIVE_MD5: + os.remove(archive_name) + raise Exception("Hash mismatch of test data file") + archive = tarfile.open(archive_name, "r:bz2") + if sys.platform in ("win32", "cygwin"): + # Magic incantation to allow longer path names on Windows. + archive.extractall(u"\\\\?\\%s" % self.root) + else: + archive.extractall(self.root) + os.rename(os.path.join(self.root, "test262-%s" % revision), + directory_name) + + +def GetSuite(name, root): + return Test262TestSuite(name, root) + + +# Deprecated definitions below. +# TODO(jkummerow): Remove when SCons is no longer supported. + + +from os.path import exists +from os.path import join +import test class Test262TestCase(test.TestCase): @@ -62,6 +150,7 @@ class Test262TestCase(test.TestCase): def GetCommand(self): result = self.context.GetVmCommand(self, self.mode) + result += [ '--es5_readonly' ] # Temporary hack until we can remove flag result += self.framework result.append(self.filename) return result |