Merge V8 at branches/3.2 r8200: Initial merge by Git

Change-Id: I5c434306e98132997e9c5f6024b6ce200b255edf

145 files changed, 8391 insertions, 8028 deletions

diff --git a/ChangeLog b/ChangeLog
index cf9c96cf..781f0cae 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,17 +1,3 @@
-2011-04-18: Version 3.3.0
-
-        Fixed bug in floating point rounding in Crankshaft on ARM
-        (issue 958)
-
-        Fixed a number of issues with running without VFPv3 support on ARM
-        (issue 1315)
-
-        Introduced v8Locale.Collator, a partial implementation of Collator
-        per last ECMAScript meeting + mailing list.
-
-        Minor performance improvements and bug fixes.
-
-
 2011-04-13: Version 3.2.10
 
         Fixed bug in external float arrays on ARM (issue 1323).
diff --git a/src/SConscript b/src/SConscript
index 417e2838..a68ee3e3 100755
--- a/src/SConscript
+++ b/src/SConscript
@@ -297,11 +297,6 @@ debug-debugger.js
 '''.split()
 
 
-EXPERIMENTAL_LIBRARY_FILES = '''
-proxy.js
-'''.split()
-
-
 def Abort(message):
   print message
   sys.exit(1)
@@ -329,16 +324,9 @@ def ConfigureObjectFiles():
   # compile it.
   library_files = [s for s in LIBRARY_FILES]
   library_files.append('macros.py')
-  libraries_src = env.JS2C(['libraries.cc'], library_files, TYPE='CORE')
+  libraries_src, libraries_empty_src = env.JS2C(['libraries.cc', 'libraries-empty.cc'], library_files, TYPE='CORE')
   libraries_obj = context.ConfigureObject(env, libraries_src, CPPPATH=['.'])
 
-  # Combine the experimental JavaScript library files into a C++ file
-  # and compile it.
-  experimental_library_files = [ s for s in EXPERIMENTAL_LIBRARY_FILES ]
-  experimental_library_files.append('macros.py')
-  experimental_libraries_src = env.JS2C(['experimental-libraries.cc'], experimental_library_files, TYPE='EXPERIMENTAL')
-  experimental_libraries_obj = context.ConfigureObject(env, experimental_libraries_src, CPPPATH=['.'])
-
   source_objs = context.ConfigureObject(env, source_files)
   non_snapshot_files = [source_objs]
 
@@ -355,7 +343,7 @@ def ConfigureObjectFiles():
   mksnapshot_env = env.Copy()
   mksnapshot_env.Replace(**context.flags['mksnapshot'])
   mksnapshot_src = 'mksnapshot.cc'
-  mksnapshot = mksnapshot_env.Program('mksnapshot', [mksnapshot_src, libraries_obj, experimental_libraries_obj,  non_snapshot_files, empty_snapshot_obj], PDB='mksnapshot.exe.pdb')
+  mksnapshot = mksnapshot_env.Program('mksnapshot', [mksnapshot_src, libraries_obj, non_snapshot_files, empty_snapshot_obj], PDB='mksnapshot.exe.pdb')
   if context.use_snapshot:
     if context.build_snapshot:
       snapshot_cc = env.Snapshot('snapshot.cc', mksnapshot, LOGFILE=File('snapshot.log').abspath)
@@ -364,7 +352,7 @@ def ConfigureObjectFiles():
     snapshot_obj = context.ConfigureObject(env, snapshot_cc, CPPPATH=['.'])
   else:
     snapshot_obj = empty_snapshot_obj
-  library_objs = [non_snapshot_files, libraries_obj, experimental_libraries_obj, snapshot_obj]
+  library_objs = [non_snapshot_files, libraries_obj, snapshot_obj]
   return (library_objs, d8_objs, [mksnapshot], preparser_objs)
 
 
diff --git a/src/api.cc b/src/api.cc
index c3684f77..247507f6 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -3709,7 +3709,6 @@ Persistent<Context> v8::Context::New(
 
     // Create the environment.
     env = isolate->bootstrapper()->CreateEnvironment(
-        isolate,
         Utils::OpenHandle(*global_object),
         proxy_template,
         extensions);
diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc
index d66daea0..8c147f92 100644
--- a/src/arm/code-stubs-arm.cc
+++ b/src/arm/code-stubs-arm.cc
@@ -1817,9 +1817,6 @@ void TypeRecordingBinaryOpStub::Generate(MacroAssembler* masm) {
     case TRBinaryOpIC::ODDBALL:
       GenerateOddballStub(masm);
       break;
-    case TRBinaryOpIC::BOTH_STRING:
-      GenerateBothStringStub(masm);
-      break;
     case TRBinaryOpIC::STRING:
       GenerateStringStub(masm);
       break;
@@ -2260,36 +2257,6 @@ void TypeRecordingBinaryOpStub::GenerateStringStub(MacroAssembler* masm) {
 }
 
 
-void TypeRecordingBinaryOpStub::GenerateBothStringStub(MacroAssembler* masm) {
-  Label call_runtime;
-  ASSERT(operands_type_ == TRBinaryOpIC::BOTH_STRING);
-  ASSERT(op_ == Token::ADD);
-  // If both arguments are strings, call the string add stub.
-  // Otherwise, do a transition.
-
-  // Registers containing left and right operands respectively.
-  Register left = r1;
-  Register right = r0;
-
-  // Test if left operand is a string.
-  __ JumpIfSmi(left, &call_runtime);
-  __ CompareObjectType(left, r2, r2, FIRST_NONSTRING_TYPE);
-  __ b(ge, &call_runtime);
-
-  // Test if right operand is a string.
-  __ JumpIfSmi(right, &call_runtime);
-  __ CompareObjectType(right, r2, r2, FIRST_NONSTRING_TYPE);
-  __ b(ge, &call_runtime);
-
-  StringAddStub string_add_stub(NO_STRING_CHECK_IN_STUB);
-  GenerateRegisterArgsPush(masm);
-  __ TailCallStub(&string_add_stub);
-
-  __ bind(&call_runtime);
-  GenerateTypeTransition(masm);
-}
-
-
 void TypeRecordingBinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
   ASSERT(operands_type_ == TRBinaryOpIC::INT32);
 
@@ -2440,6 +2407,8 @@ void TypeRecordingBinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
         // Save the left value on the stack.
         __ Push(r5, r4);
 
+        Label pop_and_call_runtime;
+
         // Allocate a heap number to store the result.
         heap_number_result = r5;
         GenerateHeapResultAllocation(masm,
@@ -2447,7 +2416,7 @@ void TypeRecordingBinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
                                      heap_number_map,
                                      scratch1,
                                      scratch2,
-                                     &call_runtime);
+                                     &pop_and_call_runtime);
 
         // Load the left value from the value saved on the stack.
         __ Pop(r1, r0);
@@ -2458,6 +2427,10 @@ void TypeRecordingBinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
         if (FLAG_debug_code) {
           __ stop("Unreachable code.");
         }
+
+        __ bind(&pop_and_call_runtime);
+        __ Drop(2);
+        __ b(&call_runtime);
       }
 
       break;
@@ -3468,11 +3441,20 @@ void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // If this is the outermost JS call, set js_entry_sp value.
+  Label non_outermost_js;
   ExternalReference js_entry_sp(Isolate::k_js_entry_sp_address, isolate);
   __ mov(r5, Operand(ExternalReference(js_entry_sp)));
   __ ldr(r6, MemOperand(r5));
-  __ cmp(r6, Operand(0, RelocInfo::NONE));
-  __ str(fp, MemOperand(r5), eq);
+  __ cmp(r6, Operand(0));
+  __ b(ne, &non_outermost_js);
+  __ str(fp, MemOperand(r5));
+  __ mov(ip, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+  Label cont;
+  __ b(&cont);
+  __ bind(&non_outermost_js);
+  __ mov(ip, Operand(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME)));
+  __ bind(&cont);
+  __ push(ip);
 #endif
 
   // Call a faked try-block that does the invoke.
@@ -3530,27 +3512,22 @@ void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
   __ mov(lr, Operand(pc));
   masm->add(pc, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
 
-  // Unlink this frame from the handler chain. When reading the
-  // address of the next handler, there is no need to use the address
-  // displacement since the current stack pointer (sp) points directly
-  // to the stack handler.
-  __ ldr(r3, MemOperand(sp, StackHandlerConstants::kNextOffset));
-  __ mov(ip, Operand(ExternalReference(Isolate::k_handler_address, isolate)));
-  __ str(r3, MemOperand(ip));
-  // No need to restore registers
-  __ add(sp, sp, Operand(StackHandlerConstants::kSize));
+  // Unlink this frame from the handler chain.
+  __ PopTryHandler();
 
+  __ bind(&exit);  // r0 holds result
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  // If current FP value is the same as js_entry_sp value, it means that
-  // the current function is the outermost.
+  // Check if the current stack frame is marked as the outermost JS frame.
+  Label non_outermost_js_2;
+  __ pop(r5);
+  __ cmp(r5, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+  __ b(ne, &non_outermost_js_2);
+  __ mov(r6, Operand(0));
   __ mov(r5, Operand(ExternalReference(js_entry_sp)));
-  __ ldr(r6, MemOperand(r5));
-  __ cmp(fp, Operand(r6));
-  __ mov(r6, Operand(0, RelocInfo::NONE), LeaveCC, eq);
-  __ str(r6, MemOperand(r5), eq);
+  __ str(r6, MemOperand(r5));
+  __ bind(&non_outermost_js_2);
 #endif
 
-  __ bind(&exit);  // r0 holds result
   // Restore the top frame descriptors from the stack.
   __ pop(r3);
   __ mov(ip,
@@ -3711,7 +3688,7 @@ void InstanceofStub::Generate(MacroAssembler* masm) {
   __ b(ne, &slow);
 
   // Null is not instance of anything.
-  __ cmp(scratch, Operand(masm->isolate()->factory()->null_value()));
+  __ cmp(scratch, Operand(FACTORY->null_value()));
   __ b(ne, &object_not_null);
   __ mov(r0, Operand(Smi::FromInt(1)));
   __ Ret(HasArgsInRegisters() ? 0 : 2);
@@ -4209,7 +4186,7 @@ void RegExpExecStub::Generate(MacroAssembler* masm) {
 
   __ bind(&failure);
   // For failure and exception return null.
-  __ mov(r0, Operand(masm->isolate()->factory()->null_value()));
+  __ mov(r0, Operand(FACTORY->null_value()));
   __ add(sp, sp, Operand(4 * kPointerSize));
   __ Ret();
 
@@ -4280,8 +4257,6 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) {
   const int kMaxInlineLength = 100;
   Label slowcase;
   Label done;
-  Factory* factory = masm->isolate()->factory();
-
   __ ldr(r1, MemOperand(sp, kPointerSize * 2));
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
@@ -4316,7 +4291,7 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) {
   // Interleave operations for better latency.
   __ ldr(r2, ContextOperand(cp, Context::GLOBAL_INDEX));
   __ add(r3, r0, Operand(JSRegExpResult::kSize));
-  __ mov(r4, Operand(factory->empty_fixed_array()));
+  __ mov(r4, Operand(FACTORY->empty_fixed_array()));
   __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalContextOffset));
   __ str(r3, FieldMemOperand(r0, JSObject::kElementsOffset));
   __ ldr(r2, ContextOperand(r2, Context::REGEXP_RESULT_MAP_INDEX));
@@ -4337,13 +4312,13 @@ void RegExpConstructResultStub::Generate(MacroAssembler* masm) {
   // r5: Number of elements in array, untagged.
 
   // Set map.
-  __ mov(r2, Operand(factory->fixed_array_map()));
+  __ mov(r2, Operand(FACTORY->fixed_array_map()));
   __ str(r2, FieldMemOperand(r3, HeapObject::kMapOffset));
   // Set FixedArray length.
   __ mov(r6, Operand(r5, LSL, kSmiTagSize));
   __ str(r6, FieldMemOperand(r3, FixedArray::kLengthOffset));
   // Fill contents of fixed-array with the-hole.
-  __ mov(r2, Operand(factory->the_hole_value()));
+  __ mov(r2, Operand(FACTORY->the_hole_value()));
   __ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
   // Fill fixed array elements with hole.
   // r0: JSArray, tagged.
diff --git a/src/arm/code-stubs-arm.h b/src/arm/code-stubs-arm.h
index 0bb0025f..d82afc74 100644
--- a/src/arm/code-stubs-arm.h
+++ b/src/arm/code-stubs-arm.h
@@ -158,7 +158,6 @@ class TypeRecordingBinaryOpStub: public CodeStub {
   void GenerateHeapNumberStub(MacroAssembler* masm);
   void GenerateOddballStub(MacroAssembler* masm);
   void GenerateStringStub(MacroAssembler* masm);
-  void GenerateBothStringStub(MacroAssembler* masm);
   void GenerateGenericStub(MacroAssembler* masm);
   void GenerateAddStrings(MacroAssembler* masm);
   void GenerateCallRuntime(MacroAssembler* masm);
diff --git a/src/arm/full-codegen-arm.cc b/src/arm/full-codegen-arm.cc
index 85e42627..871b4539 100644
--- a/src/arm/full-codegen-arm.cc
+++ b/src/arm/full-codegen-arm.cc
@@ -3161,14 +3161,15 @@ void FullCodeGenerator::EmitMathSqrt(ZoneList<Expression*>* args) {
 void FullCodeGenerator::EmitCallFunction(ZoneList<Expression*>* args) {
   ASSERT(args->length() >= 2);
 
-  int arg_count = args->length() - 2;  // 2 ~ receiver and function.
-  for (int i = 0; i < arg_count + 1; i++) {
-    VisitForStackValue(args->at(i));
+  int arg_count = args->length() - 2;  // For receiver and function.
+  VisitForStackValue(args->at(0));  // Receiver.
+  for (int i = 0; i < arg_count; i++) {
+    VisitForStackValue(args->at(i + 1));
   }
-  VisitForAccumulatorValue(args->last());  // Function.
+  VisitForAccumulatorValue(args->at(arg_count + 1));  // Function.
 
-  // InvokeFunction requires the function in r1. Move it in there.
-  __ mov(r1, result_register());
+  // InvokeFunction requires function in r1. Move it in there.
+  if (!result_register().is(r1)) __ mov(r1, result_register());
   ParameterCount count(arg_count);
   __ InvokeFunction(r1, count, CALL_FUNCTION);
   __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
@@ -4294,6 +4295,7 @@ void FullCodeGenerator::EmitCallIC(Handle<Code> ic, RelocInfo::Mode mode) {
     default:
       break;
   }
+
   __ Call(ic, mode);
 }
 
@@ -4315,6 +4317,7 @@ void FullCodeGenerator::EmitCallIC(Handle<Code> ic, JumpPatchSite* patch_site) {
     default:
       break;
   }
+
   __ Call(ic, RelocInfo::CODE_TARGET);
   if (patch_site != NULL && patch_site->is_bound()) {
     patch_site->EmitPatchInfo();
diff --git a/src/arm/ic-arm.cc b/src/arm/ic-arm.cc
index db04f330..8acf7c2e 100644
--- a/src/arm/ic-arm.cc
+++ b/src/arm/ic-arm.cc
@@ -926,6 +926,217 @@ void LoadIC::GenerateMiss(MacroAssembler* masm) {
   __ TailCallExternalReference(ref, 2, 1);
 }
 
+// Returns the code marker, or the 0 if the code is not marked.
+static inline int InlinedICSiteMarker(Address address,
+                                      Address* inline_end_address) {
+  if (V8::UseCrankshaft()) return false;
+
+  // If the instruction after the call site is not the pseudo instruction nop1
+  // then this is not related to an inlined in-object property load. The nop1
+  // instruction is located just after the call to the IC in the deferred code
+  // handling the miss in the inlined code. After the nop1 instruction there is
+  // a branch instruction for jumping back from the deferred code.
+  Address address_after_call = address + Assembler::kCallTargetAddressOffset;
+  Instr instr_after_call = Assembler::instr_at(address_after_call);
+  int code_marker = MacroAssembler::GetCodeMarker(instr_after_call);
+
+  // A negative result means the code is not marked.
+  if (code_marker <= 0) return 0;
+
+  Address address_after_nop = address_after_call + Assembler::kInstrSize;
+  Instr instr_after_nop = Assembler::instr_at(address_after_nop);
+  // There may be some reg-reg move and frame merging code to skip over before
+  // the branch back from the DeferredReferenceGetKeyedValue code to the inlined
+  // code.
+  while (!Assembler::IsBranch(instr_after_nop)) {
+    address_after_nop += Assembler::kInstrSize;
+    instr_after_nop = Assembler::instr_at(address_after_nop);
+  }
+
+  // Find the end of the inlined code for handling the load.
+  int b_offset =
+      Assembler::GetBranchOffset(instr_after_nop) + Assembler::kPcLoadDelta;
+  ASSERT(b_offset < 0);  // Jumping back from deferred code.
+  *inline_end_address = address_after_nop + b_offset;
+
+  return code_marker;
+}
+
+
+bool LoadIC::PatchInlinedLoad(Address address, Object* map, int offset) {
+  if (V8::UseCrankshaft()) return false;
+
+  // Find the end of the inlined code for handling the load if this is an
+  // inlined IC call site.
+  Address inline_end_address = 0;
+  if (InlinedICSiteMarker(address, &inline_end_address)
+      != Assembler::PROPERTY_ACCESS_INLINED) {
+    return false;
+  }
+
+  // Patch the offset of the property load instruction (ldr r0, [r1, #+XXX]).
+  // The immediate must be representable in 12 bits.
+  ASSERT((JSObject::kMaxInstanceSize - JSObject::kHeaderSize) < (1 << 12));
+  Address ldr_property_instr_address =
+      inline_end_address - Assembler::kInstrSize;
+  ASSERT(Assembler::IsLdrRegisterImmediate(
+      Assembler::instr_at(ldr_property_instr_address)));
+  Instr ldr_property_instr = Assembler::instr_at(ldr_property_instr_address);
+  ldr_property_instr = Assembler::SetLdrRegisterImmediateOffset(
+      ldr_property_instr, offset - kHeapObjectTag);
+  Assembler::instr_at_put(ldr_property_instr_address, ldr_property_instr);
+
+  // Indicate that code has changed.
+  CPU::FlushICache(ldr_property_instr_address, 1 * Assembler::kInstrSize);
+
+  // Patch the map check.
+  // For PROPERTY_ACCESS_INLINED, the load map instruction is generated
+  // 4 instructions before the end of the inlined code.
+  // See codgen-arm.cc CodeGenerator::EmitNamedLoad.
+  int ldr_map_offset = -4;
+  Address ldr_map_instr_address =
+      inline_end_address + ldr_map_offset * Assembler::kInstrSize;
+  Assembler::set_target_address_at(ldr_map_instr_address,
+                                   reinterpret_cast<Address>(map));
+  return true;
+}
+
+
+bool LoadIC::PatchInlinedContextualLoad(Address address,
+                                        Object* map,
+                                        Object* cell,
+                                        bool is_dont_delete) {
+  // Find the end of the inlined code for handling the contextual load if
+  // this is inlined IC call site.
+  Address inline_end_address = 0;
+  int marker = InlinedICSiteMarker(address, &inline_end_address);
+  if (!((marker == Assembler::PROPERTY_ACCESS_INLINED_CONTEXT) ||
+        (marker == Assembler::PROPERTY_ACCESS_INLINED_CONTEXT_DONT_DELETE))) {
+    return false;
+  }
+  // On ARM we don't rely on the is_dont_delete argument as the hint is already
+  // embedded in the code marker.
+  bool marker_is_dont_delete =
+      marker == Assembler::PROPERTY_ACCESS_INLINED_CONTEXT_DONT_DELETE;
+
+  // These are the offsets from the end of the inlined code.
+  // See codgen-arm.cc CodeGenerator::EmitNamedLoad.
+  int ldr_map_offset = marker_is_dont_delete ? -5: -8;
+  int ldr_cell_offset = marker_is_dont_delete ? -2: -5;
+  if (FLAG_debug_code && marker_is_dont_delete) {
+    // Three extra instructions were generated to check for the_hole_value.
+    ldr_map_offset -= 3;
+    ldr_cell_offset -= 3;
+  }
+  Address ldr_map_instr_address =
+      inline_end_address + ldr_map_offset * Assembler::kInstrSize;
+  Address ldr_cell_instr_address =
+      inline_end_address + ldr_cell_offset * Assembler::kInstrSize;
+
+  // Patch the map check.
+  Assembler::set_target_address_at(ldr_map_instr_address,
+                                   reinterpret_cast<Address>(map));
+  // Patch the cell address.
+  Assembler::set_target_address_at(ldr_cell_instr_address,
+                                   reinterpret_cast<Address>(cell));
+
+  return true;
+}
+
+
+bool StoreIC::PatchInlinedStore(Address address, Object* map, int offset) {
+  if (V8::UseCrankshaft()) return false;
+
+  // Find the end of the inlined code for the store if there is an
+  // inlined version of the store.
+  Address inline_end_address = 0;
+  if (InlinedICSiteMarker(address, &inline_end_address)
+      != Assembler::PROPERTY_ACCESS_INLINED) {
+    return false;
+  }
+
+  // Compute the address of the map load instruction.
+  Address ldr_map_instr_address =
+      inline_end_address -
+      (CodeGenerator::GetInlinedNamedStoreInstructionsAfterPatch() *
+       Assembler::kInstrSize);
+
+  // Update the offsets if initializing the inlined store. No reason
+  // to update the offsets when clearing the inlined version because
+  // it will bail out in the map check.
+  if (map != HEAP->null_value()) {
+    // Patch the offset in the actual store instruction.
+    Address str_property_instr_address =
+        ldr_map_instr_address + 3 * Assembler::kInstrSize;
+    Instr str_property_instr = Assembler::instr_at(str_property_instr_address);
+    ASSERT(Assembler::IsStrRegisterImmediate(str_property_instr));
+    str_property_instr = Assembler::SetStrRegisterImmediateOffset(
+        str_property_instr, offset - kHeapObjectTag);
+    Assembler::instr_at_put(str_property_instr_address, str_property_instr);
+
+    // Patch the offset in the add instruction that is part of the
+    // write barrier.
+    Address add_offset_instr_address =
+        str_property_instr_address + Assembler::kInstrSize;
+    Instr add_offset_instr = Assembler::instr_at(add_offset_instr_address);
+    ASSERT(Assembler::IsAddRegisterImmediate(add_offset_instr));
+    add_offset_instr = Assembler::SetAddRegisterImmediateOffset(
+        add_offset_instr, offset - kHeapObjectTag);
+    Assembler::instr_at_put(add_offset_instr_address, add_offset_instr);
+
+    // Indicate that code has changed.
+    CPU::FlushICache(str_property_instr_address, 2 * Assembler::kInstrSize);
+  }
+
+  // Patch the map check.
+  Assembler::set_target_address_at(ldr_map_instr_address,
+                                   reinterpret_cast<Address>(map));
+
+  return true;
+}
+
+
+bool KeyedLoadIC::PatchInlinedLoad(Address address, Object* map) {
+  if (V8::UseCrankshaft()) return false;
+
+  Address inline_end_address = 0;
+  if (InlinedICSiteMarker(address, &inline_end_address)
+      != Assembler::PROPERTY_ACCESS_INLINED) {
+    return false;
+  }
+
+  // Patch the map check.
+  Address ldr_map_instr_address =
+      inline_end_address -
+      (CodeGenerator::GetInlinedKeyedLoadInstructionsAfterPatch() *
+      Assembler::kInstrSize);
+  Assembler::set_target_address_at(ldr_map_instr_address,
+                                   reinterpret_cast<Address>(map));
+  return true;
+}
+
+
+bool KeyedStoreIC::PatchInlinedStore(Address address, Object* map) {
+  if (V8::UseCrankshaft()) return false;
+
+  // Find the end of the inlined code for handling the store if this is an
+  // inlined IC call site.
+  Address inline_end_address = 0;
+  if (InlinedICSiteMarker(address, &inline_end_address)
+      != Assembler::PROPERTY_ACCESS_INLINED) {
+    return false;
+  }
+
+  // Patch the map check.
+  Address ldr_map_instr_address =
+      inline_end_address -
+      (CodeGenerator::kInlinedKeyedStoreInstructionsAfterPatch *
+      Assembler::kInstrSize);
+  Assembler::set_target_address_at(ldr_map_instr_address,
+                                   reinterpret_cast<Address>(map));
+  return true;
+}
+
 
 Object* KeyedLoadIC_Miss(Arguments args);
 
diff --git a/src/arm/lithium-arm.cc b/src/arm/lithium-arm.cc
index faf64049..3f1d15bd 100644
--- a/src/arm/lithium-arm.cc
+++ b/src/arm/lithium-arm.cc
@@ -61,21 +61,22 @@ void LOsrEntry::MarkSpilledRegister(int allocation_index,
 
 #ifdef DEBUG
 void LInstruction::VerifyCall() {
-  // Call instructions can use only fixed registers as temporaries and
-  // outputs because all registers are blocked by the calling convention.
-  // Inputs operands must use a fixed register or use-at-start policy or
-  // a non-register policy.
+  // Call instructions can use only fixed registers as
+  // temporaries and outputs because all registers
+  // are blocked by the calling convention.
+  // Inputs must use a fixed register.
   ASSERT(Output() == NULL ||
          LUnallocated::cast(Output())->HasFixedPolicy() ||
          !LUnallocated::cast(Output())->HasRegisterPolicy());
   for (UseIterator it(this); it.HasNext(); it.Advance()) {
-    LUnallocated* operand = LUnallocated::cast(it.Next());
-    ASSERT(operand->HasFixedPolicy() ||
-           operand->IsUsedAtStart());
+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
   }
   for (TempIterator it(this); it.HasNext(); it.Advance()) {
-    LUnallocated* operand = LUnallocated::cast(it.Next());
-    ASSERT(operand->HasFixedPolicy() ||!operand->HasRegisterPolicy());
+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
   }
 }
 #endif
@@ -300,13 +301,6 @@ void LStoreContextSlot::PrintDataTo(StringStream* stream) {
 }
 
 
-void LInvokeFunction::PrintDataTo(StringStream* stream) {
-  stream->Add("= ");
-  InputAt(0)->PrintTo(stream);
-  stream->Add(" #%d / ", arity());
-}
-
-
 void LCallKeyed::PrintDataTo(StringStream* stream) {
   stream->Add("[r2] #%d / ", arity());
 }
@@ -1218,14 +1212,6 @@ LInstruction* LChunkBuilder::DoCallConstantFunction(
 }
 
 
-LInstruction* LChunkBuilder::DoInvokeFunction(HInvokeFunction* instr) {
-  LOperand* function = UseFixed(instr->function(), r1);
-  argument_count_ -= instr->argument_count();
-  LInvokeFunction* result = new LInvokeFunction(function);
-  return MarkAsCall(DefineFixed(result, r0), instr, CANNOT_DEOPTIMIZE_EAGERLY);
-}
-
-
 LInstruction* LChunkBuilder::DoUnaryMathOperation(HUnaryMathOperation* instr) {
   BuiltinFunctionId op = instr->op();
   if (op == kMathLog || op == kMathSin || op == kMathCos) {
@@ -1960,13 +1946,6 @@ LInstruction* LChunkBuilder::DoStoreNamedGeneric(HStoreNamedGeneric* instr) {
 }
 
 
-LInstruction* LChunkBuilder::DoStringAdd(HStringAdd* instr) {
-  LOperand* left = UseRegisterAtStart(instr->left());
-  LOperand* right = UseRegisterAtStart(instr->right());
-  return MarkAsCall(DefineFixed(new LStringAdd(left, right), r0), instr);
-}
-
-
 LInstruction* LChunkBuilder::DoStringCharCodeAt(HStringCharCodeAt* instr) {
   LOperand* string = UseRegister(instr->string());
   LOperand* index = UseRegisterOrConstant(instr->index());
diff --git a/src/arm/lithium-arm.h b/src/arm/lithium-arm.h
index 4add6bf4..6da7c861 100644
--- a/src/arm/lithium-arm.h
+++ b/src/arm/lithium-arm.h
@@ -106,7 +106,6 @@ class LCodeGen;
   V(InstanceOfAndBranch)                        \
   V(InstanceOfKnownGlobal)                      \
   V(Integer32ToDouble)                          \
-  V(InvokeFunction)                             \
   V(IsNull)                                     \
   V(IsNullAndBranch)                            \
   V(IsObject)                                   \
@@ -153,7 +152,6 @@ class LCodeGen;
   V(StoreKeyedSpecializedArrayElement)          \
   V(StoreNamedField)                            \
   V(StoreNamedGeneric)                          \
-  V(StringAdd)                                  \
   V(StringCharCodeAt)                           \
   V(StringCharFromCode)                         \
   V(StringLength)                               \
@@ -1414,23 +1412,6 @@ class LCallConstantFunction: public LTemplateInstruction<1, 0, 0> {
 };
 
 
-class LInvokeFunction: public LTemplateInstruction<1, 1, 0> {
- public:
-  explicit LInvokeFunction(LOperand* function) {
-    inputs_[0] = function;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
-  DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
-
-  LOperand* function() { return inputs_[0]; }
-
-  virtual void PrintDataTo(StringStream* stream);
-
-  int arity() const { return hydrogen()->argument_count() - 1; }
-};
-
-
 class LCallKeyed: public LTemplateInstruction<1, 1, 0> {
  public:
   explicit LCallKeyed(LOperand* key) {
@@ -1725,22 +1706,6 @@ class LStoreKeyedSpecializedArrayElement: public LTemplateInstruction<0, 3, 0> {
 };
 
 
-class LStringAdd: public LTemplateInstruction<1, 2, 0> {
- public:
-  LStringAdd(LOperand* left, LOperand* right) {
-    inputs_[0] = left;
-    inputs_[1] = right;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add")
-  DECLARE_HYDROGEN_ACCESSOR(StringAdd)
-
-  LOperand* left() { return inputs_[0]; }
-  LOperand* right() { return inputs_[1]; }
-};
-
-
-
 class LStringCharCodeAt: public LTemplateInstruction<1, 2, 0> {
  public:
   LStringCharCodeAt(LOperand* string, LOperand* index) {
diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc
index 2d415cba..49124497 100644
--- a/src/arm/lithium-codegen-arm.cc
+++ b/src/arm/lithium-codegen-arm.cc
@@ -91,7 +91,7 @@ bool LCodeGen::GenerateCode() {
 
 void LCodeGen::FinishCode(Handle<Code> code) {
   ASSERT(is_done());
-  code->set_stack_slots(GetStackSlotCount());
+  code->set_stack_slots(StackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
   PopulateDeoptimizationData(code);
   Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(code);
@@ -149,7 +149,7 @@ bool LCodeGen::GeneratePrologue() {
   __ add(fp, sp, Operand(2 * kPointerSize));  // Adjust FP to point to saved FP.
 
   // Reserve space for the stack slots needed by the code.
-  int slots = GetStackSlotCount();
+  int slots = StackSlotCount();
   if (slots > 0) {
     if (FLAG_debug_code) {
       __ mov(r0, Operand(slots));
@@ -263,7 +263,7 @@ bool LCodeGen::GenerateDeferredCode() {
 
 bool LCodeGen::GenerateSafepointTable() {
   ASSERT(is_done());
-  safepoints_.Emit(masm(), GetStackSlotCount());
+  safepoints_.Emit(masm(), StackSlotCount());
   return !is_aborted();
 }
 
@@ -459,7 +459,7 @@ void LCodeGen::AddToTranslation(Translation* translation,
     translation->StoreDoubleStackSlot(op->index());
   } else if (op->IsArgument()) {
     ASSERT(is_tagged);
-    int src_index = GetStackSlotCount() + op->index();
+    int src_index = StackSlotCount() + op->index();
     translation->StoreStackSlot(src_index);
   } else if (op->IsRegister()) {
     Register reg = ToRegister(op);
@@ -2180,7 +2180,7 @@ void LCodeGen::DoReturn(LReturn* instr) {
     __ push(r0);
     __ CallRuntime(Runtime::kTraceExit, 1);
   }
-  int32_t sp_delta = (GetParameterCount() + 1) * kPointerSize;
+  int32_t sp_delta = (ParameterCount() + 1) * kPointerSize;
   __ mov(sp, fp);
   __ ldm(ia_w, sp, fp.bit() | lr.bit());
   __ add(sp, sp, Operand(sp_delta));
@@ -2861,49 +2861,9 @@ void LCodeGen::DoMathFloor(LUnaryMathOperation* instr) {
 void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {
   DoubleRegister input = ToDoubleRegister(instr->InputAt(0));
   Register result = ToRegister(instr->result());
-  Register scratch1 = result;
-  Register scratch2 = scratch0();
-  Label done, check_sign_on_zero;
-
-  // Extract exponent bits.
-  __ vmov(scratch1, input.high());
-  __ ubfx(scratch2,
-          scratch1,
-          HeapNumber::kExponentShift,
-          HeapNumber::kExponentBits);
-
-  // If the number is in ]-0.5, +0.5[, the result is +/- 0.
-  __ cmp(scratch2, Operand(HeapNumber::kExponentBias - 2));
-  __ mov(result, Operand(0), LeaveCC, le);
-  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-    __ b(le, &check_sign_on_zero);
-  } else {
-    __ b(le, &done);
-  }
-
-  // The following conversion will not work with numbers
-  // outside of ]-2^32, 2^32[.
-  __ cmp(scratch2, Operand(HeapNumber::kExponentBias + 32));
-  DeoptimizeIf(ge, instr->environment());
-
-  // Save the original sign for later comparison.
-  __ and_(scratch2, scratch1, Operand(HeapNumber::kSignMask));
-
-  __ vmov(double_scratch0(), 0.5);
-  __ vadd(input, input, double_scratch0());
-
-  // Check sign of the result: if the sign changed, the input
-  // value was in ]0.5, 0[ and the result should be -0.
-  __ vmov(scratch1, input.high());
-  __ eor(scratch1, scratch1, Operand(scratch2), SetCC);
-  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-    DeoptimizeIf(mi, instr->environment());
-  } else {
-    __ mov(result, Operand(0), LeaveCC, mi);
-    __ b(mi, &done);
-  }
-
-  __ EmitVFPTruncate(kRoundToMinusInf,
+  Register scratch1 = scratch0();
+  Register scratch2 = result;
+  __ EmitVFPTruncate(kRoundToNearest,
                      double_scratch0().low(),
                      input,
                      scratch1,
@@ -2913,14 +2873,14 @@ void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {
 
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
     // Test for -0.
+    Label done;
     __ cmp(result, Operand(0));
     __ b(ne, &done);
-    __ bind(&check_sign_on_zero);
     __ vmov(scratch1, input.high());
     __ tst(scratch1, Operand(HeapNumber::kSignMask));
     DeoptimizeIf(ne, instr->environment());
+    __ bind(&done);
   }
-  __ bind(&done);
 }
 
 
@@ -3065,21 +3025,6 @@ void LCodeGen::DoUnaryMathOperation(LUnaryMathOperation* instr) {
 }
 
 
-void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
-  ASSERT(ToRegister(instr->function()).is(r1));
-  ASSERT(instr->HasPointerMap());
-  ASSERT(instr->HasDeoptimizationEnvironment());
-  LPointerMap* pointers = instr->pointer_map();
-  LEnvironment* env = instr->deoptimization_environment();
-  RecordPosition(pointers->position());
-  RegisterEnvironmentForDeoptimization(env);
-  SafepointGenerator generator(this, pointers, env->deoptimization_index());
-  ParameterCount count(instr->arity());
-  __ InvokeFunction(r1, count, CALL_FUNCTION, &generator);
-  __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
-}
-
-
 void LCodeGen::DoCallKeyed(LCallKeyed* instr) {
   ASSERT(ToRegister(instr->result()).is(r0));
 
@@ -3278,14 +3223,6 @@ void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
 }
 
 
-void LCodeGen::DoStringAdd(LStringAdd* instr) {
-  __ push(ToRegister(instr->left()));
-  __ push(ToRegister(instr->right()));
-  StringAddStub stub(NO_STRING_CHECK_IN_STUB);
-  CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
-}
-
-
 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
   class DeferredStringCharCodeAt: public LDeferredCode {
    public:
diff --git a/src/arm/lithium-codegen-arm.h b/src/arm/lithium-codegen-arm.h
index 1110ea6a..8a4ea27d 100644
--- a/src/arm/lithium-codegen-arm.h
+++ b/src/arm/lithium-codegen-arm.h
@@ -158,8 +158,8 @@ class LCodeGen BASE_EMBEDDED {
                        Register temporary,
                        Register temporary2);
 
-  int GetStackSlotCount() const { return chunk()->spill_slot_count(); }
-  int GetParameterCount() const { return scope()->num_parameters(); }
+  int StackSlotCount() const { return chunk()->spill_slot_count(); }
+  int ParameterCount() const { return scope()->num_parameters(); }
 
   void Abort(const char* format, ...);
   void Comment(const char* format, ...);
diff --git a/src/arm/regexp-macro-assembler-arm.cc b/src/arm/regexp-macro-assembler-arm.cc
index 4bd8c800..1c598234 100644
--- a/src/arm/regexp-macro-assembler-arm.cc
+++ b/src/arm/regexp-macro-assembler-arm.cc
@@ -605,7 +605,7 @@ void RegExpMacroAssemblerARM::Fail() {
 }
 
 
-Handle<Object> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
   // Finalize code - write the entry point code now we know how many
   // registers we need.
 
@@ -813,7 +813,7 @@ Handle<Object> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
                                        Code::ComputeFlags(Code::REGEXP),
                                        masm_->CodeObject());
   PROFILE(Isolate::Current(), RegExpCodeCreateEvent(*code, *source));
-  return Handle<Object>::cast(code);
+  return Handle<HeapObject>::cast(code);
 }
 
 
diff --git a/src/arm/regexp-macro-assembler-arm.h b/src/arm/regexp-macro-assembler-arm.h
index b57d0ebb..d771e403 100644
--- a/src/arm/regexp-macro-assembler-arm.h
+++ b/src/arm/regexp-macro-assembler-arm.h
@@ -82,7 +82,7 @@ class RegExpMacroAssemblerARM: public NativeRegExpMacroAssembler {
   virtual bool CheckSpecialCharacterClass(uc16 type,
                                           Label* on_no_match);
   virtual void Fail();
-  virtual Handle<Object> GetCode(Handle<String> source);
+  virtual Handle<HeapObject> GetCode(Handle<String> source);
   virtual void GoTo(Label* label);
   virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
   virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
diff --git a/src/assembler.cc b/src/assembler.cc
index ca30e19c..bfecc774 100644
--- a/src/assembler.cc
+++ b/src/assembler.cc
@@ -74,6 +74,18 @@ const double DoubleConstant::negative_infinity = -V8_INFINITY;
 const char* RelocInfo::kFillerCommentString = "DEOPTIMIZATION PADDING";
 
 // -----------------------------------------------------------------------------
+// Implementation of AssemblerBase
+
+AssemblerBase::AssemblerBase(Isolate* isolate)
+    : isolate_(isolate),
+      jit_cookie_(0) {
+  if (FLAG_mask_constants_with_cookie && isolate != NULL)  {
+    jit_cookie_ = V8::RandomPrivate(isolate);
+  }
+}
+
+
+// -----------------------------------------------------------------------------
 // Implementation of Label
 
 int Label::pos() const {
diff --git a/src/assembler.h b/src/assembler.h
index e8cecc3f..395bbd54 100644
--- a/src/assembler.h
+++ b/src/assembler.h
@@ -48,12 +48,14 @@ namespace internal {
 
 class AssemblerBase: public Malloced {
  public:
-  explicit AssemblerBase(Isolate* isolate) : isolate_(isolate) {}
+  explicit AssemblerBase(Isolate* isolate);
 
   Isolate* isolate() const { return isolate_; }
+  int jit_cookie() { return jit_cookie_; }
 
  private:
   Isolate* isolate_;
+  int jit_cookie_;
 };
 
 // -----------------------------------------------------------------------------
diff --git a/src/ast.cc b/src/ast.cc
index 303189d0..7ae0f34d 100644
--- a/src/ast.cc
+++ b/src/ast.cc
@@ -413,7 +413,8 @@ bool DebuggerStatement::IsInlineable() const {
 
 
 bool Throw::IsInlineable() const {
-  return true;
+  // TODO(1143): Make functions containing throw inlineable.
+  return false;
 }
 
 
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index 08007146..a30ffc01 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -1,4 +1,4 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
+// Copyright 2006-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:
@@ -141,8 +141,7 @@ void Bootstrapper::TearDown() {
 
 class Genesis BASE_EMBEDDED {
  public:
-  Genesis(Isolate* isolate,
-          Handle<Object> global_object,
+  Genesis(Handle<Object> global_object,
           v8::Handle<v8::ObjectTemplate> global_template,
           v8::ExtensionConfiguration* extensions);
   ~Genesis() { }
@@ -151,13 +150,8 @@ class Genesis BASE_EMBEDDED {
 
   Genesis* previous() { return previous_; }
 
-  Isolate* isolate() const { return isolate_; }
-  Factory* factory() const { return isolate_->factory(); }
-  Heap* heap() const { return isolate_->heap(); }
-
  private:
   Handle<Context> global_context_;
-  Isolate* isolate_;
 
   // There may be more than one active genesis object: When GC is
   // triggered during environment creation there may be weak handle
@@ -169,7 +163,7 @@ class Genesis BASE_EMBEDDED {
   // Creates some basic objects. Used for creating a context from scratch.
   void CreateRoots();
   // Creates the empty function.  Used for creating a context from scratch.
-  Handle<JSFunction> CreateEmptyFunction(Isolate* isolate);
+  Handle<JSFunction> CreateEmptyFunction();
   // Creates the ThrowTypeError function. ECMA 5th Ed. 13.2.3
   Handle<JSFunction> CreateThrowTypeErrorFunction(Builtins::Name builtin);
 
@@ -200,7 +194,6 @@ class Genesis BASE_EMBEDDED {
   // Used for creating a context from scratch.
   void InstallNativeFunctions();
   bool InstallNatives();
-  bool InstallExperimentalNatives();
   void InstallBuiltinFunctionIds();
   void InstallJSFunctionResultCaches();
   void InitializeNormalizedMapCaches();
@@ -246,8 +239,7 @@ class Genesis BASE_EMBEDDED {
       Handle<FixedArray> arguments,
       Handle<FixedArray> caller);
 
-  static bool CompileBuiltin(Isolate* isolate, int index);
-  static bool CompileExperimentalBuiltin(Isolate* isolate, int index);
+  static bool CompileBuiltin(int index);
   static bool CompileNative(Vector<const char> name, Handle<String> source);
   static bool CompileScriptCached(Vector<const char> name,
                                   Handle<String> source,
@@ -277,13 +269,12 @@ void Bootstrapper::Iterate(ObjectVisitor* v) {
 
 
 Handle<Context> Bootstrapper::CreateEnvironment(
-    Isolate* isolate,
     Handle<Object> global_object,
     v8::Handle<v8::ObjectTemplate> global_template,
     v8::ExtensionConfiguration* extensions) {
   HandleScope scope;
   Handle<Context> env;
-  Genesis genesis(isolate, global_object, global_template, extensions);
+  Genesis genesis(global_object, global_template, extensions);
   env = genesis.result();
   if (!env.is_null()) {
     if (InstallExtensions(env, extensions)) {
@@ -296,16 +287,15 @@ Handle<Context> Bootstrapper::CreateEnvironment(
 
 static void SetObjectPrototype(Handle<JSObject> object, Handle<Object> proto) {
   // object.__proto__ = proto;
-  Factory* factory = object->GetIsolate()->factory();
   Handle<Map> old_to_map = Handle<Map>(object->map());
-  Handle<Map> new_to_map = factory->CopyMapDropTransitions(old_to_map);
+  Handle<Map> new_to_map = FACTORY->CopyMapDropTransitions(old_to_map);
   new_to_map->set_prototype(*proto);
   object->set_map(*new_to_map);
 }
 
 
 void Bootstrapper::DetachGlobal(Handle<Context> env) {
-  Factory* factory = env->GetIsolate()->factory();
+  Factory* factory = Isolate::Current()->factory();
   JSGlobalProxy::cast(env->global_proxy())->set_context(*factory->null_value());
   SetObjectPrototype(Handle<JSObject>(env->global_proxy()),
                      factory->null_value());
@@ -332,7 +322,7 @@ static Handle<JSFunction> InstallFunction(Handle<JSObject> target,
                                           Handle<JSObject> prototype,
                                           Builtins::Name call,
                                           bool is_ecma_native) {
-  Isolate* isolate = target->GetIsolate();
+  Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
   Handle<String> symbol = factory->LookupAsciiSymbol(name);
   Handle<Code> call_code = Handle<Code>(isolate->builtins()->builtin(call));
@@ -354,31 +344,30 @@ static Handle<JSFunction> InstallFunction(Handle<JSObject> target,
 
 Handle<DescriptorArray> Genesis::ComputeFunctionInstanceDescriptor(
     PrototypePropertyMode prototypeMode) {
+  Factory* factory = Isolate::Current()->factory();
   Handle<DescriptorArray> descriptors =
-      factory()->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE
-                                    ? 4
-                                    : 5);
+      factory->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE ? 4 : 5);
   PropertyAttributes attributes =
       static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   {  // Add length.
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionLength);
-    CallbacksDescriptor d(*factory()->length_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionLength);
+    CallbacksDescriptor d(*factory->length_symbol(), *proxy, attributes);
     descriptors->Set(0, &d);
   }
   {  // Add name.
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionName);
-    CallbacksDescriptor d(*factory()->name_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionName);
+    CallbacksDescriptor d(*factory->name_symbol(), *proxy, attributes);
     descriptors->Set(1, &d);
   }
   {  // Add arguments.
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionArguments);
-    CallbacksDescriptor d(*factory()->arguments_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionArguments);
+    CallbacksDescriptor d(*factory->arguments_symbol(), *proxy, attributes);
     descriptors->Set(2, &d);
   }
   {  // Add caller.
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionCaller);
-    CallbacksDescriptor d(*factory()->caller_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionCaller);
+    CallbacksDescriptor d(*factory->caller_symbol(), *proxy, attributes);
     descriptors->Set(3, &d);
   }
   if (prototypeMode != DONT_ADD_PROTOTYPE) {
@@ -386,8 +375,8 @@ Handle<DescriptorArray> Genesis::ComputeFunctionInstanceDescriptor(
     if (prototypeMode == ADD_WRITEABLE_PROTOTYPE) {
       attributes = static_cast<PropertyAttributes>(attributes & ~READ_ONLY);
     }
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionPrototype);
-    CallbacksDescriptor d(*factory()->prototype_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionPrototype);
+    CallbacksDescriptor d(*factory->prototype_symbol(), *proxy, attributes);
     descriptors->Set(4, &d);
   }
   descriptors->Sort();
@@ -396,7 +385,7 @@ Handle<DescriptorArray> Genesis::ComputeFunctionInstanceDescriptor(
 
 
 Handle<Map> Genesis::CreateFunctionMap(PrototypePropertyMode prototype_mode) {
-  Handle<Map> map = factory()->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
+  Handle<Map> map = FACTORY->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
   Handle<DescriptorArray> descriptors =
       ComputeFunctionInstanceDescriptor(prototype_mode);
   map->set_instance_descriptors(*descriptors);
@@ -405,7 +394,7 @@ Handle<Map> Genesis::CreateFunctionMap(PrototypePropertyMode prototype_mode) {
 }
 
 
-Handle<JSFunction> Genesis::CreateEmptyFunction(Isolate* isolate) {
+Handle<JSFunction> Genesis::CreateEmptyFunction() {
   // Allocate the map for function instances. Maps are allocated first and their
   // prototypes patched later, once empty function is created.
 
@@ -433,6 +422,7 @@ Handle<JSFunction> Genesis::CreateEmptyFunction(Isolate* isolate) {
   function_instance_map_writable_prototype_ =
       CreateFunctionMap(ADD_WRITEABLE_PROTOTYPE);
 
+  Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
   Heap* heap = isolate->heap();
 
@@ -501,31 +491,28 @@ Handle<DescriptorArray> Genesis::ComputeStrictFunctionInstanceDescriptor(
     PrototypePropertyMode prototypeMode,
     Handle<FixedArray> arguments,
     Handle<FixedArray> caller) {
+  Factory* factory = Isolate::Current()->factory();
   Handle<DescriptorArray> descriptors =
-      factory()->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE
-                                    ? 4
-                                    : 5);
+      factory->NewDescriptorArray(prototypeMode == DONT_ADD_PROTOTYPE ? 4 : 5);
   PropertyAttributes attributes = static_cast<PropertyAttributes>(
       DONT_ENUM | DONT_DELETE | READ_ONLY);
 
   {  // length
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionLength);
-    CallbacksDescriptor d(*factory()->length_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionLength);
+    CallbacksDescriptor d(*factory->length_symbol(), *proxy, attributes);
     descriptors->Set(0, &d);
   }
   {  // name
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionName);
-    CallbacksDescriptor d(*factory()->name_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionName);
+    CallbacksDescriptor d(*factory->name_symbol(), *proxy, attributes);
     descriptors->Set(1, &d);
   }
   {  // arguments
-    CallbacksDescriptor d(*factory()->arguments_symbol(),
-                          *arguments,
-                          attributes);
+    CallbacksDescriptor d(*factory->arguments_symbol(), *arguments, attributes);
     descriptors->Set(2, &d);
   }
   {  // caller
-    CallbacksDescriptor d(*factory()->caller_symbol(), *caller, attributes);
+    CallbacksDescriptor d(*factory->caller_symbol(), *caller, attributes);
     descriptors->Set(3, &d);
   }
 
@@ -534,8 +521,8 @@ Handle<DescriptorArray> Genesis::ComputeStrictFunctionInstanceDescriptor(
     if (prototypeMode == ADD_WRITEABLE_PROTOTYPE) {
       attributes = static_cast<PropertyAttributes>(attributes & ~READ_ONLY);
     }
-    Handle<Proxy> proxy = factory()->NewProxy(&Accessors::FunctionPrototype);
-    CallbacksDescriptor d(*factory()->prototype_symbol(), *proxy, attributes);
+    Handle<Proxy> proxy = factory->NewProxy(&Accessors::FunctionPrototype);
+    CallbacksDescriptor d(*factory->prototype_symbol(), *proxy, attributes);
     descriptors->Set(4, &d);
   }
 
@@ -547,11 +534,14 @@ Handle<DescriptorArray> Genesis::ComputeStrictFunctionInstanceDescriptor(
 // ECMAScript 5th Edition, 13.2.3
 Handle<JSFunction> Genesis::CreateThrowTypeErrorFunction(
     Builtins::Name builtin) {
-  Handle<String> name = factory()->LookupAsciiSymbol("ThrowTypeError");
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+
+  Handle<String> name = factory->LookupAsciiSymbol("ThrowTypeError");
   Handle<JSFunction> throw_type_error =
-      factory()->NewFunctionWithoutPrototype(name, kStrictMode);
+      factory->NewFunctionWithoutPrototype(name, kStrictMode);
   Handle<Code> code = Handle<Code>(
-      isolate()->builtins()->builtin(builtin));
+      isolate->builtins()->builtin(builtin));
 
   throw_type_error->set_map(global_context()->strict_mode_function_map());
   throw_type_error->set_code(*code);
@@ -569,7 +559,7 @@ Handle<Map> Genesis::CreateStrictModeFunctionMap(
     Handle<JSFunction> empty_function,
     Handle<FixedArray> arguments_callbacks,
     Handle<FixedArray> caller_callbacks) {
-  Handle<Map> map = factory()->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
+  Handle<Map> map = FACTORY->NewMap(JS_FUNCTION_TYPE, JSFunction::kSize);
   Handle<DescriptorArray> descriptors =
       ComputeStrictFunctionInstanceDescriptor(prototype_mode,
                                               arguments_callbacks,
@@ -584,7 +574,7 @@ Handle<Map> Genesis::CreateStrictModeFunctionMap(
 void Genesis::CreateStrictModeFunctionMaps(Handle<JSFunction> empty) {
   // Create the callbacks arrays for ThrowTypeError functions.
   // The get/set callacks are filled in after the maps are created below.
-  Factory* factory = empty->GetIsolate()->factory();
+  Factory* factory = Isolate::Current()->factory();
   Handle<FixedArray> arguments = factory->NewFixedArray(2, TENURED);
   Handle<FixedArray> caller = factory->NewFixedArray(2, TENURED);
 
@@ -633,7 +623,7 @@ void Genesis::CreateStrictModeFunctionMaps(Handle<JSFunction> empty) {
 
 static void AddToWeakGlobalContextList(Context* context) {
   ASSERT(context->IsGlobalContext());
-  Heap* heap = context->GetIsolate()->heap();
+  Heap* heap = Isolate::Current()->heap();
 #ifdef DEBUG
   { // NOLINT
     ASSERT(context->get(Context::NEXT_CONTEXT_LINK)->IsUndefined());
@@ -651,14 +641,15 @@ static void AddToWeakGlobalContextList(Context* context) {
 
 
 void Genesis::CreateRoots() {
+  Isolate* isolate = Isolate::Current();
   // Allocate the global context FixedArray first and then patch the
   // closure and extension object later (we need the empty function
   // and the global object, but in order to create those, we need the
   // global context).
-  global_context_ = Handle<Context>::cast(isolate()->global_handles()->Create(
-              *factory()->NewGlobalContext()));
+  global_context_ = Handle<Context>::cast(isolate->global_handles()->Create(
+              *isolate->factory()->NewGlobalContext()));
   AddToWeakGlobalContextList(*global_context_);
-  isolate()->set_context(*global_context());
+  isolate->set_context(*global_context());
 
   // Allocate the message listeners object.
   {
@@ -701,13 +692,17 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
     }
   }
 
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Heap* heap = isolate->heap();
+
   if (js_global_template.is_null()) {
-    Handle<String> name = Handle<String>(heap()->empty_symbol());
-    Handle<Code> code = Handle<Code>(isolate()->builtins()->builtin(
+    Handle<String> name = Handle<String>(heap->empty_symbol());
+    Handle<Code> code = Handle<Code>(isolate->builtins()->builtin(
         Builtins::kIllegal));
     js_global_function =
-        factory()->NewFunction(name, JS_GLOBAL_OBJECT_TYPE,
-                               JSGlobalObject::kSize, code, true);
+        factory->NewFunction(name, JS_GLOBAL_OBJECT_TYPE,
+                             JSGlobalObject::kSize, code, true);
     // Change the constructor property of the prototype of the
     // hidden global function to refer to the Object function.
     Handle<JSObject> prototype =
@@ -715,20 +710,20 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
             JSObject::cast(js_global_function->instance_prototype()));
     SetLocalPropertyNoThrow(
         prototype,
-        factory()->constructor_symbol(),
-        isolate()->object_function(),
+        factory->constructor_symbol(),
+        isolate->object_function(),
         NONE);
   } else {
     Handle<FunctionTemplateInfo> js_global_constructor(
         FunctionTemplateInfo::cast(js_global_template->constructor()));
     js_global_function =
-        factory()->CreateApiFunction(js_global_constructor,
-                                     factory()->InnerGlobalObject);
+        factory->CreateApiFunction(js_global_constructor,
+                                   factory->InnerGlobalObject);
   }
 
   js_global_function->initial_map()->set_is_hidden_prototype();
   Handle<GlobalObject> inner_global =
-      factory()->NewGlobalObject(js_global_function);
+      factory->NewGlobalObject(js_global_function);
   if (inner_global_out != NULL) {
     *inner_global_out = inner_global;
   }
@@ -736,23 +731,23 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
   // Step 2: create or re-initialize the global proxy object.
   Handle<JSFunction> global_proxy_function;
   if (global_template.IsEmpty()) {
-    Handle<String> name = Handle<String>(heap()->empty_symbol());
-    Handle<Code> code = Handle<Code>(isolate()->builtins()->builtin(
+    Handle<String> name = Handle<String>(heap->empty_symbol());
+    Handle<Code> code = Handle<Code>(isolate->builtins()->builtin(
         Builtins::kIllegal));
     global_proxy_function =
-        factory()->NewFunction(name, JS_GLOBAL_PROXY_TYPE,
-                               JSGlobalProxy::kSize, code, true);
+        factory->NewFunction(name, JS_GLOBAL_PROXY_TYPE,
+                             JSGlobalProxy::kSize, code, true);
   } else {
     Handle<ObjectTemplateInfo> data =
         v8::Utils::OpenHandle(*global_template);
     Handle<FunctionTemplateInfo> global_constructor(
             FunctionTemplateInfo::cast(data->constructor()));
     global_proxy_function =
-        factory()->CreateApiFunction(global_constructor,
-                                     factory()->OuterGlobalObject);
+        factory->CreateApiFunction(global_constructor,
+                                   factory->OuterGlobalObject);
   }
 
-  Handle<String> global_name = factory()->LookupAsciiSymbol("global");
+  Handle<String> global_name = factory->LookupAsciiSymbol("global");
   global_proxy_function->shared()->set_instance_class_name(*global_name);
   global_proxy_function->initial_map()->set_is_access_check_needed(true);
 
@@ -766,7 +761,7 @@ Handle<JSGlobalProxy> Genesis::CreateNewGlobals(
         Handle<JSGlobalProxy>::cast(global_object));
   } else {
     return Handle<JSGlobalProxy>::cast(
-        factory()->NewJSObject(global_proxy_function, TENURED));
+        factory->NewJSObject(global_proxy_function, TENURED));
   }
 }
 
@@ -791,7 +786,7 @@ void Genesis::HookUpInnerGlobal(Handle<GlobalObject> inner_global) {
   static const PropertyAttributes attributes =
       static_cast<PropertyAttributes>(READ_ONLY | DONT_DELETE);
   ForceSetProperty(builtins_global,
-                   factory()->LookupAsciiSymbol("global"),
+                   FACTORY->LookupAsciiSymbol("global"),
                    inner_global,
                    attributes);
   // Setup the reference from the global object to the builtins object.
@@ -819,7 +814,7 @@ void Genesis::InitializeGlobal(Handle<GlobalObject> inner_global,
   // object reinitialization.
   global_context()->set_security_token(*inner_global);
 
-  Isolate* isolate = inner_global->GetIsolate();
+  Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
   Heap* heap = isolate->heap();
 
@@ -1169,26 +1164,17 @@ void Genesis::InitializeGlobal(Handle<GlobalObject> inner_global,
 }
 
 
-bool Genesis::CompileBuiltin(Isolate* isolate, int index) {
+bool Genesis::CompileBuiltin(int index) {
   Vector<const char> name = Natives::GetScriptName(index);
   Handle<String> source_code =
-      isolate->bootstrapper()->NativesSourceLookup(index);
-  return CompileNative(name, source_code);
-}
-
-
-bool Genesis::CompileExperimentalBuiltin(Isolate* isolate, int index) {
-  Vector<const char> name = ExperimentalNatives::GetScriptName(index);
-  Factory* factory = isolate->factory();
-  Handle<String> source_code =
-      factory->NewStringFromAscii(ExperimentalNatives::GetScriptSource(index));
+      Isolate::Current()->bootstrapper()->NativesSourceLookup(index);
   return CompileNative(name, source_code);
 }
 
 
 bool Genesis::CompileNative(Vector<const char> name, Handle<String> source) {
   HandleScope scope;
-  Isolate* isolate = source->GetIsolate();
+  Isolate* isolate = Isolate::Current();
 #ifdef ENABLE_DEBUGGER_SUPPORT
   isolate->debugger()->set_compiling_natives(true);
 #endif
@@ -1213,7 +1199,7 @@ bool Genesis::CompileScriptCached(Vector<const char> name,
                                   v8::Extension* extension,
                                   Handle<Context> top_context,
                                   bool use_runtime_context) {
-  Factory* factory = source->GetIsolate()->factory();
+  Factory* factory = Isolate::Current()->factory();
   HandleScope scope;
   Handle<SharedFunctionInfo> function_info;
 
@@ -1260,15 +1246,15 @@ bool Genesis::CompileScriptCached(Vector<const char> name,
 }
 
 
-#define INSTALL_NATIVE(Type, name, var)                                       \
-  Handle<String> var##_name = factory()->LookupAsciiSymbol(name);             \
-  Object* var##_native =                                                      \
-      global_context()->builtins()->GetPropertyNoExceptionThrown(             \
-           *var##_name);                                                      \
+#define INSTALL_NATIVE(Type, name, var)                                        \
+  Handle<String> var##_name = factory->LookupAsciiSymbol(name);                \
+  Object* var##_native =                                                       \
+      global_context()->builtins()->GetPropertyNoExceptionThrown(*var##_name); \
   global_context()->set_##var(Type::cast(var##_native));
 
 
 void Genesis::InstallNativeFunctions() {
+  Factory* factory = Isolate::Current()->factory();
   HandleScope scope;
   INSTALL_NATIVE(JSFunction, "CreateDate", create_date_fun);
   INSTALL_NATIVE(JSFunction, "ToNumber", to_number_fun);
@@ -1291,23 +1277,25 @@ void Genesis::InstallNativeFunctions() {
 
 bool Genesis::InstallNatives() {
   HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Heap* heap = isolate->heap();
 
   // Create a function for the builtins object. Allocate space for the
   // JavaScript builtins, a reference to the builtins object
   // (itself) and a reference to the global_context directly in the object.
   Handle<Code> code = Handle<Code>(
-      isolate()->builtins()->builtin(Builtins::kIllegal));
+      isolate->builtins()->builtin(Builtins::kIllegal));
   Handle<JSFunction> builtins_fun =
-      factory()->NewFunction(factory()->empty_symbol(),
-                             JS_BUILTINS_OBJECT_TYPE,
-                             JSBuiltinsObject::kSize, code, true);
+      factory->NewFunction(factory->empty_symbol(), JS_BUILTINS_OBJECT_TYPE,
+                           JSBuiltinsObject::kSize, code, true);
 
-  Handle<String> name = factory()->LookupAsciiSymbol("builtins");
+  Handle<String> name = factory->LookupAsciiSymbol("builtins");
   builtins_fun->shared()->set_instance_class_name(*name);
 
   // Allocate the builtins object.
   Handle<JSBuiltinsObject> builtins =
-      Handle<JSBuiltinsObject>::cast(factory()->NewGlobalObject(builtins_fun));
+      Handle<JSBuiltinsObject>::cast(factory->NewGlobalObject(builtins_fun));
   builtins->set_builtins(*builtins);
   builtins->set_global_context(*global_context());
   builtins->set_global_receiver(*builtins);
@@ -1318,7 +1306,7 @@ bool Genesis::InstallNatives() {
   // global object.
   static const PropertyAttributes attributes =
       static_cast<PropertyAttributes>(READ_ONLY | DONT_DELETE);
-  Handle<String> global_symbol = factory()->LookupAsciiSymbol("global");
+  Handle<String> global_symbol = factory->LookupAsciiSymbol("global");
   Handle<Object> global_obj(global_context()->global());
   SetLocalPropertyNoThrow(builtins, global_symbol, global_obj, attributes);
 
@@ -1327,13 +1315,12 @@ bool Genesis::InstallNatives() {
 
   // Create a bridge function that has context in the global context.
   Handle<JSFunction> bridge =
-      factory()->NewFunction(factory()->empty_symbol(),
-                             factory()->undefined_value());
-  ASSERT(bridge->context() == *isolate()->global_context());
+      factory->NewFunction(factory->empty_symbol(), factory->undefined_value());
+  ASSERT(bridge->context() == *isolate->global_context());
 
   // Allocate the builtins context.
   Handle<Context> context =
-    factory()->NewFunctionContext(Context::MIN_CONTEXT_SLOTS, bridge);
+    factory->NewFunctionContext(Context::MIN_CONTEXT_SLOTS, bridge);
   context->set_global(*builtins);  // override builtins global object
 
   global_context()->set_runtime_context(*context);
@@ -1342,113 +1329,113 @@ bool Genesis::InstallNatives() {
     // Builtin functions for Script.
     Handle<JSFunction> script_fun =
         InstallFunction(builtins, "Script", JS_VALUE_TYPE, JSValue::kSize,
-                        isolate()->initial_object_prototype(),
+                        isolate->initial_object_prototype(),
                         Builtins::kIllegal, false);
     Handle<JSObject> prototype =
-        factory()->NewJSObject(isolate()->object_function(), TENURED);
+        factory->NewJSObject(isolate->object_function(), TENURED);
     SetPrototype(script_fun, prototype);
     global_context()->set_script_function(*script_fun);
 
     // Add 'source' and 'data' property to scripts.
     PropertyAttributes common_attributes =
         static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
-    Handle<Proxy> proxy_source = factory()->NewProxy(&Accessors::ScriptSource);
+    Handle<Proxy> proxy_source = factory->NewProxy(&Accessors::ScriptSource);
     Handle<DescriptorArray> script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
-            factory()->empty_descriptor_array(),
-            factory()->LookupAsciiSymbol("source"),
+        factory->CopyAppendProxyDescriptor(
+            factory->empty_descriptor_array(),
+            factory->LookupAsciiSymbol("source"),
             proxy_source,
             common_attributes);
-    Handle<Proxy> proxy_name = factory()->NewProxy(&Accessors::ScriptName);
+    Handle<Proxy> proxy_name = factory->NewProxy(&Accessors::ScriptName);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("name"),
+            factory->LookupAsciiSymbol("name"),
             proxy_name,
             common_attributes);
-    Handle<Proxy> proxy_id = factory()->NewProxy(&Accessors::ScriptId);
+    Handle<Proxy> proxy_id = factory->NewProxy(&Accessors::ScriptId);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("id"),
+            factory->LookupAsciiSymbol("id"),
             proxy_id,
             common_attributes);
     Handle<Proxy> proxy_line_offset =
-        factory()->NewProxy(&Accessors::ScriptLineOffset);
+        factory->NewProxy(&Accessors::ScriptLineOffset);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("line_offset"),
+            factory->LookupAsciiSymbol("line_offset"),
             proxy_line_offset,
             common_attributes);
     Handle<Proxy> proxy_column_offset =
-        factory()->NewProxy(&Accessors::ScriptColumnOffset);
+        factory->NewProxy(&Accessors::ScriptColumnOffset);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("column_offset"),
+            factory->LookupAsciiSymbol("column_offset"),
             proxy_column_offset,
             common_attributes);
-    Handle<Proxy> proxy_data = factory()->NewProxy(&Accessors::ScriptData);
+    Handle<Proxy> proxy_data = factory->NewProxy(&Accessors::ScriptData);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("data"),
+            factory->LookupAsciiSymbol("data"),
             proxy_data,
             common_attributes);
-    Handle<Proxy> proxy_type = factory()->NewProxy(&Accessors::ScriptType);
+    Handle<Proxy> proxy_type = factory->NewProxy(&Accessors::ScriptType);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("type"),
+            factory->LookupAsciiSymbol("type"),
             proxy_type,
             common_attributes);
     Handle<Proxy> proxy_compilation_type =
-        factory()->NewProxy(&Accessors::ScriptCompilationType);
+        factory->NewProxy(&Accessors::ScriptCompilationType);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("compilation_type"),
+            factory->LookupAsciiSymbol("compilation_type"),
             proxy_compilation_type,
             common_attributes);
     Handle<Proxy> proxy_line_ends =
-        factory()->NewProxy(&Accessors::ScriptLineEnds);
+        factory->NewProxy(&Accessors::ScriptLineEnds);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("line_ends"),
+            factory->LookupAsciiSymbol("line_ends"),
             proxy_line_ends,
             common_attributes);
     Handle<Proxy> proxy_context_data =
-        factory()->NewProxy(&Accessors::ScriptContextData);
+        factory->NewProxy(&Accessors::ScriptContextData);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("context_data"),
+            factory->LookupAsciiSymbol("context_data"),
             proxy_context_data,
             common_attributes);
     Handle<Proxy> proxy_eval_from_script =
-        factory()->NewProxy(&Accessors::ScriptEvalFromScript);
+        factory->NewProxy(&Accessors::ScriptEvalFromScript);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("eval_from_script"),
+            factory->LookupAsciiSymbol("eval_from_script"),
             proxy_eval_from_script,
             common_attributes);
     Handle<Proxy> proxy_eval_from_script_position =
-        factory()->NewProxy(&Accessors::ScriptEvalFromScriptPosition);
+        factory->NewProxy(&Accessors::ScriptEvalFromScriptPosition);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("eval_from_script_position"),
+            factory->LookupAsciiSymbol("eval_from_script_position"),
             proxy_eval_from_script_position,
             common_attributes);
     Handle<Proxy> proxy_eval_from_function_name =
-        factory()->NewProxy(&Accessors::ScriptEvalFromFunctionName);
+        factory->NewProxy(&Accessors::ScriptEvalFromFunctionName);
     script_descriptors =
-        factory()->CopyAppendProxyDescriptor(
+        factory->CopyAppendProxyDescriptor(
             script_descriptors,
-            factory()->LookupAsciiSymbol("eval_from_function_name"),
+            factory->LookupAsciiSymbol("eval_from_function_name"),
             proxy_eval_from_function_name,
             common_attributes);
 
@@ -1456,9 +1443,9 @@ bool Genesis::InstallNatives() {
     script_map->set_instance_descriptors(*script_descriptors);
 
     // Allocate the empty script.
-    Handle<Script> script = factory()->NewScript(factory()->empty_string());
+    Handle<Script> script = factory->NewScript(factory->empty_string());
     script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
-    heap()->public_set_empty_script(*script);
+    heap->public_set_empty_script(*script);
   }
   {
     // Builtin function for OpaqueReference -- a JSValue-based object,
@@ -1467,10 +1454,10 @@ bool Genesis::InstallNatives() {
     Handle<JSFunction> opaque_reference_fun =
         InstallFunction(builtins, "OpaqueReference", JS_VALUE_TYPE,
                         JSValue::kSize,
-                        isolate()->initial_object_prototype(),
+                        isolate->initial_object_prototype(),
                         Builtins::kIllegal, false);
     Handle<JSObject> prototype =
-        factory()->NewJSObject(isolate()->object_function(), TENURED);
+        factory->NewJSObject(isolate->object_function(), TENURED);
     SetPrototype(opaque_reference_fun, prototype);
     global_context()->set_opaque_reference_function(*opaque_reference_fun);
   }
@@ -1489,23 +1476,23 @@ bool Genesis::InstallNatives() {
                         "InternalArray",
                         JS_ARRAY_TYPE,
                         JSArray::kSize,
-                        isolate()->initial_object_prototype(),
+                        isolate->initial_object_prototype(),
                         Builtins::kArrayCode,
                         true);
     Handle<JSObject> prototype =
-        factory()->NewJSObject(isolate()->object_function(), TENURED);
+        factory->NewJSObject(isolate->object_function(), TENURED);
     SetPrototype(array_function, prototype);
 
     array_function->shared()->set_construct_stub(
-        isolate()->builtins()->builtin(Builtins::kArrayConstructCode));
+        isolate->builtins()->builtin(Builtins::kArrayConstructCode));
     array_function->shared()->DontAdaptArguments();
 
     // Make "length" magic on instances.
     Handle<DescriptorArray> array_descriptors =
-        factory()->CopyAppendProxyDescriptor(
-            factory()->empty_descriptor_array(),
-            factory()->length_symbol(),
-            factory()->NewProxy(&Accessors::ArrayLength),
+        factory->CopyAppendProxyDescriptor(
+            factory->empty_descriptor_array(),
+            factory->length_symbol(),
+            factory->NewProxy(&Accessors::ArrayLength),
             static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE));
 
     array_function->initial_map()->set_instance_descriptors(
@@ -1521,7 +1508,8 @@ bool Genesis::InstallNatives() {
   for (int i = Natives::GetDebuggerCount();
        i < Natives::GetBuiltinsCount();
        i++) {
-    if (!CompileBuiltin(isolate(), i)) return false;
+    Vector<const char> name = Natives::GetScriptName(i);
+    if (!CompileBuiltin(i)) return false;
     // TODO(ager): We really only need to install the JS builtin
     // functions on the builtins object after compiling and running
     // runtime.js.
@@ -1541,9 +1529,9 @@ bool Genesis::InstallNatives() {
   InstallBuiltinFunctionIds();
 
   // Install Function.prototype.call and apply.
-  { Handle<String> key = factory()->function_class_symbol();
+  { Handle<String> key = factory->function_class_symbol();
     Handle<JSFunction> function =
-        Handle<JSFunction>::cast(GetProperty(isolate()->global(), key));
+        Handle<JSFunction>::cast(GetProperty(isolate->global(), key));
     Handle<JSObject> proto =
         Handle<JSObject>(JSObject::cast(function->instance_prototype()));
 
@@ -1585,7 +1573,7 @@ bool Genesis::InstallNatives() {
 
     // Add initial map.
     Handle<Map> initial_map =
-        factory()->NewMap(JS_ARRAY_TYPE, JSRegExpResult::kSize);
+        factory->NewMap(JS_ARRAY_TYPE, JSRegExpResult::kSize);
     initial_map->set_constructor(*array_constructor);
 
     // Set prototype on map.
@@ -1599,13 +1587,13 @@ bool Genesis::InstallNatives() {
     ASSERT_EQ(1, array_descriptors->number_of_descriptors());
 
     Handle<DescriptorArray> reresult_descriptors =
-        factory()->NewDescriptorArray(3);
+        factory->NewDescriptorArray(3);
 
     reresult_descriptors->CopyFrom(0, *array_descriptors, 0);
 
     int enum_index = 0;
     {
-      FieldDescriptor index_field(heap()->index_symbol(),
+      FieldDescriptor index_field(heap->index_symbol(),
                                   JSRegExpResult::kIndexIndex,
                                   NONE,
                                   enum_index++);
@@ -1613,7 +1601,7 @@ bool Genesis::InstallNatives() {
     }
 
     {
-      FieldDescriptor input_field(heap()->input_symbol(),
+      FieldDescriptor input_field(heap->input_symbol(),
                                   JSRegExpResult::kInputIndex,
                                   NONE,
                                   enum_index++);
@@ -1638,22 +1626,10 @@ bool Genesis::InstallNatives() {
 }
 
 
-bool Genesis::InstallExperimentalNatives() {
-  if (FLAG_harmony_proxies) {
-    for (int i = ExperimentalNatives::GetDebuggerCount();
-         i < ExperimentalNatives::GetBuiltinsCount();
-         i++) {
-      if (!CompileExperimentalBuiltin(isolate(), i)) return false;
-    }
-  }
-  return true;
-}
-
-
 static Handle<JSObject> ResolveBuiltinIdHolder(
     Handle<Context> global_context,
     const char* holder_expr) {
-  Factory* factory = global_context->GetIsolate()->factory();
+  Factory* factory = Isolate::Current()->factory();
   Handle<GlobalObject> global(global_context->global());
   const char* period_pos = strchr(holder_expr, '.');
   if (period_pos == NULL) {
@@ -1672,8 +1648,7 @@ static Handle<JSObject> ResolveBuiltinIdHolder(
 static void InstallBuiltinFunctionId(Handle<JSObject> holder,
                                      const char* function_name,
                                      BuiltinFunctionId id) {
-  Factory* factory = holder->GetIsolate()->factory();
-  Handle<String> name = factory->LookupAsciiSymbol(function_name);
+  Handle<String> name = FACTORY->LookupAsciiSymbol(function_name);
   Object* function_object = holder->GetProperty(*name)->ToObjectUnchecked();
   Handle<JSFunction> function(JSFunction::cast(function_object));
   function->shared()->set_function_data(Smi::FromInt(id));
@@ -1700,14 +1675,13 @@ void Genesis::InstallBuiltinFunctionIds() {
   F(16, global_context()->regexp_function())
 
 
-static FixedArray* CreateCache(int size, JSFunction* factory_function) {
-  Factory* factory = factory_function->GetIsolate()->factory();
+static FixedArray* CreateCache(int size, JSFunction* factory) {
   // Caches are supposed to live for a long time, allocate in old space.
   int array_size = JSFunctionResultCache::kEntriesIndex + 2 * size;
   // Cannot use cast as object is not fully initialized yet.
   JSFunctionResultCache* cache = reinterpret_cast<JSFunctionResultCache*>(
-      *factory->NewFixedArrayWithHoles(array_size, TENURED));
-  cache->set(JSFunctionResultCache::kFactoryIndex, factory_function);
+      *FACTORY->NewFixedArrayWithHoles(array_size, TENURED));
+  cache->set(JSFunctionResultCache::kFactoryIndex, factory);
   cache->MakeZeroSize();
   return cache;
 }
@@ -1746,7 +1720,7 @@ void Genesis::InitializeNormalizedMapCaches() {
 
 bool Bootstrapper::InstallExtensions(Handle<Context> global_context,
                                      v8::ExtensionConfiguration* extensions) {
-  Isolate* isolate = global_context->GetIsolate();
+  Isolate* isolate = Isolate::Current();
   BootstrapperActive active;
   SaveContext saved_context(isolate);
   isolate->set_context(*global_context);
@@ -1757,7 +1731,7 @@ bool Bootstrapper::InstallExtensions(Handle<Context> global_context,
 
 
 void Genesis::InstallSpecialObjects(Handle<Context> global_context) {
-  Factory* factory = global_context->GetIsolate()->factory();
+  Factory* factory = Isolate::Current()->factory();
   HandleScope scope;
   Handle<JSGlobalObject> js_global(
       JSGlobalObject::cast(global_context->global()));
@@ -1893,10 +1867,9 @@ bool Genesis::InstallExtension(v8::RegisteredExtension* current) {
 
 bool Genesis::InstallJSBuiltins(Handle<JSBuiltinsObject> builtins) {
   HandleScope scope;
-  Factory* factory = builtins->GetIsolate()->factory();
   for (int i = 0; i < Builtins::NumberOfJavaScriptBuiltins(); i++) {
     Builtins::JavaScript id = static_cast<Builtins::JavaScript>(i);
-    Handle<String> name = factory->LookupAsciiSymbol(Builtins::GetName(id));
+    Handle<String> name = FACTORY->LookupAsciiSymbol(Builtins::GetName(id));
     Object* function_object = builtins->GetPropertyNoExceptionThrown(*name);
     Handle<JSFunction> function
         = Handle<JSFunction>(JSFunction::cast(function_object));
@@ -1945,12 +1918,13 @@ bool Genesis::ConfigureApiObject(Handle<JSObject> object,
   ASSERT(object->IsInstanceOf(
       FunctionTemplateInfo::cast(object_template->constructor())));
 
+  Isolate* isolate = Isolate::Current();
   bool pending_exception = false;
   Handle<JSObject> obj =
       Execution::InstantiateObject(object_template, &pending_exception);
   if (pending_exception) {
-    ASSERT(isolate()->has_pending_exception());
-    isolate()->clear_pending_exception();
+    ASSERT(isolate->has_pending_exception());
+    isolate->clear_pending_exception();
     return false;
   }
   TransferObject(obj, object);
@@ -2049,7 +2023,6 @@ void Genesis::TransferIndexedProperties(Handle<JSObject> from,
 
 void Genesis::TransferObject(Handle<JSObject> from, Handle<JSObject> to) {
   HandleScope outer;
-  Factory* factory = from->GetIsolate()->factory();
 
   ASSERT(!from->IsJSArray());
   ASSERT(!to->IsJSArray());
@@ -2059,7 +2032,7 @@ void Genesis::TransferObject(Handle<JSObject> from, Handle<JSObject> to) {
 
   // Transfer the prototype (new map is needed).
   Handle<Map> old_to_map = Handle<Map>(to->map());
-  Handle<Map> new_to_map = factory->CopyMapDropTransitions(old_to_map);
+  Handle<Map> new_to_map = FACTORY->CopyMapDropTransitions(old_to_map);
   new_to_map->set_prototype(from->map()->prototype());
   to->set_map(*new_to_map);
 }
@@ -2080,10 +2053,10 @@ void Genesis::MakeFunctionInstancePrototypeWritable() {
 }
 
 
-Genesis::Genesis(Isolate* isolate,
-                 Handle<Object> global_object,
+Genesis::Genesis(Handle<Object> global_object,
                  v8::Handle<v8::ObjectTemplate> global_template,
-                 v8::ExtensionConfiguration* extensions) : isolate_(isolate) {
+                 v8::ExtensionConfiguration* extensions) {
+  Isolate* isolate = Isolate::Current();
   result_ = Handle<Context>::null();
   // If V8 isn't running and cannot be initialized, just return.
   if (!V8::IsRunning() && !V8::Initialize(NULL)) return;
@@ -2113,7 +2086,7 @@ Genesis::Genesis(Isolate* isolate,
   } else {
     // We get here if there was no context snapshot.
     CreateRoots();
-    Handle<JSFunction> empty_function = CreateEmptyFunction(isolate);
+    Handle<JSFunction> empty_function = CreateEmptyFunction();
     CreateStrictModeFunctionMaps(empty_function);
     Handle<GlobalObject> inner_global;
     Handle<JSGlobalProxy> global_proxy =
@@ -2130,9 +2103,6 @@ Genesis::Genesis(Isolate* isolate,
     isolate->counters()->contexts_created_from_scratch()->Increment();
   }
 
-  // Install experimental natives.
-  if (!InstallExperimentalNatives()) return;
-
   result_ = global_context_;
 }
 
diff --git a/src/bootstrapper.h b/src/bootstrapper.h
index 018ceef3..3e158d66 100644
--- a/src/bootstrapper.h
+++ b/src/bootstrapper.h
@@ -93,7 +93,6 @@ class Bootstrapper {
   // Creates a JavaScript Global Context with initial object graph.
   // The returned value is a global handle casted to V8Environment*.
   Handle<Context> CreateEnvironment(
-      Isolate* isolate,
       Handle<Object> global_object,
       v8::Handle<v8::ObjectTemplate> global_template,
       v8::ExtensionConfiguration* extensions);
diff --git a/src/builtins.cc b/src/builtins.cc
index ae3dab46..18465903 100644
--- a/src/builtins.cc
+++ b/src/builtins.cc
@@ -378,8 +378,7 @@ static bool ArrayPrototypeHasNoElements(Heap* heap,
   array_proto = JSObject::cast(proto);
   if (array_proto != global_context->initial_object_prototype()) return false;
   if (array_proto->elements() != heap->empty_fixed_array()) return false;
-  ASSERT(array_proto->GetPrototype()->IsNull());
-  return true;
+  return array_proto->GetPrototype()->IsNull();
 }
 
 
@@ -838,8 +837,8 @@ BUILTIN(ArraySplice) {
       const int delta = actual_delete_count - item_count;
 
       if (actual_start > 0) {
-        Object** start = elms->data_start();
-        memmove(start + delta, start, actual_start * kPointerSize);
+        AssertNoAllocation no_gc;
+        MoveElements(heap, &no_gc, elms, delta, elms, 0, actual_start);
       }
 
       elms = LeftTrimFixedArray(heap, elms, delta);
diff --git a/src/cpu-profiler.cc b/src/cpu-profiler.cc
index 38947481..10a33606 100644
--- a/src/cpu-profiler.cc
+++ b/src/cpu-profiler.cc
@@ -244,7 +244,7 @@ bool ProfilerEventsProcessor::ProcessTicks(unsigned dequeue_order) {
       // A paranoid check to make sure that we don't get a memory overrun
       // in case of frames_count having a wild value.
       if (record.sample.frames_count < 0
-          || record.sample.frames_count >= TickSample::kMaxFramesCount)
+          || record.sample.frames_count > TickSample::kMaxFramesCount)
         record.sample.frames_count = 0;
       generator_->RecordTickSample(record.sample);
       ticks_buffer_.FinishDequeue();
diff --git a/src/d8.gyp b/src/d8.gyp
index 29212dde..901fd651 100644
--- a/src/d8.gyp
+++ b/src/d8.gyp
@@ -61,7 +61,6 @@
       'variables': {
         'js_files': [
           'd8.js',
-          'macros.py',
         ],
       },
       'actions': [
@@ -73,6 +72,7 @@
           ],
           'outputs': [
             '<(SHARED_INTERMEDIATE_DIR)/d8-js.cc',
+            '<(SHARED_INTERMEDIATE_DIR)/d8-js-empty.cc',
           ],
           'action': [
             'python',
diff --git a/src/data-flow.cc b/src/data-flow.cc
index 6a3b05cc..79339eda 100644
--- a/src/data-flow.cc
+++ b/src/data-flow.cc
@@ -63,4 +63,477 @@ void BitVector::Iterator::Advance() {
   current_value_ = val >> 1;
 }
 
+
+bool AssignedVariablesAnalyzer::Analyze(CompilationInfo* info) {
+  Scope* scope = info->scope();
+  int size = scope->num_parameters() + scope->num_stack_slots();
+  if (size == 0) return true;
+  AssignedVariablesAnalyzer analyzer(info, size);
+  return analyzer.Analyze();
+}
+
+
+AssignedVariablesAnalyzer::AssignedVariablesAnalyzer(CompilationInfo* info,
+                                                     int size)
+    : info_(info), av_(size) {
+}
+
+
+bool AssignedVariablesAnalyzer::Analyze() {
+  ASSERT(av_.length() > 0);
+  VisitStatements(info_->function()->body());
+  return !HasStackOverflow();
+}
+
+
+Variable* AssignedVariablesAnalyzer::FindSmiLoopVariable(ForStatement* stmt) {
+  // The loop must have all necessary parts.
+  if (stmt->init() == NULL || stmt->cond() == NULL || stmt->next() == NULL) {
+    return NULL;
+  }
+  // The initialization statement has to be a simple assignment.
+  Assignment* init = stmt->init()->StatementAsSimpleAssignment();
+  if (init == NULL) return NULL;
+
+  // We only deal with local variables.
+  Variable* loop_var = init->target()->AsVariableProxy()->AsVariable();
+  if (loop_var == NULL || !loop_var->IsStackAllocated()) return NULL;
+
+  // Don't try to get clever with const or dynamic variables.
+  if (loop_var->mode() != Variable::VAR) return NULL;
+
+  // The initial value has to be a smi.
+  Literal* init_lit = init->value()->AsLiteral();
+  if (init_lit == NULL || !init_lit->handle()->IsSmi()) return NULL;
+  int init_value = Smi::cast(*init_lit->handle())->value();
+
+  // The condition must be a compare of variable with <, <=, >, or >=.
+  CompareOperation* cond = stmt->cond()->AsCompareOperation();
+  if (cond == NULL) return NULL;
+  if (cond->op() != Token::LT
+      && cond->op() != Token::LTE
+      && cond->op() != Token::GT
+      && cond->op() != Token::GTE) return NULL;
+
+  // The lhs must be the same variable as in the init expression.
+  if (cond->left()->AsVariableProxy()->AsVariable() != loop_var) return NULL;
+
+  // The rhs must be a smi.
+  Literal* term_lit = cond->right()->AsLiteral();
+  if (term_lit == NULL || !term_lit->handle()->IsSmi()) return NULL;
+  int term_value = Smi::cast(*term_lit->handle())->value();
+
+  // The count operation updates the same variable as in the init expression.
+  CountOperation* update = stmt->next()->StatementAsCountOperation();
+  if (update == NULL) return NULL;
+  if (update->expression()->AsVariableProxy()->AsVariable() != loop_var) {
+    return NULL;
+  }
+
+  // The direction of the count operation must agree with the start and the end
+  // value. We currently do not allow the initial value to be the same as the
+  // terminal value. This _would_ be ok as long as the loop body never executes
+  // or executes exactly one time.
+  if (init_value == term_value) return NULL;
+  if (init_value < term_value && update->op() != Token::INC) return NULL;
+  if (init_value > term_value && update->op() != Token::DEC) return NULL;
+
+  // Check that the update operation cannot overflow the smi range. This can
+  // occur in the two cases where the loop bound is equal to the largest or
+  // smallest smi.
+  if (update->op() == Token::INC && term_value == Smi::kMaxValue) return NULL;
+  if (update->op() == Token::DEC && term_value == Smi::kMinValue) return NULL;
+
+  // Found a smi loop variable.
+  return loop_var;
+}
+
+int AssignedVariablesAnalyzer::BitIndex(Variable* var) {
+  ASSERT(var != NULL);
+  ASSERT(var->IsStackAllocated());
+  Slot* slot = var->AsSlot();
+  if (slot->type() == Slot::PARAMETER) {
+    return slot->index();
+  } else {
+    return info_->scope()->num_parameters() + slot->index();
+  }
+}
+
+
+void AssignedVariablesAnalyzer::RecordAssignedVar(Variable* var) {
+  ASSERT(var != NULL);
+  if (var->IsStackAllocated()) {
+    av_.Add(BitIndex(var));
+  }
+}
+
+
+void AssignedVariablesAnalyzer::MarkIfTrivial(Expression* expr) {
+  Variable* var = expr->AsVariableProxy()->AsVariable();
+  if (var != NULL &&
+      var->IsStackAllocated() &&
+      !var->is_arguments() &&
+      var->mode() != Variable::CONST &&
+      (var->is_this() || !av_.Contains(BitIndex(var)))) {
+    expr->AsVariableProxy()->MarkAsTrivial();
+  }
+}
+
+
+void AssignedVariablesAnalyzer::ProcessExpression(Expression* expr) {
+  BitVector saved_av(av_);
+  av_.Clear();
+  Visit(expr);
+  av_.Union(saved_av);
+}
+
+void AssignedVariablesAnalyzer::VisitBlock(Block* stmt) {
+  VisitStatements(stmt->statements());
+}
+
+
+void AssignedVariablesAnalyzer::VisitExpressionStatement(
+    ExpressionStatement* stmt) {
+  ProcessExpression(stmt->expression());
+}
+
+
+void AssignedVariablesAnalyzer::VisitEmptyStatement(EmptyStatement* stmt) {
+  // Do nothing.
+}
+
+
+void AssignedVariablesAnalyzer::VisitIfStatement(IfStatement* stmt) {
+  ProcessExpression(stmt->condition());
+  Visit(stmt->then_statement());
+  Visit(stmt->else_statement());
+}
+
+
+void AssignedVariablesAnalyzer::VisitContinueStatement(
+    ContinueStatement* stmt) {
+  // Nothing to do.
+}
+
+
+void AssignedVariablesAnalyzer::VisitBreakStatement(BreakStatement* stmt) {
+  // Nothing to do.
+}
+
+
+void AssignedVariablesAnalyzer::VisitReturnStatement(ReturnStatement* stmt) {
+  ProcessExpression(stmt->expression());
+}
+
+
+void AssignedVariablesAnalyzer::VisitWithEnterStatement(
+    WithEnterStatement* stmt) {
+  ProcessExpression(stmt->expression());
+}
+
+
+void AssignedVariablesAnalyzer::VisitWithExitStatement(
+    WithExitStatement* stmt) {
+  // Nothing to do.
+}
+
+
+void AssignedVariablesAnalyzer::VisitSwitchStatement(SwitchStatement* stmt) {
+  BitVector result(av_);
+  av_.Clear();
+  Visit(stmt->tag());
+  result.Union(av_);
+  for (int i = 0; i < stmt->cases()->length(); i++) {
+    CaseClause* clause = stmt->cases()->at(i);
+    if (!clause->is_default()) {
+      av_.Clear();
+      Visit(clause->label());
+      result.Union(av_);
+    }
+    VisitStatements(clause->statements());
+  }
+  av_.Union(result);
+}
+
+
+void AssignedVariablesAnalyzer::VisitDoWhileStatement(DoWhileStatement* stmt) {
+  ProcessExpression(stmt->cond());
+  Visit(stmt->body());
+}
+
+
+void AssignedVariablesAnalyzer::VisitWhileStatement(WhileStatement* stmt) {
+  ProcessExpression(stmt->cond());
+  Visit(stmt->body());
+}
+
+
+void AssignedVariablesAnalyzer::VisitForStatement(ForStatement* stmt) {
+  if (stmt->init() != NULL) Visit(stmt->init());
+  if (stmt->cond() != NULL) ProcessExpression(stmt->cond());
+  if (stmt->next() != NULL) Visit(stmt->next());
+
+  // Process loop body. After visiting the loop body av_ contains
+  // the assigned variables of the loop body.
+  BitVector saved_av(av_);
+  av_.Clear();
+  Visit(stmt->body());
+
+  Variable* var = FindSmiLoopVariable(stmt);
+  if (var != NULL && !av_.Contains(BitIndex(var))) {
+    stmt->set_loop_variable(var);
+  }
+  av_.Union(saved_av);
+}
+
+
+void AssignedVariablesAnalyzer::VisitForInStatement(ForInStatement* stmt) {
+  ProcessExpression(stmt->each());
+  ProcessExpression(stmt->enumerable());
+  Visit(stmt->body());
+}
+
+
+void AssignedVariablesAnalyzer::VisitTryCatchStatement(
+    TryCatchStatement* stmt) {
+  Visit(stmt->try_block());
+  Visit(stmt->catch_block());
+}
+
+
+void AssignedVariablesAnalyzer::VisitTryFinallyStatement(
+    TryFinallyStatement* stmt) {
+  Visit(stmt->try_block());
+  Visit(stmt->finally_block());
+}
+
+
+void AssignedVariablesAnalyzer::VisitDebuggerStatement(
+    DebuggerStatement* stmt) {
+  // Nothing to do.
+}
+
+
+void AssignedVariablesAnalyzer::VisitFunctionLiteral(FunctionLiteral* expr) {
+  // Nothing to do.
+  ASSERT(av_.IsEmpty());
+}
+
+
+void AssignedVariablesAnalyzer::VisitSharedFunctionInfoLiteral(
+    SharedFunctionInfoLiteral* expr) {
+  // Nothing to do.
+  ASSERT(av_.IsEmpty());
+}
+
+
+void AssignedVariablesAnalyzer::VisitConditional(Conditional* expr) {
+  ASSERT(av_.IsEmpty());
+
+  Visit(expr->condition());
+
+  BitVector result(av_);
+  av_.Clear();
+  Visit(expr->then_expression());
+  result.Union(av_);
+
+  av_.Clear();
+  Visit(expr->else_expression());
+  av_.Union(result);
+}
+
+
+void AssignedVariablesAnalyzer::VisitVariableProxy(VariableProxy* expr) {
+  // Nothing to do.
+  ASSERT(av_.IsEmpty());
+}
+
+
+void AssignedVariablesAnalyzer::VisitLiteral(Literal* expr) {
+  // Nothing to do.
+  ASSERT(av_.IsEmpty());
+}
+
+
+void AssignedVariablesAnalyzer::VisitRegExpLiteral(RegExpLiteral* expr) {
+  // Nothing to do.
+  ASSERT(av_.IsEmpty());
+}
+
+
+void AssignedVariablesAnalyzer::VisitObjectLiteral(ObjectLiteral* expr) {
+  ASSERT(av_.IsEmpty());
+  BitVector result(av_.length());
+  for (int i = 0; i < expr->properties()->length(); i++) {
+    Visit(expr->properties()->at(i)->value());
+    result.Union(av_);
+    av_.Clear();
+  }
+  av_ = result;
+}
+
+
+void AssignedVariablesAnalyzer::VisitArrayLiteral(ArrayLiteral* expr) {
+  ASSERT(av_.IsEmpty());
+  BitVector result(av_.length());
+  for (int i = 0; i < expr->values()->length(); i++) {
+    Visit(expr->values()->at(i));
+    result.Union(av_);
+    av_.Clear();
+  }
+  av_ = result;
+}
+
+
+void AssignedVariablesAnalyzer::VisitCatchExtensionObject(
+    CatchExtensionObject* expr) {
+  ASSERT(av_.IsEmpty());
+  Visit(expr->key());
+  ProcessExpression(expr->value());
+}
+
+
+void AssignedVariablesAnalyzer::VisitAssignment(Assignment* expr) {
+  ASSERT(av_.IsEmpty());
+
+  // There are three kinds of assignments: variable assignments, property
+  // assignments, and reference errors (invalid left-hand sides).
+  Variable* var = expr->target()->AsVariableProxy()->AsVariable();
+  Property* prop = expr->target()->AsProperty();
+  ASSERT(var == NULL || prop == NULL);
+
+  if (var != NULL) {
+    MarkIfTrivial(expr->value());
+    Visit(expr->value());
+    if (expr->is_compound()) {
+      // Left-hand side occurs also as an rvalue.
+      MarkIfTrivial(expr->target());
+      ProcessExpression(expr->target());
+    }
+    RecordAssignedVar(var);
+
+  } else if (prop != NULL) {
+    MarkIfTrivial(expr->value());
+    Visit(expr->value());
+    if (!prop->key()->IsPropertyName()) {
+      MarkIfTrivial(prop->key());
+      ProcessExpression(prop->key());
+    }
+    MarkIfTrivial(prop->obj());
+    ProcessExpression(prop->obj());
+
+  } else {
+    Visit(expr->target());
+  }
+}
+
+
+void AssignedVariablesAnalyzer::VisitThrow(Throw* expr) {
+  ASSERT(av_.IsEmpty());
+  Visit(expr->exception());
+}
+
+
+void AssignedVariablesAnalyzer::VisitProperty(Property* expr) {
+  ASSERT(av_.IsEmpty());
+  if (!expr->key()->IsPropertyName()) {
+    MarkIfTrivial(expr->key());
+    Visit(expr->key());
+  }
+  MarkIfTrivial(expr->obj());
+  ProcessExpression(expr->obj());
+}
+
+
+void AssignedVariablesAnalyzer::VisitCall(Call* expr) {
+  ASSERT(av_.IsEmpty());
+  Visit(expr->expression());
+  BitVector result(av_);
+  for (int i = 0; i < expr->arguments()->length(); i++) {
+    av_.Clear();
+    Visit(expr->arguments()->at(i));
+    result.Union(av_);
+  }
+  av_ = result;
+}
+
+
+void AssignedVariablesAnalyzer::VisitCallNew(CallNew* expr) {
+  ASSERT(av_.IsEmpty());
+  Visit(expr->expression());
+  BitVector result(av_);
+  for (int i = 0; i < expr->arguments()->length(); i++) {
+    av_.Clear();
+    Visit(expr->arguments()->at(i));
+    result.Union(av_);
+  }
+  av_ = result;
+}
+
+
+void AssignedVariablesAnalyzer::VisitCallRuntime(CallRuntime* expr) {
+  ASSERT(av_.IsEmpty());
+  BitVector result(av_);
+  for (int i = 0; i < expr->arguments()->length(); i++) {
+    av_.Clear();
+    Visit(expr->arguments()->at(i));
+    result.Union(av_);
+  }
+  av_ = result;
+}
+
+
+void AssignedVariablesAnalyzer::VisitUnaryOperation(UnaryOperation* expr) {
+  ASSERT(av_.IsEmpty());
+  MarkIfTrivial(expr->expression());
+  Visit(expr->expression());
+}
+
+
+void AssignedVariablesAnalyzer::VisitCountOperation(CountOperation* expr) {
+  ASSERT(av_.IsEmpty());
+  if (expr->is_prefix()) MarkIfTrivial(expr->expression());
+  Visit(expr->expression());
+
+  Variable* var = expr->expression()->AsVariableProxy()->AsVariable();
+  if (var != NULL) RecordAssignedVar(var);
+}
+
+
+void AssignedVariablesAnalyzer::VisitBinaryOperation(BinaryOperation* expr) {
+  ASSERT(av_.IsEmpty());
+  MarkIfTrivial(expr->right());
+  Visit(expr->right());
+  MarkIfTrivial(expr->left());
+  ProcessExpression(expr->left());
+}
+
+
+void AssignedVariablesAnalyzer::VisitCompareOperation(CompareOperation* expr) {
+  ASSERT(av_.IsEmpty());
+  MarkIfTrivial(expr->right());
+  Visit(expr->right());
+  MarkIfTrivial(expr->left());
+  ProcessExpression(expr->left());
+}
+
+
+void AssignedVariablesAnalyzer::VisitCompareToNull(CompareToNull* expr) {
+  ASSERT(av_.IsEmpty());
+  MarkIfTrivial(expr->expression());
+  Visit(expr->expression());
+}
+
+
+void AssignedVariablesAnalyzer::VisitThisFunction(ThisFunction* expr) {
+  // Nothing to do.
+  ASSERT(av_.IsEmpty());
+}
+
+
+void AssignedVariablesAnalyzer::VisitDeclaration(Declaration* decl) {
+  UNREACHABLE();
+}
+
+
 } }  // namespace v8::internal
diff --git a/src/data-flow.h b/src/data-flow.h
index 76cff889..573d7d80 100644
--- a/src/data-flow.h
+++ b/src/data-flow.h
@@ -335,6 +335,44 @@ class WorkList BASE_EMBEDDED {
   List<T*> queue_;
 };
 
+
+// Computes the set of assigned variables and annotates variables proxies
+// that are trivial sub-expressions and for-loops where the loop variable
+// is guaranteed to be a smi.
+class AssignedVariablesAnalyzer : public AstVisitor {
+ public:
+  static bool Analyze(CompilationInfo* info);
+
+ private:
+  AssignedVariablesAnalyzer(CompilationInfo* info, int bits);
+  bool Analyze();
+
+  Variable* FindSmiLoopVariable(ForStatement* stmt);
+
+  int BitIndex(Variable* var);
+
+  void RecordAssignedVar(Variable* var);
+
+  void MarkIfTrivial(Expression* expr);
+
+  // Visits an expression saving the accumulator before, clearing
+  // it before visting and restoring it after visiting.
+  void ProcessExpression(Expression* expr);
+
+  // AST node visit functions.
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
+  AST_NODE_LIST(DECLARE_VISIT)
+#undef DECLARE_VISIT
+
+  CompilationInfo* info_;
+
+  // Accumulator for assigned variables set.
+  BitVector av_;
+
+  DISALLOW_COPY_AND_ASSIGN(AssignedVariablesAnalyzer);
+};
+
+
 } }  // namespace v8::internal
 
 
diff --git a/src/debug.cc b/src/debug.cc
index 36913337..093f38ee 100644
--- a/src/debug.cc
+++ b/src/debug.cc
@@ -477,6 +477,21 @@ void BreakLocationIterator::SetDebugBreakAtIC() {
     // calling convention used by the call site.
     Handle<Code> dbgbrk_code(Debug::FindDebugBreak(code, mode));
     rinfo()->set_target_address(dbgbrk_code->entry());
+
+    // For stubs that refer back to an inlined version clear the cached map for
+    // the inlined case to always go through the IC. As long as the break point
+    // is set the patching performed by the runtime system will take place in
+    // the code copy and will therefore have no effect on the running code
+    // keeping it from using the inlined code.
+    if (code->is_keyed_load_stub()) {
+      KeyedLoadIC::ClearInlinedVersion(pc());
+    } else if (code->is_keyed_store_stub()) {
+      KeyedStoreIC::ClearInlinedVersion(pc());
+    } else if (code->is_load_stub()) {
+      LoadIC::ClearInlinedVersion(pc());
+    } else if (code->is_store_stub()) {
+      StoreIC::ClearInlinedVersion(pc());
+    }
   }
 }
 
@@ -484,6 +499,20 @@ void BreakLocationIterator::SetDebugBreakAtIC() {
 void BreakLocationIterator::ClearDebugBreakAtIC() {
   // Patch the code to the original invoke.
   rinfo()->set_target_address(original_rinfo()->target_address());
+
+  RelocInfo::Mode mode = rmode();
+  if (RelocInfo::IsCodeTarget(mode)) {
+    AssertNoAllocation nogc;
+    Address target = original_rinfo()->target_address();
+    Code* code = Code::GetCodeFromTargetAddress(target);
+
+    // Restore the inlined version of keyed stores to get back to the
+    // fast case.  We need to patch back the keyed store because no
+    // patching happens when running normally.  For keyed loads, the
+    // map check will get patched back when running normally after ICs
+    // have been cleared at GC.
+    if (code->is_keyed_store_stub()) KeyedStoreIC::RestoreInlinedVersion(pc());
+  }
 }
 
 
@@ -814,7 +843,6 @@ bool Debug::Load() {
   HandleScope scope(isolate_);
   Handle<Context> context =
       isolate_->bootstrapper()->CreateEnvironment(
-          isolate_,
           Handle<Object>::null(),
           v8::Handle<ObjectTemplate>(),
           NULL);
diff --git a/src/extensions/experimental/collator.cc b/src/extensions/experimental/collator.cc
deleted file mode 100644
index 7d1a21dc..00000000
--- a/src/extensions/experimental/collator.cc
+++ /dev/null
@@ -1,218 +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.
-
-#include "collator.h"
-
-#include "unicode/coll.h"
-#include "unicode/locid.h"
-#include "unicode/ucol.h"
-
-namespace v8 {
-namespace internal {
-
-v8::Persistent<v8::FunctionTemplate> Collator::collator_template_;
-
-icu::Collator* Collator::UnpackCollator(v8::Handle<v8::Object> obj) {
-  if (collator_template_->HasInstance(obj)) {
-    return static_cast<icu::Collator*>(obj->GetPointerFromInternalField(0));
-  }
-
-  return NULL;
-}
-
-void Collator::DeleteCollator(v8::Persistent<v8::Value> object, void* param) {
-  v8::Persistent<v8::Object> persistent_object =
-      v8::Persistent<v8::Object>::Cast(object);
-
-  // First delete the hidden C++ object.
-  // Unpacking should never return NULL here. That would only happen if
-  // this method is used as the weak callback for persistent handles not
-  // pointing to a collator.
-  delete UnpackCollator(persistent_object);
-
-  // Then dispose of the persistent handle to JS object.
-  persistent_object.Dispose();
-}
-
-// Throws a JavaScript exception.
-static v8::Handle<v8::Value> ThrowUnexpectedObjectError() {
-  // Returns undefined, and schedules an exception to be thrown.
-  return v8::ThrowException(v8::Exception::Error(
-      v8::String::New("Collator method called on an object "
-                      "that is not a Collator.")));
-}
-
-// Extract a boolean option named in |option| and set it to |result|.
-// Return true if it's specified. Otherwise, return false.
-static bool ExtractBooleanOption(const v8::Local<v8::Object>& options,
-                                 const char* option,
-                                 bool* result) {
-  v8::HandleScope handle_scope;
-  v8::TryCatch try_catch;
-  v8::Handle<v8::Value> value = options->Get(v8::String::New(option));
-  if (try_catch.HasCaught()) {
-    return false;
-  }
-  // No need to check if |value| is empty because it's taken care of
-  // by TryCatch above.
-  if (!value->IsUndefined() && !value->IsNull()) {
-    if (value->IsBoolean()) {
-      *result = value->BooleanValue();
-      return true;
-    }
-  }
-  return false;
-}
-
-// When there's an ICU error, throw a JavaScript error with |message|.
-static v8::Handle<v8::Value> ThrowExceptionForICUError(const char* message) {
-  return v8::ThrowException(v8::Exception::Error(v8::String::New(message)));
-}
-
-v8::Handle<v8::Value> Collator::CollatorCompare(const v8::Arguments& args) {
-  if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsString()) {
-    return v8::ThrowException(v8::Exception::SyntaxError(
-        v8::String::New("Two string arguments are required.")));
-  }
-
-  icu::Collator* collator = UnpackCollator(args.Holder());
-  if (!collator) {
-    return ThrowUnexpectedObjectError();
-  }
-
-  v8::String::Value string_value1(args[0]);
-  v8::String::Value string_value2(args[1]);
-  const UChar* string1 = reinterpret_cast<const UChar*>(*string_value1);
-  const UChar* string2 = reinterpret_cast<const UChar*>(*string_value2);
-  UErrorCode status = U_ZERO_ERROR;
-  UCollationResult result = collator->compare(
-      string1, string_value1.length(), string2, string_value2.length(), status);
-
-  if (U_FAILURE(status)) {
-    return ThrowExceptionForICUError(
-        "Unexpected failure in Collator.compare.");
-  }
-
-  return v8::Int32::New(result);
-}
-
-v8::Handle<v8::Value> Collator::JSCollator(const v8::Arguments& args) {
-  v8::HandleScope handle_scope;
-
-  if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsObject()) {
-    return v8::ThrowException(v8::Exception::SyntaxError(
-        v8::String::New("Locale and collation options are required.")));
-  }
-
-  v8::String::AsciiValue locale(args[0]);
-  icu::Locale icu_locale(*locale);
-
-  icu::Collator* collator = NULL;
-  UErrorCode status = U_ZERO_ERROR;
-  collator = icu::Collator::createInstance(icu_locale, status);
-
-  if (U_FAILURE(status)) {
-    delete collator;
-    return ThrowExceptionForICUError("Failed to create collator.");
-  }
-
-  v8::Local<v8::Object> options(args[1]->ToObject());
-
-  // Below, we change collation options that are explicitly specified
-  // by a caller in JavaScript. Otherwise, we don't touch because
-  // we don't want to change the locale-dependent default value.
-  // The three options below are very likely to have the same default
-  // across locales, but I haven't checked them all. Others we may add
-  // in the future have certainly locale-dependent default (e.g.
-  // caseFirst is upperFirst for Danish while is off for most other locales).
-
-  bool ignore_case, ignore_accents, numeric;
-
-  if (ExtractBooleanOption(options, "ignoreCase", &ignore_case)) {
-    collator->setAttribute(UCOL_CASE_LEVEL, ignore_case ? UCOL_OFF : UCOL_ON,
-                           status);
-    if (U_FAILURE(status)) {
-      delete collator;
-      return ThrowExceptionForICUError("Failed to set ignoreCase.");
-    }
-  }
-
-  // Accents are taken into account with strength secondary or higher.
-  if (ExtractBooleanOption(options, "ignoreAccents", &ignore_accents)) {
-    if (!ignore_accents) {
-      collator->setStrength(icu::Collator::SECONDARY);
-    } else {
-      collator->setStrength(icu::Collator::PRIMARY);
-    }
-  }
-
-  if (ExtractBooleanOption(options, "numeric", &numeric)) {
-    collator->setAttribute(UCOL_NUMERIC_COLLATION,
-                           numeric ? UCOL_ON : UCOL_OFF, status);
-    if (U_FAILURE(status)) {
-      delete collator;
-      return ThrowExceptionForICUError("Failed to set numeric sort option.");
-    }
-  }
-
-  if (collator_template_.IsEmpty()) {
-    v8::Local<v8::FunctionTemplate> raw_template(v8::FunctionTemplate::New());
-    raw_template->SetClassName(v8::String::New("v8Locale.Collator"));
-
-    // Define internal field count on instance template.
-    v8::Local<v8::ObjectTemplate> object_template =
-        raw_template->InstanceTemplate();
-
-    // Set aside internal fields for icu collator.
-    object_template->SetInternalFieldCount(1);
-
-    // Define all of the prototype methods on prototype template.
-    v8::Local<v8::ObjectTemplate> proto = raw_template->PrototypeTemplate();
-    proto->Set(v8::String::New("compare"),
-               v8::FunctionTemplate::New(CollatorCompare));
-
-    collator_template_ =
-        v8::Persistent<v8::FunctionTemplate>::New(raw_template);
-  }
-
-  // Create an empty object wrapper.
-  v8::Local<v8::Object> local_object =
-      collator_template_->GetFunction()->NewInstance();
-  v8::Persistent<v8::Object> wrapper =
-      v8::Persistent<v8::Object>::New(local_object);
-
-  // Set collator as internal field of the resulting JS object.
-  wrapper->SetPointerInInternalField(0, collator);
-
-  // Make object handle weak so we can delete iterator once GC kicks in.
-  wrapper.MakeWeak(NULL, DeleteCollator);
-
-  return wrapper;
-}
-
-} }  // namespace v8::internal
-
diff --git a/src/extensions/experimental/collator.h b/src/extensions/experimental/collator.h
deleted file mode 100644
index 10d6ffb5..00000000
--- a/src/extensions/experimental/collator.h
+++ /dev/null
@@ -1,69 +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.
-
-#ifndef V8_EXTENSIONS_EXPERIMENTAL_COLLATOR_H
-#define V8_EXTENSIONS_EXPERIMENTAL_COLLATOR_H_
-
-#include <v8.h>
-
-#include "unicode/uversion.h"
-
-namespace U_ICU_NAMESPACE {
-class Collator;
-class UnicodeString;
-}
-
-namespace v8 {
-namespace internal {
-
-class Collator {
- public:
-  static v8::Handle<v8::Value> JSCollator(const v8::Arguments& args);
-
-  // Helper methods for various bindings.
-
-  // Unpacks collator object from corresponding JavaScript object.
-  static icu::Collator* UnpackCollator(v8::Handle<v8::Object> obj);
-
-  // Release memory we allocated for the Collator once the JS object that
-  // holds the pointer gets garbage collected.
-  static void DeleteCollator(v8::Persistent<v8::Value> object, void* param);
-
-  // Compare two strings and returns -1, 0 and 1 depending on
-  // whether string1 is smaller than, equal to or larger than string2.
-  static v8::Handle<v8::Value> CollatorCompare(const v8::Arguments& args);
-
- private:
-  Collator() {}
-
-  static v8::Persistent<v8::FunctionTemplate> collator_template_;
-};
-
-} }  // namespace v8::internal
-
-#endif  // V8_EXTENSIONS_EXPERIMENTAL_COLLATOR
-
diff --git a/src/extensions/experimental/experimental.gyp b/src/extensions/experimental/experimental.gyp
index d1194cec..a8585fd7 100644
--- a/src/extensions/experimental/experimental.gyp
+++ b/src/extensions/experimental/experimental.gyp
@@ -39,13 +39,9 @@
       'sources': [
         'break-iterator.cc',
         'break-iterator.h',
-        'collator.cc',
-        'collator.h',
         'i18n-extension.cc',
         'i18n-extension.h',
-        'i18n-locale.cc',
-        'i18n-locale.h',
-        '<(SHARED_INTERMEDIATE_DIR)/i18n-js.cc',
+	'<(SHARED_INTERMEDIATE_DIR)/i18n-js.cc',
       ],
       'include_dirs': [
         '<(icu_src_dir)/public/common',
@@ -53,7 +49,7 @@
       ],
       'dependencies': [
         '<(icu_src_dir)/icu.gyp:*',
-        'js2c_i18n#host',
+	'js2c_i18n#host',
         '../../../tools/gyp/v8.gyp:v8',
       ],
     },
@@ -63,27 +59,28 @@
       'toolsets': ['host'],
       'variables': {
         'library_files': [
-          'i18n.js'
-        ],
+	  'i18n.js'
+	],
       },
       'actions': [
         {
-          'action_name': 'js2c_i18n',
-          'inputs': [
-            '../../../tools/js2c.py',
-            '<@(library_files)',
-          ],
-          'outputs': [
-            '<(SHARED_INTERMEDIATE_DIR)/i18n-js.cc',
-          ],
-          'action': [
-            'python',
-            '../../../tools/js2c.py',
-            '<@(_outputs)',
-            'I18N',
-            '<@(library_files)'
-          ],
-        },
+	  'action_name': 'js2c_i18n',
+	  'inputs': [
+	    '../../../tools/js2c.py',
+	    '<@(library_files)',
+	  ],
+	  'outputs': [
+	    '<(SHARED_INTERMEDIATE_DIR)/i18n-js.cc',
+	    '<(SHARED_INTERMEDIATE_DIR)/i18n-js-empty.cc'
+	  ],
+	  'action': [
+	    'python',
+	    '../../../tools/js2c.py',
+	    '<@(_outputs)',
+	    'I18N',
+	    '<@(library_files)'
+	  ],
+	},
       ],
     },
   ],  # targets
diff --git a/src/extensions/experimental/i18n-extension.cc b/src/extensions/experimental/i18n-extension.cc
index 56bea23e..6e3ab15f 100644
--- a/src/extensions/experimental/i18n-extension.cc
+++ b/src/extensions/experimental/i18n-extension.cc
@@ -1,4 +1,4 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
+// 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:
@@ -27,10 +27,13 @@
 
 #include "i18n-extension.h"
 
+#include <algorithm>
+#include <string>
+
 #include "break-iterator.h"
-#include "collator.h"
-#include "i18n-locale.h"
 #include "natives.h"
+#include "unicode/locid.h"
+#include "unicode/uloc.h"
 
 namespace v8 {
 namespace internal {
@@ -54,30 +57,166 @@ I18NExtension::I18NExtension()
 v8::Handle<v8::FunctionTemplate> I18NExtension::GetNativeFunction(
     v8::Handle<v8::String> name) {
   if (name->Equals(v8::String::New("NativeJSLocale"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSLocale);
+    return v8::FunctionTemplate::New(JSLocale);
   } else if (name->Equals(v8::String::New("NativeJSAvailableLocales"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSAvailableLocales);
+    return v8::FunctionTemplate::New(JSAvailableLocales);
   } else if (name->Equals(v8::String::New("NativeJSMaximizedLocale"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSMaximizedLocale);
+    return v8::FunctionTemplate::New(JSMaximizedLocale);
   } else if (name->Equals(v8::String::New("NativeJSMinimizedLocale"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSMinimizedLocale);
+    return v8::FunctionTemplate::New(JSMinimizedLocale);
   } else if (name->Equals(v8::String::New("NativeJSDisplayLanguage"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSDisplayLanguage);
+    return v8::FunctionTemplate::New(JSDisplayLanguage);
   } else if (name->Equals(v8::String::New("NativeJSDisplayScript"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSDisplayScript);
+    return v8::FunctionTemplate::New(JSDisplayScript);
   } else if (name->Equals(v8::String::New("NativeJSDisplayRegion"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSDisplayRegion);
+    return v8::FunctionTemplate::New(JSDisplayRegion);
   } else if (name->Equals(v8::String::New("NativeJSDisplayName"))) {
-    return v8::FunctionTemplate::New(I18NLocale::JSDisplayName);
+    return v8::FunctionTemplate::New(JSDisplayName);
   } else if (name->Equals(v8::String::New("NativeJSBreakIterator"))) {
     return v8::FunctionTemplate::New(BreakIterator::JSBreakIterator);
-  } else if (name->Equals(v8::String::New("NativeJSCollator"))) {
-    return v8::FunctionTemplate::New(Collator::JSCollator);
   }
 
   return v8::Handle<v8::FunctionTemplate>();
 }
 
+v8::Handle<v8::Value> I18NExtension::JSLocale(const v8::Arguments& args) {
+  // TODO(cira): Fetch browser locale. Accept en-US as good default for now.
+  // We could possibly pass browser locale as a parameter in the constructor.
+  std::string locale_name("en-US");
+  if (args.Length() == 1 && args[0]->IsString()) {
+    locale_name = *v8::String::Utf8Value(args[0]->ToString());
+  }
+
+  v8::Local<v8::Object> locale = v8::Object::New();
+  locale->Set(v8::String::New("locale"), v8::String::New(locale_name.c_str()));
+
+  icu::Locale icu_locale(locale_name.c_str());
+
+  const char* language = icu_locale.getLanguage();
+  locale->Set(v8::String::New("language"), v8::String::New(language));
+
+  const char* script = icu_locale.getScript();
+  if (strlen(script)) {
+    locale->Set(v8::String::New("script"), v8::String::New(script));
+  }
+
+  const char* region = icu_locale.getCountry();
+  if (strlen(region)) {
+    locale->Set(v8::String::New("region"), v8::String::New(region));
+  }
+
+  return locale;
+}
+
+// TODO(cira): Filter out locales that Chrome doesn't support.
+v8::Handle<v8::Value> I18NExtension::JSAvailableLocales(
+    const v8::Arguments& args) {
+  v8::Local<v8::Array> all_locales = v8::Array::New();
+
+  int count = 0;
+  const icu::Locale* icu_locales = icu::Locale::getAvailableLocales(count);
+  for (int i = 0; i < count; ++i) {
+    all_locales->Set(i, v8::String::New(icu_locales[i].getName()));
+  }
+
+  return all_locales;
+}
+
+// Use - as tag separator, not _ that ICU uses.
+static std::string NormalizeLocale(const std::string& locale) {
+  std::string result(locale);
+  // TODO(cira): remove STL dependency.
+  std::replace(result.begin(), result.end(), '_', '-');
+  return result;
+}
+
+v8::Handle<v8::Value> I18NExtension::JSMaximizedLocale(
+    const v8::Arguments& args) {
+  if (!args.Length() || !args[0]->IsString()) {
+    return v8::Undefined();
+  }
+
+  UErrorCode status = U_ZERO_ERROR;
+  std::string locale_name = *v8::String::Utf8Value(args[0]->ToString());
+  char max_locale[ULOC_FULLNAME_CAPACITY];
+  uloc_addLikelySubtags(locale_name.c_str(), max_locale,
+                        sizeof(max_locale), &status);
+  if (U_FAILURE(status)) {
+    return v8::Undefined();
+  }
+
+  return v8::String::New(NormalizeLocale(max_locale).c_str());
+}
+
+v8::Handle<v8::Value> I18NExtension::JSMinimizedLocale(
+    const v8::Arguments& args) {
+  if (!args.Length() || !args[0]->IsString()) {
+    return v8::Undefined();
+  }
+
+  UErrorCode status = U_ZERO_ERROR;
+  std::string locale_name = *v8::String::Utf8Value(args[0]->ToString());
+  char min_locale[ULOC_FULLNAME_CAPACITY];
+  uloc_minimizeSubtags(locale_name.c_str(), min_locale,
+                       sizeof(min_locale), &status);
+  if (U_FAILURE(status)) {
+    return v8::Undefined();
+  }
+
+  return v8::String::New(NormalizeLocale(min_locale).c_str());
+}
+
+// Common code for JSDisplayXXX methods.
+static v8::Handle<v8::Value> GetDisplayItem(const v8::Arguments& args,
+                                            const std::string& item) {
+  if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsString()) {
+    return v8::Undefined();
+  }
+
+  std::string base_locale = *v8::String::Utf8Value(args[0]->ToString());
+  icu::Locale icu_locale(base_locale.c_str());
+  icu::Locale display_locale =
+      icu::Locale(*v8::String::Utf8Value(args[1]->ToString()));
+  icu::UnicodeString result;
+  if (item == "language") {
+    icu_locale.getDisplayLanguage(display_locale, result);
+  } else if (item == "script") {
+    icu_locale.getDisplayScript(display_locale, result);
+  } else if (item == "region") {
+    icu_locale.getDisplayCountry(display_locale, result);
+  } else if (item == "name") {
+    icu_locale.getDisplayName(display_locale, result);
+  } else {
+    return v8::Undefined();
+  }
+
+  if (result.length()) {
+    return v8::String::New(
+        reinterpret_cast<const uint16_t*>(result.getBuffer()), result.length());
+  }
+
+  return v8::Undefined();
+}
+
+v8::Handle<v8::Value> I18NExtension::JSDisplayLanguage(
+    const v8::Arguments& args) {
+  return GetDisplayItem(args, "language");
+}
+
+v8::Handle<v8::Value> I18NExtension::JSDisplayScript(
+    const v8::Arguments& args) {
+  return GetDisplayItem(args, "script");
+}
+
+v8::Handle<v8::Value> I18NExtension::JSDisplayRegion(
+    const v8::Arguments& args) {
+  return GetDisplayItem(args, "region");
+}
+
+v8::Handle<v8::Value> I18NExtension::JSDisplayName(const v8::Arguments& args) {
+  return GetDisplayItem(args, "name");
+}
+
 I18NExtension* I18NExtension::get() {
   if (!extension_) {
     extension_ = new I18NExtension();
diff --git a/src/extensions/experimental/i18n-extension.h b/src/extensions/experimental/i18n-extension.h
index b4dc7c35..54c973f7 100644
--- a/src/extensions/experimental/i18n-extension.h
+++ b/src/extensions/experimental/i18n-extension.h
@@ -1,4 +1,4 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
+// 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:
@@ -41,6 +41,16 @@ class I18NExtension : public v8::Extension {
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name);
 
+  // Implementations of window.Locale methods.
+  static v8::Handle<v8::Value> JSLocale(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSAvailableLocales(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSMaximizedLocale(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSMinimizedLocale(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSDisplayLanguage(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSDisplayScript(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSDisplayRegion(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSDisplayName(const v8::Arguments& args);
+
   // V8 code prefers Register, while Chrome and WebKit use get kind of methods.
   static void Register();
   static I18NExtension* get();
diff --git a/src/extensions/experimental/i18n-locale.cc b/src/extensions/experimental/i18n-locale.cc
deleted file mode 100644
index e5e1cf85..00000000
--- a/src/extensions/experimental/i18n-locale.cc
+++ /dev/null
@@ -1,172 +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.
-
-#include "i18n-locale.h"
-
-#include <algorithm>
-#include <string>
-
-#include "unicode/locid.h"
-#include "unicode/uloc.h"
-
-namespace v8 {
-namespace internal {
-
-v8::Handle<v8::Value> I18NLocale::JSLocale(const v8::Arguments& args) {
-  // TODO(cira): Fetch browser locale. Accept en-US as good default for now.
-  // We could possibly pass browser locale as a parameter in the constructor.
-  std::string locale_name("en-US");
-  if (args.Length() == 1 && args[0]->IsString()) {
-    locale_name = *v8::String::Utf8Value(args[0]->ToString());
-  }
-
-  v8::Local<v8::Object> locale = v8::Object::New();
-  locale->Set(v8::String::New("locale"), v8::String::New(locale_name.c_str()));
-
-  icu::Locale icu_locale(locale_name.c_str());
-
-  const char* language = icu_locale.getLanguage();
-  locale->Set(v8::String::New("language"), v8::String::New(language));
-
-  const char* script = icu_locale.getScript();
-  if (strlen(script)) {
-    locale->Set(v8::String::New("script"), v8::String::New(script));
-  }
-
-  const char* region = icu_locale.getCountry();
-  if (strlen(region)) {
-    locale->Set(v8::String::New("region"), v8::String::New(region));
-  }
-
-  return locale;
-}
-
-// TODO(cira): Filter out locales that Chrome doesn't support.
-v8::Handle<v8::Value> I18NLocale::JSAvailableLocales(
-    const v8::Arguments& args) {
-  v8::Local<v8::Array> all_locales = v8::Array::New();
-
-  int count = 0;
-  const icu::Locale* icu_locales = icu::Locale::getAvailableLocales(count);
-  for (int i = 0; i < count; ++i) {
-    all_locales->Set(i, v8::String::New(icu_locales[i].getName()));
-  }
-
-  return all_locales;
-}
-
-// Use - as tag separator, not _ that ICU uses.
-static std::string NormalizeLocale(const std::string& locale) {
-  std::string result(locale);
-  // TODO(cira): remove STL dependency.
-  std::replace(result.begin(), result.end(), '_', '-');
-  return result;
-}
-
-v8::Handle<v8::Value> I18NLocale::JSMaximizedLocale(const v8::Arguments& args) {
-  if (!args.Length() || !args[0]->IsString()) {
-    return v8::Undefined();
-  }
-
-  UErrorCode status = U_ZERO_ERROR;
-  std::string locale_name = *v8::String::Utf8Value(args[0]->ToString());
-  char max_locale[ULOC_FULLNAME_CAPACITY];
-  uloc_addLikelySubtags(locale_name.c_str(), max_locale,
-                        sizeof(max_locale), &status);
-  if (U_FAILURE(status)) {
-    return v8::Undefined();
-  }
-
-  return v8::String::New(NormalizeLocale(max_locale).c_str());
-}
-
-v8::Handle<v8::Value> I18NLocale::JSMinimizedLocale(const v8::Arguments& args) {
-  if (!args.Length() || !args[0]->IsString()) {
-    return v8::Undefined();
-  }
-
-  UErrorCode status = U_ZERO_ERROR;
-  std::string locale_name = *v8::String::Utf8Value(args[0]->ToString());
-  char min_locale[ULOC_FULLNAME_CAPACITY];
-  uloc_minimizeSubtags(locale_name.c_str(), min_locale,
-                       sizeof(min_locale), &status);
-  if (U_FAILURE(status)) {
-    return v8::Undefined();
-  }
-
-  return v8::String::New(NormalizeLocale(min_locale).c_str());
-}
-
-// Common code for JSDisplayXXX methods.
-static v8::Handle<v8::Value> GetDisplayItem(const v8::Arguments& args,
-                                            const std::string& item) {
-  if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsString()) {
-    return v8::Undefined();
-  }
-
-  std::string base_locale = *v8::String::Utf8Value(args[0]->ToString());
-  icu::Locale icu_locale(base_locale.c_str());
-  icu::Locale display_locale =
-      icu::Locale(*v8::String::Utf8Value(args[1]->ToString()));
-  icu::UnicodeString result;
-  if (item == "language") {
-    icu_locale.getDisplayLanguage(display_locale, result);
-  } else if (item == "script") {
-    icu_locale.getDisplayScript(display_locale, result);
-  } else if (item == "region") {
-    icu_locale.getDisplayCountry(display_locale, result);
-  } else if (item == "name") {
-    icu_locale.getDisplayName(display_locale, result);
-  } else {
-    return v8::Undefined();
-  }
-
-  if (result.length()) {
-    return v8::String::New(
-        reinterpret_cast<const uint16_t*>(result.getBuffer()), result.length());
-  }
-
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> I18NLocale::JSDisplayLanguage(const v8::Arguments& args) {
-  return GetDisplayItem(args, "language");
-}
-
-v8::Handle<v8::Value> I18NLocale::JSDisplayScript(const v8::Arguments& args) {
-  return GetDisplayItem(args, "script");
-}
-
-v8::Handle<v8::Value> I18NLocale::JSDisplayRegion(const v8::Arguments& args) {
-  return GetDisplayItem(args, "region");
-}
-
-v8::Handle<v8::Value> I18NLocale::JSDisplayName(const v8::Arguments& args) {
-  return GetDisplayItem(args, "name");
-}
-
-} }  // namespace v8::internal
diff --git a/src/extensions/experimental/i18n-locale.h b/src/extensions/experimental/i18n-locale.h
deleted file mode 100644
index aa9adbeb..00000000
--- a/src/extensions/experimental/i18n-locale.h
+++ /dev/null
@@ -1,53 +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.
-
-#ifndef V8_EXTENSIONS_EXPERIMENTAL_I18N_LOCALE_H_
-#define V8_EXTENSIONS_EXPERIMENTAL_I18N_LOCALE_H_
-
-#include <v8.h>
-
-namespace v8 {
-namespace internal {
-
-class I18NLocale {
- public:
-  I18NLocale() {}
-
-  // Implementations of window.Locale methods.
-  static v8::Handle<v8::Value> JSLocale(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSAvailableLocales(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSMaximizedLocale(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSMinimizedLocale(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSDisplayLanguage(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSDisplayScript(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSDisplayRegion(const v8::Arguments& args);
-  static v8::Handle<v8::Value> JSDisplayName(const v8::Arguments& args);
-};
-
-} }  // namespace v8::internal
-
-#endif  // V8_EXTENSIONS_EXPERIMENTAL_I18N_LOCALE_H_
diff --git a/src/extensions/experimental/i18n.js b/src/extensions/experimental/i18n.js
index 5a749058..baf38591 100644
--- a/src/extensions/experimental/i18n.js
+++ b/src/extensions/experimental/i18n.js
@@ -101,16 +101,3 @@ v8Locale.v8BreakIterator.BreakType = {
 v8Locale.prototype.v8CreateBreakIterator = function(type) {
   return new v8Locale.v8BreakIterator(this.locale, type);
 };
-
-// TODO(jungshik): Set |collator.options| to actually recognized / resolved
-// values.
-v8Locale.Collator = function(locale, options) {
-  native function NativeJSCollator();
-  var collator = NativeJSCollator(locale,
-      options === undefined ? {} : options);
-  return collator;
-};
-
-v8Locale.prototype.createCollator = function(options) {
-  return new v8Locale.Collator(this.locale, options);
-};
diff --git a/src/flag-definitions.h b/src/flag-definitions.h
index 69139bb4..17e2015d 100644
--- a/src/flag-definitions.h
+++ b/src/flag-definitions.h
@@ -96,9 +96,6 @@ private:
 //
 #define FLAG FLAG_FULL
 
-// Flags for experimental language features.
-DEFINE_bool(harmony_proxies, false, "enable harmony proxies")
-
 // Flags for Crankshaft.
 #ifdef V8_TARGET_ARCH_MIPS
   DEFINE_bool(crankshaft, false, "use crankshaft")
@@ -223,6 +220,8 @@ DEFINE_bool(use_flow_graph, false, "perform flow-graph based optimizations")
 // compilation-cache.cc
 DEFINE_bool(compilation_cache, true, "enable compilation cache")
 
+DEFINE_bool(cache_prototype_transitions, true, "cache prototype transitions")
+
 // data-flow.cc
 DEFINE_bool(loop_peeling, false, "Peel off the first iteration of loops.")
 
diff --git a/src/frames.h b/src/frames.h
index da9009be..6fe6a637 100644
--- a/src/frames.h
+++ b/src/frames.h
@@ -151,6 +151,12 @@ class StackFrame BASE_EMBEDDED {
     NO_ID = 0
   };
 
+  // Used to mark the outermost JS entry frame.
+  enum JsFrameMarker {
+    INNER_JSENTRY_FRAME = 0,
+    OUTERMOST_JSENTRY_FRAME = 1
+  };
+
   struct State {
     State() : sp(NULL), fp(NULL), pc_address(NULL) { }
     Address sp;
diff --git a/src/heap.cc b/src/heap.cc
index 93bdc039..0b4abf30 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -127,6 +127,7 @@ Heap::Heap()
       global_gc_prologue_callback_(NULL),
       global_gc_epilogue_callback_(NULL),
       gc_safe_size_of_old_object_(NULL),
+      total_regexp_code_generated_(0),
       tracer_(NULL),
       young_survivors_after_last_gc_(0),
       high_survival_rate_period_length_(0),
@@ -1596,6 +1597,7 @@ MaybeObject* Heap::AllocateMap(InstanceType instance_type, int instance_size) {
   map->set_pre_allocated_property_fields(0);
   map->set_instance_descriptors(empty_descriptor_array());
   map->set_code_cache(empty_fixed_array());
+  map->set_prototype_transitions(empty_fixed_array());
   map->set_unused_property_fields(0);
   map->set_bit_field(0);
   map->set_bit_field2((1 << Map::kIsExtensible) | (1 << Map::kHasFastElements));
@@ -1688,12 +1690,15 @@ bool Heap::CreateInitialMaps() {
   // Fix the instance_descriptors for the existing maps.
   meta_map()->set_instance_descriptors(empty_descriptor_array());
   meta_map()->set_code_cache(empty_fixed_array());
+  meta_map()->set_prototype_transitions(empty_fixed_array());
 
   fixed_array_map()->set_instance_descriptors(empty_descriptor_array());
   fixed_array_map()->set_code_cache(empty_fixed_array());
+  fixed_array_map()->set_prototype_transitions(empty_fixed_array());
 
   oddball_map()->set_instance_descriptors(empty_descriptor_array());
   oddball_map()->set_code_cache(empty_fixed_array());
+  oddball_map()->set_prototype_transitions(empty_fixed_array());
 
   // Fix prototype object for existing maps.
   meta_map()->set_prototype(null_value());
diff --git a/src/heap.h b/src/heap.h
index 7a1bed35..ae4e9e75 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -1210,6 +1210,11 @@ class Heap {
 
   GCTracer* tracer() { return tracer_; }
 
+  double total_regexp_code_generated() { return total_regexp_code_generated_; }
+  void IncreaseTotalRegexpCodeGenerated(int size) {
+    total_regexp_code_generated_ += size;
+  }
+
   // Returns maximum GC pause.
   int get_max_gc_pause() { return max_gc_pause_; }
 
@@ -1493,6 +1498,9 @@ class Heap {
       SharedFunctionInfo* shared,
       Object* prototype);
 
+  // Total RegExp code ever generated
+  double total_regexp_code_generated_;
+
   GCTracer* tracer_;
 
 
diff --git a/src/hydrogen-instructions.cc b/src/hydrogen-instructions.cc
index 3b01f576..032ca769 100644
--- a/src/hydrogen-instructions.cc
+++ b/src/hydrogen-instructions.cc
@@ -1017,9 +1017,10 @@ void HEnterInlined::PrintDataTo(StringStream* stream) {
 
 HConstant::HConstant(Handle<Object> handle, Representation r)
     : handle_(handle),
+      constant_type_(HType::TypeFromValue(handle)),
       has_int32_value_(false),
-      has_double_value_(false),
       int32_value_(0),
+      has_double_value_(false),
       double_value_(0)  {
   set_representation(r);
   SetFlag(kUseGVN);
@@ -1434,7 +1435,7 @@ HType HPhi::CalculateInferredType() {
 
 
 HType HConstant::CalculateInferredType() {
-  return HType::TypeFromValue(handle_);
+  return constant_type_;
 }
 
 
diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h
index e32a09c7..a623775f 100644
--- a/src/hydrogen-instructions.h
+++ b/src/hydrogen-instructions.h
@@ -114,7 +114,6 @@ class LChunkBuilder;
   V(HasCachedArrayIndex)                       \
   V(InstanceOf)                                \
   V(InstanceOfKnownGlobal)                     \
-  V(InvokeFunction)                            \
   V(IsNull)                                    \
   V(IsObject)                                  \
   V(IsSmi)                                     \
@@ -156,7 +155,6 @@ class LChunkBuilder;
   V(StoreKeyedGeneric)                         \
   V(StoreNamedField)                           \
   V(StoreNamedGeneric)                         \
-  V(StringAdd)                                 \
   V(StringCharCodeAt)                          \
   V(StringCharFromCode)                        \
   V(StringLength)                              \
@@ -1245,23 +1243,6 @@ class HBinaryCall: public HCall<2> {
 };
 
 
-class HInvokeFunction: public HBinaryCall {
- public:
-  HInvokeFunction(HValue* context, HValue* function, int argument_count)
-      : HBinaryCall(context, function, argument_count) {
-  }
-
-  virtual Representation RequiredInputRepresentation(int index) const {
-    return Representation::Tagged();
-  }
-
-  HValue* context() { return first(); }
-  HValue* function() { return second(); }
-
-  DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke_function")
-};
-
-
 class HCallConstantFunction: public HCall<0> {
  public:
   HCallConstantFunction(Handle<JSFunction> function, int argument_count)
@@ -1726,16 +1707,6 @@ class HCheckInstanceType: public HUnaryOperation {
   virtual void Verify();
 #endif
 
-  virtual HValue* Canonicalize() {
-    if (!value()->type().IsUninitialized() &&
-        value()->type().IsString() &&
-        first() == FIRST_STRING_TYPE &&
-        last() == LAST_STRING_TYPE) {
-      return NULL;
-    }
-    return this;
-  }
-
   static HCheckInstanceType* NewIsJSObjectOrJSFunction(HValue* value);
 
   InstanceType first() const { return first_; }
@@ -1777,18 +1748,6 @@ class HCheckNonSmi: public HUnaryOperation {
   virtual void Verify();
 #endif
 
-  virtual HValue* Canonicalize() {
-    HType value_type = value()->type();
-    if (!value_type.IsUninitialized() &&
-        (value_type.IsHeapNumber() ||
-         value_type.IsString() ||
-         value_type.IsBoolean() ||
-         value_type.IsNonPrimitive())) {
-      return NULL;
-    }
-    return this;
-  }
-
   DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check_non_smi")
 
  protected:
@@ -2031,13 +1990,14 @@ class HConstant: public HTemplateInstruction<0> {
 
  private:
   Handle<Object> handle_;
+  HType constant_type_;
 
   // The following two values represent the int32 and the double value of the
   // given constant if there is a lossless conversion between the constant
   // and the specific representation.
-  bool has_int32_value_ : 1;
-  bool has_double_value_ : 1;
+  bool has_int32_value_;
   int32_t int32_value_;
+  bool has_double_value_;
   double double_value_;
 };
 
@@ -3448,29 +3408,6 @@ class HStoreKeyedGeneric: public HTemplateInstruction<4> {
 };
 
 
-class HStringAdd: public HBinaryOperation {
- public:
-  HStringAdd(HValue* left, HValue* right) : HBinaryOperation(left, right) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetFlag(kDependsOnMaps);
-  }
-
-  virtual Representation RequiredInputRepresentation(int index) const {
-    return Representation::Tagged();
-  }
-
-  virtual HType CalculateInferredType() {
-    return HType::String();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string_add")
-
- protected:
-  virtual bool DataEquals(HValue* other) { return true; }
-};
-
-
 class HStringCharCodeAt: public HBinaryOperation {
  public:
   HStringCharCodeAt(HValue* string, HValue* index)
diff --git a/src/hydrogen.cc b/src/hydrogen.cc
index f6c47f31..73ea97d0 100644
--- a/src/hydrogen.cc
+++ b/src/hydrogen.cc
@@ -242,7 +242,7 @@ void HBasicBlock::PostProcessLoopHeader(IterationStatement* stmt) {
 
 
 void HBasicBlock::RegisterPredecessor(HBasicBlock* pred) {
-  if (HasPredecessor()) {
+  if (!predecessors_.is_empty()) {
     // Only loop header blocks can have a predecessor added after
     // instructions have been added to the block (they have phis for all
     // values in the environment, these phis may be eliminated later).
@@ -1808,7 +1808,7 @@ void HGraph::InsertRepresentationChangesForValue(
     ZoneList<Representation>* to_convert_reps) {
   Representation r = current->representation();
   if (r.IsNone()) return;
-  if (current->uses()->is_empty()) return;
+  if (current->uses()->length() == 0) return;
 
   // Collect the representation changes in a sorted list.  This allows
   // us to avoid duplicate changes without searching the list.
@@ -2076,17 +2076,37 @@ void TestContext::BuildBranch(HValue* value) {
 
 
 // HGraphBuilder infrastructure for bailing out and checking bailouts.
-#define CHECK_BAILOUT(call)                     \
+#define BAILOUT(reason)                         \
   do {                                          \
-    call;                                       \
+    Bailout(reason);                            \
+    return;                                     \
+  } while (false)
+
+
+#define CHECK_BAILOUT                           \
+  do {                                          \
+    if (HasStackOverflow()) return;             \
+  } while (false)
+
+
+#define VISIT_FOR_EFFECT(expr)                  \
+  do {                                          \
+    VisitForEffect(expr);                       \
+    if (HasStackOverflow()) return;             \
+  } while (false)
+
+
+#define VISIT_FOR_VALUE(expr)                   \
+  do {                                          \
+    VisitForValue(expr);                        \
     if (HasStackOverflow()) return;             \
   } while (false)
 
 
-#define CHECK_ALIVE(call)                                       \
+#define VISIT_FOR_CONTROL(expr, true_block, false_block)        \
   do {                                                          \
-    call;                                                       \
-    if (HasStackOverflow() || current_block() == NULL) return;  \
+    VisitForControl(expr, true_block, false_block);             \
+    if (HasStackOverflow()) return;                             \
   } while (false)
 
 
@@ -2128,21 +2148,22 @@ void HGraphBuilder::VisitForControl(Expression* expr,
 
 
 void HGraphBuilder::VisitArgument(Expression* expr) {
-  CHECK_ALIVE(VisitForValue(expr));
+  VISIT_FOR_VALUE(expr);
   Push(AddInstruction(new(zone()) HPushArgument(Pop())));
 }
 
 
 void HGraphBuilder::VisitArgumentList(ZoneList<Expression*>* arguments) {
   for (int i = 0; i < arguments->length(); i++) {
-    CHECK_ALIVE(VisitArgument(arguments->at(i)));
+    VisitArgument(arguments->at(i));
+    if (HasStackOverflow() || current_block() == NULL) return;
   }
 }
 
 
 void HGraphBuilder::VisitExpressions(ZoneList<Expression*>* exprs) {
   for (int i = 0; i < exprs->length(); ++i) {
-    CHECK_ALIVE(VisitForValue(exprs->at(i)));
+    VISIT_FOR_VALUE(exprs->at(i));
   }
 }
 
@@ -2273,7 +2294,7 @@ HInstruction* HGraphBuilder::PreProcessCall(HCall<V>* call) {
 
 void HGraphBuilder::SetupScope(Scope* scope) {
   // We don't yet handle the function name for named function expressions.
-  if (scope->function() != NULL) return Bailout("named function expression");
+  if (scope->function() != NULL) BAILOUT("named function expression");
 
   HConstant* undefined_constant = new(zone()) HConstant(
       isolate()->factory()->undefined_value(), Representation::Tagged());
@@ -2299,7 +2320,7 @@ void HGraphBuilder::SetupScope(Scope* scope) {
     if (!scope->arguments()->IsStackAllocated() ||
         (scope->arguments_shadow() != NULL &&
         !scope->arguments_shadow()->IsStackAllocated())) {
-      return Bailout("context-allocated arguments");
+      BAILOUT("context-allocated arguments");
     }
     HArgumentsObject* object = new(zone()) HArgumentsObject;
     AddInstruction(object);
@@ -2314,7 +2335,8 @@ void HGraphBuilder::SetupScope(Scope* scope) {
 
 void HGraphBuilder::VisitStatements(ZoneList<Statement*>* statements) {
   for (int i = 0; i < statements->length(); i++) {
-    CHECK_ALIVE(Visit(statements->at(i)));
+    Visit(statements->at(i));
+    if (HasStackOverflow() || current_block() == NULL) break;
   }
 }
 
@@ -2336,12 +2358,10 @@ HBasicBlock* HGraphBuilder::CreateLoopHeaderBlock() {
 
 
 void HGraphBuilder::VisitBlock(Block* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   BreakAndContinueInfo break_info(stmt);
   { BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(VisitStatements(stmt->statements()));
+    VisitStatements(stmt->statements());
+    CHECK_BAILOUT;
   }
   HBasicBlock* break_block = break_info.break_block();
   if (break_block != NULL) {
@@ -2353,24 +2373,15 @@ void HGraphBuilder::VisitBlock(Block* stmt) {
 
 
 void HGraphBuilder::VisitExpressionStatement(ExpressionStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   VisitForEffect(stmt->expression());
 }
 
 
 void HGraphBuilder::VisitEmptyStatement(EmptyStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
 }
 
 
 void HGraphBuilder::VisitIfStatement(IfStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   if (stmt->condition()->ToBooleanIsTrue()) {
     AddSimulate(stmt->ThenId());
     Visit(stmt->then_statement());
@@ -2380,27 +2391,20 @@ void HGraphBuilder::VisitIfStatement(IfStatement* stmt) {
   } else {
     HBasicBlock* cond_true = graph()->CreateBasicBlock();
     HBasicBlock* cond_false = graph()->CreateBasicBlock();
-    CHECK_BAILOUT(VisitForControl(stmt->condition(), cond_true, cond_false));
+    VISIT_FOR_CONTROL(stmt->condition(), cond_true, cond_false);
+    cond_true->SetJoinId(stmt->ThenId());
+    cond_false->SetJoinId(stmt->ElseId());
 
-    if (cond_true->HasPredecessor()) {
-      cond_true->SetJoinId(stmt->ThenId());
-      set_current_block(cond_true);
-      CHECK_BAILOUT(Visit(stmt->then_statement()));
-      cond_true = current_block();
-    } else {
-      cond_true = NULL;
-    }
+    set_current_block(cond_true);
+    Visit(stmt->then_statement());
+    CHECK_BAILOUT;
+    HBasicBlock* other = current_block();
 
-    if (cond_false->HasPredecessor()) {
-      cond_false->SetJoinId(stmt->ElseId());
-      set_current_block(cond_false);
-      CHECK_BAILOUT(Visit(stmt->else_statement()));
-      cond_false = current_block();
-    } else {
-      cond_false = NULL;
-    }
+    set_current_block(cond_false);
+    Visit(stmt->else_statement());
+    CHECK_BAILOUT;
 
-    HBasicBlock* join = CreateJoin(cond_true, cond_false, stmt->id());
+    HBasicBlock* join = CreateJoin(other, current_block(), stmt->id());
     set_current_block(join);
   }
 }
@@ -2438,9 +2442,6 @@ HBasicBlock* HGraphBuilder::BreakAndContinueScope::Get(
 
 
 void HGraphBuilder::VisitContinueStatement(ContinueStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   HBasicBlock* continue_block = break_scope()->Get(stmt->target(), CONTINUE);
   current_block()->Goto(continue_block);
   set_current_block(NULL);
@@ -2448,9 +2449,6 @@ void HGraphBuilder::VisitContinueStatement(ContinueStatement* stmt) {
 
 
 void HGraphBuilder::VisitBreakStatement(BreakStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   HBasicBlock* break_block = break_scope()->Get(stmt->target(), BREAK);
   current_block()->Goto(break_block);
   set_current_block(NULL);
@@ -2458,13 +2456,10 @@ void HGraphBuilder::VisitBreakStatement(BreakStatement* stmt) {
 
 
 void HGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   AstContext* context = call_context();
   if (context == NULL) {
     // Not an inlined return, so an actual one.
-    CHECK_ALIVE(VisitForValue(stmt->expression()));
+    VISIT_FOR_VALUE(stmt->expression());
     HValue* result = environment()->Pop();
     current_block()->FinishExit(new(zone()) HReturn(result));
     set_current_block(NULL);
@@ -2477,11 +2472,11 @@ void HGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) {
                       test->if_true(),
                       test->if_false());
     } else if (context->IsEffect()) {
-      CHECK_ALIVE(VisitForEffect(stmt->expression()));
+      VISIT_FOR_EFFECT(stmt->expression());
       current_block()->Goto(function_return(), false);
     } else {
       ASSERT(context->IsValue());
-      CHECK_ALIVE(VisitForValue(stmt->expression()));
+      VISIT_FOR_VALUE(stmt->expression());
       HValue* return_value = environment()->Pop();
       current_block()->AddLeaveInlined(return_value, function_return());
     }
@@ -2491,35 +2486,26 @@ void HGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) {
 
 
 void HGraphBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("WithEnterStatement");
+  BAILOUT("WithEnterStatement");
 }
 
 
 void HGraphBuilder::VisitWithExitStatement(WithExitStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("WithExitStatement");
+  BAILOUT("WithExitStatement");
 }
 
 
 void HGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   // We only optimize switch statements with smi-literal smi comparisons,
   // with a bounded number of clauses.
   const int kCaseClauseLimit = 128;
   ZoneList<CaseClause*>* clauses = stmt->cases();
   int clause_count = clauses->length();
   if (clause_count > kCaseClauseLimit) {
-    return Bailout("SwitchStatement: too many clauses");
+    BAILOUT("SwitchStatement: too many clauses");
   }
 
-  CHECK_ALIVE(VisitForValue(stmt->tag()));
+  VISIT_FOR_VALUE(stmt->tag());
   AddSimulate(stmt->EntryId());
   HValue* tag_value = Pop();
   HBasicBlock* first_test_block = current_block();
@@ -2530,7 +2516,7 @@ void HGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
     CaseClause* clause = clauses->at(i);
     if (clause->is_default()) continue;
     if (!clause->label()->IsSmiLiteral()) {
-      return Bailout("SwitchStatement: non-literal switch label");
+      BAILOUT("SwitchStatement: non-literal switch label");
     }
 
     // Unconditionally deoptimize on the first non-smi compare.
@@ -2542,7 +2528,7 @@ void HGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
     }
 
     // Otherwise generate a compare and branch.
-    CHECK_ALIVE(VisitForValue(clause->label()));
+    VISIT_FOR_VALUE(clause->label());
     HValue* label_value = Pop();
     HCompare* compare =
         new(zone()) HCompare(tag_value, label_value, Token::EQ_STRICT);
@@ -2572,9 +2558,11 @@ void HGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
       // Identify the block where normal (non-fall-through) control flow
       // goes to.
       HBasicBlock* normal_block = NULL;
-      if (clause->is_default() && last_block != NULL) {
-        normal_block = last_block;
-        last_block = NULL;  // Cleared to indicate we've handled it.
+      if (clause->is_default()) {
+        if (last_block != NULL) {
+          normal_block = last_block;
+          last_block = NULL;  // Cleared to indicate we've handled it.
+        }
       } else if (!curr_test_block->end()->IsDeoptimize()) {
         normal_block = curr_test_block->end()->FirstSuccessor();
         curr_test_block = curr_test_block->end()->SecondSuccessor();
@@ -2604,7 +2592,8 @@ void HGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
         set_current_block(join);
       }
 
-      CHECK_BAILOUT(VisitStatements(clause->statements()));
+      VisitStatements(clause->statements());
+      CHECK_BAILOUT;
       fall_through_block = current_block();
     }
   }
@@ -2664,9 +2653,6 @@ void HGraphBuilder::PreProcessOsrEntry(IterationStatement* statement) {
 
 
 void HGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   ASSERT(current_block() != NULL);
   PreProcessOsrEntry(stmt);
   HBasicBlock* loop_entry = CreateLoopHeaderBlock();
@@ -2675,7 +2661,8 @@ void HGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
 
   BreakAndContinueInfo break_info(stmt);
   { BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(Visit(stmt->body()));
+    Visit(stmt->body());
+    CHECK_BAILOUT;
   }
   HBasicBlock* body_exit =
       JoinContinue(stmt, current_block(), break_info.continue_block());
@@ -2686,17 +2673,9 @@ void HGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
     // back edge.
     body_exit = graph()->CreateBasicBlock();
     loop_successor = graph()->CreateBasicBlock();
-    CHECK_BAILOUT(VisitForControl(stmt->cond(), body_exit, loop_successor));
-    if (body_exit->HasPredecessor()) {
-      body_exit->SetJoinId(stmt->BackEdgeId());
-    } else {
-      body_exit = NULL;
-    }
-    if (loop_successor->HasPredecessor()) {
-      loop_successor->SetJoinId(stmt->ExitId());
-    } else {
-      loop_successor = NULL;
-    }
+    VISIT_FOR_CONTROL(stmt->cond(), body_exit, loop_successor);
+    body_exit->SetJoinId(stmt->BackEdgeId());
+    loop_successor->SetJoinId(stmt->ExitId());
   }
   HBasicBlock* loop_exit = CreateLoop(stmt,
                                       loop_entry,
@@ -2708,9 +2687,6 @@ void HGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
 
 
 void HGraphBuilder::VisitWhileStatement(WhileStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   ASSERT(current_block() != NULL);
   PreProcessOsrEntry(stmt);
   HBasicBlock* loop_entry = CreateLoopHeaderBlock();
@@ -2722,22 +2698,16 @@ void HGraphBuilder::VisitWhileStatement(WhileStatement* stmt) {
   if (!stmt->cond()->ToBooleanIsTrue()) {
     HBasicBlock* body_entry = graph()->CreateBasicBlock();
     loop_successor = graph()->CreateBasicBlock();
-    CHECK_BAILOUT(VisitForControl(stmt->cond(), body_entry, loop_successor));
-    if (body_entry->HasPredecessor()) {
-      body_entry->SetJoinId(stmt->BodyId());
-      set_current_block(body_entry);
-    }
-    if (loop_successor->HasPredecessor()) {
-      loop_successor->SetJoinId(stmt->ExitId());
-    } else {
-      loop_successor = NULL;
-    }
+    VISIT_FOR_CONTROL(stmt->cond(), body_entry, loop_successor);
+    body_entry->SetJoinId(stmt->BodyId());
+    loop_successor->SetJoinId(stmt->ExitId());
+    set_current_block(body_entry);
   }
 
   BreakAndContinueInfo break_info(stmt);
-  if (current_block() != NULL) {
-    BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(Visit(stmt->body()));
+  { BreakAndContinueScope push(&break_info, this);
+    Visit(stmt->body());
+    CHECK_BAILOUT;
   }
   HBasicBlock* body_exit =
       JoinContinue(stmt, current_block(), break_info.continue_block());
@@ -2751,11 +2721,9 @@ void HGraphBuilder::VisitWhileStatement(WhileStatement* stmt) {
 
 
 void HGraphBuilder::VisitForStatement(ForStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   if (stmt->init() != NULL) {
-    CHECK_ALIVE(Visit(stmt->init()));
+    Visit(stmt->init());
+    CHECK_BAILOUT;
   }
   ASSERT(current_block() != NULL);
   PreProcessOsrEntry(stmt);
@@ -2767,29 +2735,24 @@ void HGraphBuilder::VisitForStatement(ForStatement* stmt) {
   if (stmt->cond() != NULL) {
     HBasicBlock* body_entry = graph()->CreateBasicBlock();
     loop_successor = graph()->CreateBasicBlock();
-    CHECK_BAILOUT(VisitForControl(stmt->cond(), body_entry, loop_successor));
-    if (body_entry->HasPredecessor()) {
-      body_entry->SetJoinId(stmt->BodyId());
-      set_current_block(body_entry);
-    }
-    if (loop_successor->HasPredecessor()) {
-      loop_successor->SetJoinId(stmt->ExitId());
-    } else {
-      loop_successor = NULL;
-    }
+    VISIT_FOR_CONTROL(stmt->cond(), body_entry, loop_successor);
+    body_entry->SetJoinId(stmt->BodyId());
+    loop_successor->SetJoinId(stmt->ExitId());
+    set_current_block(body_entry);
   }
 
   BreakAndContinueInfo break_info(stmt);
-  if (current_block() != NULL) {
-    BreakAndContinueScope push(&break_info, this);
-    CHECK_BAILOUT(Visit(stmt->body()));
+  { BreakAndContinueScope push(&break_info, this);
+    Visit(stmt->body());
+    CHECK_BAILOUT;
   }
   HBasicBlock* body_exit =
       JoinContinue(stmt, current_block(), break_info.continue_block());
 
   if (stmt->next() != NULL && body_exit != NULL) {
     set_current_block(body_exit);
-    CHECK_BAILOUT(Visit(stmt->next()));
+    Visit(stmt->next());
+    CHECK_BAILOUT;
     body_exit = current_block();
   }
 
@@ -2803,34 +2766,22 @@ void HGraphBuilder::VisitForStatement(ForStatement* stmt) {
 
 
 void HGraphBuilder::VisitForInStatement(ForInStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("ForInStatement");
+  BAILOUT("ForInStatement");
 }
 
 
 void HGraphBuilder::VisitTryCatchStatement(TryCatchStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("TryCatchStatement");
+  BAILOUT("TryCatchStatement");
 }
 
 
 void HGraphBuilder::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("TryFinallyStatement");
+  BAILOUT("TryFinallyStatement");
 }
 
 
 void HGraphBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("DebuggerStatement");
+  BAILOUT("DebuggerStatement");
 }
 
 
@@ -2855,17 +2806,13 @@ static Handle<SharedFunctionInfo> SearchSharedFunctionInfo(
 
 
 void HGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   Handle<SharedFunctionInfo> shared_info =
       SearchSharedFunctionInfo(info()->shared_info()->code(),
                                expr);
   if (shared_info.is_null()) {
     shared_info = Compiler::BuildFunctionInfo(expr, info()->script());
   }
-  // We also have a stack overflow if the recursive compilation did.
-  if (HasStackOverflow()) return;
+  CHECK_BAILOUT;
   HFunctionLiteral* instr =
       new(zone()) HFunctionLiteral(shared_info, expr->pretenure());
   ast_context()->ReturnInstruction(instr, expr->id());
@@ -2874,47 +2821,32 @@ void HGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
 
 void HGraphBuilder::VisitSharedFunctionInfoLiteral(
     SharedFunctionInfoLiteral* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("SharedFunctionInfoLiteral");
+  BAILOUT("SharedFunctionInfoLiteral");
 }
 
 
 void HGraphBuilder::VisitConditional(Conditional* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   HBasicBlock* cond_true = graph()->CreateBasicBlock();
   HBasicBlock* cond_false = graph()->CreateBasicBlock();
-  CHECK_BAILOUT(VisitForControl(expr->condition(), cond_true, cond_false));
+  VISIT_FOR_CONTROL(expr->condition(), cond_true, cond_false);
+  cond_true->SetJoinId(expr->ThenId());
+  cond_false->SetJoinId(expr->ElseId());
 
   // Visit the true and false subexpressions in the same AST context as the
   // whole expression.
-  if (cond_true->HasPredecessor()) {
-    cond_true->SetJoinId(expr->ThenId());
-    set_current_block(cond_true);
-    CHECK_BAILOUT(Visit(expr->then_expression()));
-    cond_true = current_block();
-  } else {
-    cond_true = NULL;
-  }
+  set_current_block(cond_true);
+  Visit(expr->then_expression());
+  CHECK_BAILOUT;
+  HBasicBlock* other = current_block();
 
-  if (cond_false->HasPredecessor()) {
-    cond_false->SetJoinId(expr->ElseId());
-    set_current_block(cond_false);
-    CHECK_BAILOUT(Visit(expr->else_expression()));
-    cond_false = current_block();
-  } else {
-    cond_false = NULL;
-  }
+  set_current_block(cond_false);
+  Visit(expr->else_expression());
+  CHECK_BAILOUT;
 
   if (!ast_context()->IsTest()) {
-    HBasicBlock* join = CreateJoin(cond_true, cond_false, expr->id());
+    HBasicBlock* join = CreateJoin(other, current_block(), expr->id());
     set_current_block(join);
-    if (join != NULL && !ast_context()->IsEffect()) {
-      ast_context()->ReturnValue(Pop());
-    }
+    if (!ast_context()->IsEffect()) ast_context()->ReturnValue(Pop());
   }
 }
 
@@ -2951,20 +2883,17 @@ HValue* HGraphBuilder::BuildContextChainWalk(Variable* var) {
 
 
 void HGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   Variable* variable = expr->AsVariable();
   if (variable == NULL) {
-    return Bailout("reference to rewritten variable");
+    BAILOUT("reference to rewritten variable");
   } else if (variable->IsStackAllocated()) {
     if (environment()->Lookup(variable)->CheckFlag(HValue::kIsArguments)) {
-      return Bailout("unsupported context for arguments object");
+      BAILOUT("unsupported context for arguments object");
     }
     ast_context()->ReturnValue(environment()->Lookup(variable));
   } else if (variable->IsContextSlot()) {
     if (variable->mode() == Variable::CONST) {
-      return Bailout("reference to const context slot");
+      BAILOUT("reference to const context slot");
     }
     HValue* context = BuildContextChainWalk(variable);
     int index = variable->AsSlot()->index();
@@ -3000,15 +2929,12 @@ void HGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
       ast_context()->ReturnInstruction(instr, expr->id());
     }
   } else {
-    return Bailout("reference to a variable which requires dynamic lookup");
+    BAILOUT("reference to a variable which requires dynamic lookup");
   }
 }
 
 
 void HGraphBuilder::VisitLiteral(Literal* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   HConstant* instr =
       new(zone()) HConstant(expr->handle(), Representation::Tagged());
   ast_context()->ReturnInstruction(instr, expr->id());
@@ -3016,9 +2942,6 @@ void HGraphBuilder::VisitLiteral(Literal* expr) {
 
 
 void HGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   HRegExpLiteral* instr = new(zone()) HRegExpLiteral(expr->pattern(),
                                                      expr->flags(),
                                                      expr->literal_index());
@@ -3027,9 +2950,6 @@ void HGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
 
 
 void HGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HObjectLiteral* literal =
@@ -3059,7 +2979,7 @@ void HGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
       case ObjectLiteral::Property::COMPUTED:
         if (key->handle()->IsSymbol()) {
           if (property->emit_store()) {
-            CHECK_ALIVE(VisitForValue(value));
+            VISIT_FOR_VALUE(value);
             HValue* value = Pop();
             Handle<String> name = Handle<String>::cast(key->handle());
             HStoreNamedGeneric* store =
@@ -3072,7 +2992,7 @@ void HGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
             AddInstruction(store);
             AddSimulate(key->id());
           } else {
-            CHECK_ALIVE(VisitForEffect(value));
+            VISIT_FOR_EFFECT(value);
           }
           break;
         }
@@ -3080,7 +3000,7 @@ void HGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
       case ObjectLiteral::Property::PROTOTYPE:
       case ObjectLiteral::Property::SETTER:
       case ObjectLiteral::Property::GETTER:
-        return Bailout("Object literal with complex property");
+        BAILOUT("Object literal with complex property");
       default: UNREACHABLE();
     }
   }
@@ -3101,9 +3021,6 @@ void HGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
 
 
 void HGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   ZoneList<Expression*>* subexprs = expr->values();
   int length = subexprs->length();
 
@@ -3123,9 +3040,9 @@ void HGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
     // is already set in the cloned array.
     if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
 
-    CHECK_ALIVE(VisitForValue(subexpr));
+    VISIT_FOR_VALUE(subexpr);
     HValue* value = Pop();
-    if (!Smi::IsValid(i)) return Bailout("Non-smi key in array literal");
+    if (!Smi::IsValid(i)) BAILOUT("Non-smi key in array literal");
 
     // Load the elements array before the first store.
     if (elements == NULL)  {
@@ -3144,10 +3061,7 @@ void HGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
 
 
 void HGraphBuilder::VisitCatchExtensionObject(CatchExtensionObject* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("CatchExtensionObject");
+  BAILOUT("CatchExtensionObject");
 }
 
 
@@ -3326,14 +3240,14 @@ void HGraphBuilder::HandlePropertyAssignment(Assignment* expr) {
   Property* prop = expr->target()->AsProperty();
   ASSERT(prop != NULL);
   expr->RecordTypeFeedback(oracle());
-  CHECK_ALIVE(VisitForValue(prop->obj()));
+  VISIT_FOR_VALUE(prop->obj());
 
   HValue* value = NULL;
   HInstruction* instr = NULL;
 
   if (prop->key()->IsPropertyName()) {
     // Named store.
-    CHECK_ALIVE(VisitForValue(expr->value()));
+    VISIT_FOR_VALUE(expr->value());
     value = Pop();
     HValue* object = Pop();
 
@@ -3357,8 +3271,8 @@ void HGraphBuilder::HandlePropertyAssignment(Assignment* expr) {
 
   } else {
     // Keyed store.
-    CHECK_ALIVE(VisitForValue(prop->key()));
-    CHECK_ALIVE(VisitForValue(expr->value()));
+    VISIT_FOR_VALUE(prop->key());
+    VISIT_FOR_VALUE(expr->value());
     value = Pop();
     HValue* key = Pop();
     HValue* object = Pop();
@@ -3420,7 +3334,7 @@ void HGraphBuilder::HandleCompoundAssignment(Assignment* expr) {
   BinaryOperation* operation = expr->binary_operation();
 
   if (var != NULL) {
-    CHECK_ALIVE(VisitForValue(operation));
+    VISIT_FOR_VALUE(operation);
 
     if (var->is_global()) {
       HandleGlobalVariableAssignment(var,
@@ -3437,7 +3351,7 @@ void HGraphBuilder::HandleCompoundAssignment(Assignment* expr) {
       AddInstruction(instr);
       if (instr->HasSideEffects()) AddSimulate(expr->AssignmentId());
     } else {
-      return Bailout("compound assignment to lookup slot");
+      BAILOUT("compound assignment to lookup slot");
     }
     ast_context()->ReturnValue(Pop());
 
@@ -3446,7 +3360,7 @@ void HGraphBuilder::HandleCompoundAssignment(Assignment* expr) {
 
     if (prop->key()->IsPropertyName()) {
       // Named property.
-      CHECK_ALIVE(VisitForValue(prop->obj()));
+      VISIT_FOR_VALUE(prop->obj());
       HValue* obj = Top();
 
       HInstruction* load = NULL;
@@ -3460,7 +3374,7 @@ void HGraphBuilder::HandleCompoundAssignment(Assignment* expr) {
       PushAndAdd(load);
       if (load->HasSideEffects()) AddSimulate(expr->CompoundLoadId());
 
-      CHECK_ALIVE(VisitForValue(expr->value()));
+      VISIT_FOR_VALUE(expr->value());
       HValue* right = Pop();
       HValue* left = Pop();
 
@@ -3478,8 +3392,8 @@ void HGraphBuilder::HandleCompoundAssignment(Assignment* expr) {
 
     } else {
       // Keyed property.
-      CHECK_ALIVE(VisitForValue(prop->obj()));
-      CHECK_ALIVE(VisitForValue(prop->key()));
+      VISIT_FOR_VALUE(prop->obj());
+      VISIT_FOR_VALUE(prop->key());
       HValue* obj = environment()->ExpressionStackAt(1);
       HValue* key = environment()->ExpressionStackAt(0);
 
@@ -3487,7 +3401,7 @@ void HGraphBuilder::HandleCompoundAssignment(Assignment* expr) {
       PushAndAdd(load);
       if (load->HasSideEffects()) AddSimulate(expr->CompoundLoadId());
 
-      CHECK_ALIVE(VisitForValue(expr->value()));
+      VISIT_FOR_VALUE(expr->value());
       HValue* right = Pop();
       HValue* left = Pop();
 
@@ -3506,15 +3420,12 @@ void HGraphBuilder::HandleCompoundAssignment(Assignment* expr) {
     }
 
   } else {
-    return Bailout("invalid lhs in compound assignment");
+    BAILOUT("invalid lhs in compound assignment");
   }
 }
 
 
 void HGraphBuilder::VisitAssignment(Assignment* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   VariableProxy* proxy = expr->target()->AsVariableProxy();
   Variable* var = proxy->AsVariable();
   Property* prop = expr->target()->AsProperty();
@@ -3526,7 +3437,7 @@ void HGraphBuilder::VisitAssignment(Assignment* expr) {
   }
 
   if (var != NULL) {
-    if (proxy->IsArguments()) return Bailout("assignment to arguments");
+    if (proxy->IsArguments()) BAILOUT("assignment to arguments");
 
     // Handle the assignment.
     if (var->IsStackAllocated()) {
@@ -3540,14 +3451,14 @@ void HGraphBuilder::VisitAssignment(Assignment* expr) {
       if (rhs_var != NULL && rhs_var->IsStackAllocated()) {
         value = environment()->Lookup(rhs_var);
       } else {
-        CHECK_ALIVE(VisitForValue(expr->value()));
+        VISIT_FOR_VALUE(expr->value());
         value = Pop();
       }
       Bind(var, value);
       ast_context()->ReturnValue(value);
 
     } else if (var->IsContextSlot() && var->mode() != Variable::CONST) {
-      CHECK_ALIVE(VisitForValue(expr->value()));
+      VISIT_FOR_VALUE(expr->value());
       HValue* context = BuildContextChainWalk(var);
       int index = var->AsSlot()->index();
       HStoreContextSlot* instr =
@@ -3557,7 +3468,7 @@ void HGraphBuilder::VisitAssignment(Assignment* expr) {
       ast_context()->ReturnValue(Pop());
 
     } else if (var->is_global()) {
-      CHECK_ALIVE(VisitForValue(expr->value()));
+      VISIT_FOR_VALUE(expr->value());
       HandleGlobalVariableAssignment(var,
                                      Top(),
                                      expr->position(),
@@ -3565,26 +3476,23 @@ void HGraphBuilder::VisitAssignment(Assignment* expr) {
       ast_context()->ReturnValue(Pop());
 
     } else {
-      return Bailout("assignment to LOOKUP or const CONTEXT variable");
+      BAILOUT("assignment to LOOKUP or const CONTEXT variable");
     }
 
   } else if (prop != NULL) {
     HandlePropertyAssignment(expr);
   } else {
-    return Bailout("invalid left-hand side in assignment");
+    BAILOUT("invalid left-hand side in assignment");
   }
 }
 
 
 void HGraphBuilder::VisitThrow(Throw* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   // We don't optimize functions with invalid left-hand sides in
   // assignments, count operations, or for-in.  Consequently throw can
   // currently only occur in an effect context.
   ASSERT(ast_context()->IsEffect());
-  CHECK_ALIVE(VisitForValue(expr->exception()));
+  VISIT_FOR_VALUE(expr->exception());
 
   HValue* value = environment()->Pop();
   HThrow* instr = new(zone()) HThrow(value);
@@ -3832,7 +3740,7 @@ bool HGraphBuilder::TryArgumentsAccess(Property* expr) {
   } else {
     Push(graph()->GetArgumentsObject());
     VisitForValue(expr->key());
-    if (HasStackOverflow() || current_block() == NULL) return true;
+    if (HasStackOverflow()) return false;
     HValue* key = Pop();
     Drop(1);  // Arguments object.
     HInstruction* elements = AddInstruction(new(zone()) HArgumentsElements);
@@ -3847,14 +3755,12 @@ bool HGraphBuilder::TryArgumentsAccess(Property* expr) {
 
 
 void HGraphBuilder::VisitProperty(Property* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   expr->RecordTypeFeedback(oracle());
 
   if (TryArgumentsAccess(expr)) return;
+  CHECK_BAILOUT;
 
-  CHECK_ALIVE(VisitForValue(expr->obj()));
+  VISIT_FOR_VALUE(expr->obj());
 
   HInstruction* instr = NULL;
   if (expr->IsArrayLength()) {
@@ -3873,7 +3779,7 @@ void HGraphBuilder::VisitProperty(Property* expr) {
                                                   LAST_STRING_TYPE));
     instr = new(zone()) HStringLength(string);
   } else if (expr->IsStringAccess()) {
-    CHECK_ALIVE(VisitForValue(expr->key()));
+    VISIT_FOR_VALUE(expr->key());
     HValue* index = Pop();
     HValue* string = Pop();
     HStringCharCodeAt* char_code = BuildStringCharCodeAt(string, index);
@@ -3900,7 +3806,7 @@ void HGraphBuilder::VisitProperty(Property* expr) {
     }
 
   } else {
-    CHECK_ALIVE(VisitForValue(expr->key()));
+    VISIT_FOR_VALUE(expr->key());
 
     HValue* key = Pop();
     HValue* obj = Pop();
@@ -3961,11 +3867,10 @@ void HGraphBuilder::HandlePolymorphicCallNamed(Call* expr,
         PrintF("Trying to inline the polymorphic call to %s\n",
                *name->ToCString());
       }
-      if (FLAG_polymorphic_inlining && TryInline(expr)) {
-        // Trying to inline will signal that we should bailout from the
-        // entire compilation by setting stack overflow on the visitor.
-        if (HasStackOverflow()) return;
-      } else {
+      if (!FLAG_polymorphic_inlining || !TryInline(expr)) {
+        // Check for bailout, as trying to inline might fail due to bailout
+        // during hydrogen processing.
+        CHECK_BAILOUT;
         HCallConstantFunction* call =
             new(zone()) HCallConstantFunction(expr->target(), argument_count);
         call->set_position(expr->position());
@@ -4005,12 +3910,10 @@ void HGraphBuilder::HandlePolymorphicCallNamed(Call* expr,
   // even without predecessors to the join block, we set it as the exit
   // block and continue by adding instructions there.
   ASSERT(join != NULL);
+  set_current_block(join);
   if (join->HasPredecessor()) {
-    set_current_block(join);
     join->SetJoinId(expr->id());
     if (!ast_context()->IsEffect()) ast_context()->ReturnValue(Pop());
-  } else {
-    set_current_block(NULL);
   }
 }
 
@@ -4182,7 +4085,7 @@ bool HGraphBuilder::TryInline(Call* expr) {
     // Bail out if the inline function did, as we cannot residualize a call
     // instead.
     TraceInline(target, "inline graph construction failed");
-    return true;
+    return false;
   }
 
   // Update inlined nodes count.
@@ -4238,11 +4141,9 @@ bool HGraphBuilder::TryInline(Call* expr) {
     // flow to handle.
     set_current_block(NULL);
 
-  } else if (function_return()->HasPredecessor()) {
+  } else {
     function_return()->SetJoinId(expr->id());
     set_current_block(function_return());
-  } else {
-    set_current_block(NULL);
   }
 
   return true;
@@ -4368,10 +4269,10 @@ bool HGraphBuilder::TryCallApply(Call* expr) {
 
   // Found pattern f.apply(receiver, arguments).
   VisitForValue(prop->obj());
-  if (HasStackOverflow() || current_block() == NULL) return true;
+  if (HasStackOverflow()) return false;
   HValue* function = Pop();
   VisitForValue(args->at(0));
-  if (HasStackOverflow() || current_block() == NULL) return true;
+  if (HasStackOverflow()) return false;
   HValue* receiver = Pop();
   HInstruction* elements = AddInstruction(new(zone()) HArgumentsElements);
   HInstruction* length = AddInstruction(new(zone()) HArgumentsLength(elements));
@@ -4388,9 +4289,6 @@ bool HGraphBuilder::TryCallApply(Call* expr) {
 
 
 void HGraphBuilder::VisitCall(Call* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   Expression* callee = expr->expression();
   int argument_count = expr->arguments()->length() + 1;  // Plus receiver.
   HInstruction* call = NULL;
@@ -4399,16 +4297,17 @@ void HGraphBuilder::VisitCall(Call* expr) {
   if (prop != NULL) {
     if (!prop->key()->IsPropertyName()) {
       // Keyed function call.
-      CHECK_ALIVE(VisitForValue(prop->obj()));
+      VISIT_FOR_VALUE(prop->obj());
 
-      CHECK_ALIVE(VisitForValue(prop->key()));
+      VISIT_FOR_VALUE(prop->key());
       // Push receiver and key like the non-optimized code generator expects it.
       HValue* key = Pop();
       HValue* receiver = Pop();
       Push(key);
       Push(receiver);
 
-      CHECK_ALIVE(VisitExpressions(expr->arguments()));
+      VisitExpressions(expr->arguments());
+      CHECK_BAILOUT;
 
       HContext* context = new(zone()) HContext;
       AddInstruction(context);
@@ -4424,9 +4323,11 @@ void HGraphBuilder::VisitCall(Call* expr) {
     expr->RecordTypeFeedback(oracle());
 
     if (TryCallApply(expr)) return;
+    CHECK_BAILOUT;
 
-    CHECK_ALIVE(VisitForValue(prop->obj()));
-    CHECK_ALIVE(VisitExpressions(expr->arguments()));
+    VISIT_FOR_VALUE(prop->obj());
+    VisitExpressions(expr->arguments());
+    CHECK_BAILOUT;
 
     Handle<String> name = prop->key()->AsLiteral()->AsPropertyName();
 
@@ -4457,10 +4358,16 @@ void HGraphBuilder::VisitCall(Call* expr) {
       } else {
         AddCheckConstantFunction(expr, receiver, receiver_map, true);
 
-        if (TryInline(expr)) return;
-        call = PreProcessCall(
-            new(zone()) HCallConstantFunction(expr->target(),
-                                              argument_count));
+        if (TryInline(expr)) {
+          return;
+        } else {
+          // Check for bailout, as the TryInline call in the if condition above
+          // might return false due to bailout during hydrogen processing.
+          CHECK_BAILOUT;
+          call = PreProcessCall(
+              new(zone()) HCallConstantFunction(expr->target(),
+                                                argument_count));
+        }
       }
     } else if (types != NULL && types->length() > 1) {
       ASSERT(expr->check_type() == RECEIVER_MAP_CHECK);
@@ -4480,7 +4387,7 @@ void HGraphBuilder::VisitCall(Call* expr) {
 
     if (!global_call) {
       ++argument_count;
-      CHECK_ALIVE(VisitForValue(expr->expression()));
+      VISIT_FOR_VALUE(expr->expression());
     }
 
     if (global_call) {
@@ -4502,9 +4409,10 @@ void HGraphBuilder::VisitCall(Call* expr) {
         HGlobalObject* global_object = new(zone()) HGlobalObject(context);
         AddInstruction(context);
         PushAndAdd(global_object);
-        CHECK_ALIVE(VisitExpressions(expr->arguments()));
+        VisitExpressions(expr->arguments());
+        CHECK_BAILOUT;
 
-        CHECK_ALIVE(VisitForValue(expr->expression()));
+        VISIT_FOR_VALUE(expr->expression());
         HValue* function = Pop();
         AddInstruction(new(zone()) HCheckFunction(function, expr->target()));
 
@@ -4518,14 +4426,21 @@ void HGraphBuilder::VisitCall(Call* expr) {
                IsGlobalObject());
         environment()->SetExpressionStackAt(receiver_index, global_receiver);
 
-        if (TryInline(expr)) return;
+        if (TryInline(expr)) {
+          return;
+        }
+        // Check for bailout, as trying to inline might fail due to bailout
+        // during hydrogen processing.
+        CHECK_BAILOUT;
+
         call = PreProcessCall(new(zone()) HCallKnownGlobal(expr->target(),
-                                                           argument_count));
+                                                   argument_count));
       } else {
         HContext* context = new(zone()) HContext;
         AddInstruction(context);
         PushAndAdd(new(zone()) HGlobalObject(context));
-        CHECK_ALIVE(VisitExpressions(expr->arguments()));
+        VisitExpressions(expr->arguments());
+        CHECK_BAILOUT;
 
         call = PreProcessCall(new(zone()) HCallGlobal(context,
                                               var->name(),
@@ -4538,7 +4453,8 @@ void HGraphBuilder::VisitCall(Call* expr) {
       AddInstruction(context);
       AddInstruction(global_object);
       PushAndAdd(new(zone()) HGlobalReceiver(global_object));
-      CHECK_ALIVE(VisitExpressions(expr->arguments()));
+      VisitExpressions(expr->arguments());
+      CHECK_BAILOUT;
 
       call = PreProcessCall(new(zone()) HCallFunction(context, argument_count));
     }
@@ -4550,13 +4466,11 @@ void HGraphBuilder::VisitCall(Call* expr) {
 
 
 void HGraphBuilder::VisitCallNew(CallNew* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   // The constructor function is also used as the receiver argument to the
   // JS construct call builtin.
-  CHECK_ALIVE(VisitForValue(expr->expression()));
-  CHECK_ALIVE(VisitExpressions(expr->arguments()));
+  VISIT_FOR_VALUE(expr->expression());
+  VisitExpressions(expr->arguments());
+  CHECK_BAILOUT;
 
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
@@ -4588,11 +4502,8 @@ const HGraphBuilder::InlineFunctionGenerator
 
 
 void HGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   if (expr->is_jsruntime()) {
-    return Bailout("call to a JavaScript runtime function");
+    BAILOUT("call to a JavaScript runtime function");
   }
 
   const Runtime::Function* function = expr->function();
@@ -4612,7 +4523,8 @@ void HGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
     (this->*generator)(expr);
   } else {
     ASSERT(function->intrinsic_type == Runtime::RUNTIME);
-    CHECK_ALIVE(VisitArgumentList(expr->arguments()));
+    VisitArgumentList(expr->arguments());
+    CHECK_BAILOUT;
 
     Handle<String> name = expr->name();
     int argument_count = expr->arguments()->length();
@@ -4626,12 +4538,9 @@ void HGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
 
 
 void HGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   Token::Value op = expr->op();
   if (op == Token::VOID) {
-    CHECK_ALIVE(VisitForEffect(expr->expression()));
+    VISIT_FOR_EFFECT(expr->expression());
     ast_context()->ReturnValue(graph()->GetConstantUndefined());
   } else if (op == Token::DELETE) {
     Property* prop = expr->expression()->AsProperty();
@@ -4639,7 +4548,7 @@ void HGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
     if (prop == NULL && var == NULL) {
       // Result of deleting non-property, non-variable reference is true.
       // Evaluate the subexpression for side effects.
-      CHECK_ALIVE(VisitForEffect(expr->expression()));
+      VISIT_FOR_EFFECT(expr->expression());
       ast_context()->ReturnValue(graph()->GetConstantTrue());
     } else if (var != NULL &&
                !var->is_global() &&
@@ -4654,17 +4563,17 @@ void HGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
         // to accesses on the arguments object.
         ast_context()->ReturnValue(graph()->GetConstantFalse());
       } else {
-        CHECK_ALIVE(VisitForValue(prop->obj()));
-        CHECK_ALIVE(VisitForValue(prop->key()));
+        VISIT_FOR_VALUE(prop->obj());
+        VISIT_FOR_VALUE(prop->key());
         HValue* key = Pop();
         HValue* obj = Pop();
         HDeleteProperty* instr = new(zone()) HDeleteProperty(obj, key);
         ast_context()->ReturnInstruction(instr, expr->id());
       }
     } else if (var->is_global()) {
-      return Bailout("delete with global variable");
+      BAILOUT("delete with global variable");
     } else {
-      return Bailout("delete with non-global variable");
+      BAILOUT("delete with non-global variable");
     }
   } else if (op == Token::NOT) {
     if (ast_context()->IsTest()) {
@@ -4675,42 +4584,34 @@ void HGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
     } else if (ast_context()->IsValue()) {
       HBasicBlock* materialize_false = graph()->CreateBasicBlock();
       HBasicBlock* materialize_true = graph()->CreateBasicBlock();
-      CHECK_BAILOUT(VisitForControl(expr->expression(),
-                                    materialize_false,
-                                    materialize_true));
-
-      if (materialize_false->HasPredecessor()) {
-        materialize_false->SetJoinId(expr->expression()->id());
-        set_current_block(materialize_false);
-        Push(graph()->GetConstantFalse());
-      } else {
-        materialize_false = NULL;
-      }
+      VISIT_FOR_CONTROL(expr->expression(),
+                        materialize_false,
+                        materialize_true);
+      materialize_false->SetJoinId(expr->expression()->id());
+      materialize_true->SetJoinId(expr->expression()->id());
 
-      if (materialize_true->HasPredecessor()) {
-        materialize_true->SetJoinId(expr->expression()->id());
-        set_current_block(materialize_true);
-        Push(graph()->GetConstantTrue());
-      } else {
-        materialize_true = NULL;
-      }
+      set_current_block(materialize_false);
+      Push(graph()->GetConstantFalse());
+      set_current_block(materialize_true);
+      Push(graph()->GetConstantTrue());
 
       HBasicBlock* join =
           CreateJoin(materialize_false, materialize_true, expr->id());
       set_current_block(join);
-      if (join != NULL) ast_context()->ReturnValue(Pop());
+      ast_context()->ReturnValue(Pop());
     } else {
       ASSERT(ast_context()->IsEffect());
       VisitForEffect(expr->expression());
     }
 
   } else if (op == Token::TYPEOF) {
-    CHECK_ALIVE(VisitForTypeOf(expr->expression()));
+    VisitForTypeOf(expr->expression());
+    if (HasStackOverflow()) return;
     HValue* value = Pop();
     ast_context()->ReturnInstruction(new(zone()) HTypeof(value), expr->id());
 
   } else {
-    CHECK_ALIVE(VisitForValue(expr->expression()));
+    VISIT_FOR_VALUE(expr->expression());
     HValue* value = Pop();
     HInstruction* instr = NULL;
     switch (op) {
@@ -4724,7 +4625,7 @@ void HGraphBuilder::VisitUnaryOperation(UnaryOperation* expr) {
         instr = new(zone()) HMul(value, graph_->GetConstant1());
         break;
       default:
-        return Bailout("Value: unsupported unary operation");
+        BAILOUT("Value: unsupported unary operation");
         break;
     }
     ast_context()->ReturnInstruction(instr, expr->id());
@@ -4743,9 +4644,6 @@ HInstruction* HGraphBuilder::BuildIncrement(HValue* value, bool increment) {
 
 
 void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   Expression* target = expr->expression();
   VariableProxy* proxy = target->AsVariableProxy();
   Variable* var = proxy->AsVariable();
@@ -4754,7 +4652,7 @@ void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
   bool inc = expr->op() == Token::INC;
 
   if (var != NULL) {
-    CHECK_ALIVE(VisitForValue(target));
+    VISIT_FOR_VALUE(target);
 
     // Match the full code generator stack by simulating an extra stack
     // element for postfix operations in a non-effect context.
@@ -4779,7 +4677,7 @@ void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
       AddInstruction(instr);
       if (instr->HasSideEffects()) AddSimulate(expr->AssignmentId());
     } else {
-      return Bailout("lookup variable in count operation");
+      BAILOUT("lookup variable in count operation");
     }
     Drop(has_extra ? 2 : 1);
     ast_context()->ReturnValue(expr->is_postfix() ? before : after);
@@ -4795,7 +4693,7 @@ void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
       bool has_extra = expr->is_postfix() && !ast_context()->IsEffect();
       if (has_extra) Push(graph_->GetConstantUndefined());
 
-      CHECK_ALIVE(VisitForValue(prop->obj()));
+      VISIT_FOR_VALUE(prop->obj());
       HValue* obj = Top();
 
       HInstruction* load = NULL;
@@ -4836,8 +4734,8 @@ void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
       bool has_extra = expr->is_postfix() && !ast_context()->IsEffect();
       if (has_extra) Push(graph_->GetConstantUndefined());
 
-      CHECK_ALIVE(VisitForValue(prop->obj()));
-      CHECK_ALIVE(VisitForValue(prop->key()));
+      VISIT_FOR_VALUE(prop->obj());
+      VISIT_FOR_VALUE(prop->key());
       HValue* obj = environment()->ExpressionStackAt(1);
       HValue* key = environment()->ExpressionStackAt(0);
 
@@ -4868,7 +4766,7 @@ void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
     }
 
   } else {
-    return Bailout("invalid lhs in count operation");
+    BAILOUT("invalid lhs in count operation");
   }
 }
 
@@ -4888,21 +4786,10 @@ HStringCharCodeAt* HGraphBuilder::BuildStringCharCodeAt(HValue* string,
 HInstruction* HGraphBuilder::BuildBinaryOperation(BinaryOperation* expr,
                                                   HValue* left,
                                                   HValue* right) {
-  TypeInfo info = oracle()->BinaryType(expr);
   HInstruction* instr = NULL;
   switch (expr->op()) {
     case Token::ADD:
-      if (info.IsString()) {
-        AddInstruction(new(zone()) HCheckNonSmi(left));
-        AddInstruction(new(zone()) HCheckInstanceType(
-            left, FIRST_STRING_TYPE, LAST_STRING_TYPE));
-        AddInstruction(new(zone()) HCheckNonSmi(right));
-        AddInstruction(new(zone()) HCheckInstanceType(
-            right, FIRST_STRING_TYPE, LAST_STRING_TYPE));
-        instr = new(zone()) HStringAdd(left, right);
-      } else {
-        instr = new(zone()) HAdd(left, right);
-      }
+      instr = new(zone()) HAdd(left, right);
       break;
     case Token::SUB:
       instr = new(zone()) HSub(left, right);
@@ -4937,6 +4824,7 @@ HInstruction* HGraphBuilder::BuildBinaryOperation(BinaryOperation* expr,
     default:
       UNREACHABLE();
   }
+  TypeInfo info = oracle()->BinaryType(expr);
   // If we hit an uninitialized binary op stub we will get type info
   // for a smi operation. If one of the operands is a constant string
   // do not generate code assuming it is a smi operation.
@@ -4973,11 +4861,8 @@ static bool IsClassOfTest(CompareOperation* expr) {
 
 
 void HGraphBuilder::VisitBinaryOperation(BinaryOperation* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   if (expr->op() == Token::COMMA) {
-    CHECK_ALIVE(VisitForEffect(expr->left()));
+    VISIT_FOR_EFFECT(expr->left());
     // Visit the right subexpression in the same AST context as the entire
     // expression.
     Visit(expr->right());
@@ -4989,25 +4874,19 @@ void HGraphBuilder::VisitBinaryOperation(BinaryOperation* expr) {
       // Translate left subexpression.
       HBasicBlock* eval_right = graph()->CreateBasicBlock();
       if (is_logical_and) {
-        CHECK_BAILOUT(VisitForControl(expr->left(),
-                                      eval_right,
-                                      context->if_false()));
+        VISIT_FOR_CONTROL(expr->left(), eval_right, context->if_false());
       } else {
-        CHECK_BAILOUT(VisitForControl(expr->left(),
-                                      context->if_true(),
-                                      eval_right));
+        VISIT_FOR_CONTROL(expr->left(), context->if_true(), eval_right);
       }
+      eval_right->SetJoinId(expr->RightId());
 
       // Translate right subexpression by visiting it in the same AST
       // context as the entire expression.
-      if (eval_right->HasPredecessor()) {
-        eval_right->SetJoinId(expr->RightId());
-        set_current_block(eval_right);
-        Visit(expr->right());
-      }
+      set_current_block(eval_right);
+      Visit(expr->right());
 
     } else if (ast_context()->IsValue()) {
-      CHECK_ALIVE(VisitForValue(expr->left()));
+      VISIT_FOR_VALUE(expr->left());
       ASSERT(current_block() != NULL);
 
       // We need an extra block to maintain edge-split form.
@@ -5020,7 +4899,7 @@ void HGraphBuilder::VisitBinaryOperation(BinaryOperation* expr) {
 
       set_current_block(eval_right);
       Drop(1);  // Value of the left subexpression.
-      CHECK_BAILOUT(VisitForValue(expr->right()));
+      VISIT_FOR_VALUE(expr->right());
 
       HBasicBlock* join_block =
           CreateJoin(empty_block, current_block(), expr->id());
@@ -5034,42 +4913,33 @@ void HGraphBuilder::VisitBinaryOperation(BinaryOperation* expr) {
       // extra block to maintain edge-split form.
       HBasicBlock* empty_block = graph()->CreateBasicBlock();
       HBasicBlock* right_block = graph()->CreateBasicBlock();
+      HBasicBlock* join_block = graph()->CreateBasicBlock();
       if (is_logical_and) {
-        CHECK_BAILOUT(VisitForControl(expr->left(), right_block, empty_block));
+        VISIT_FOR_CONTROL(expr->left(), right_block, empty_block);
       } else {
-        CHECK_BAILOUT(VisitForControl(expr->left(), empty_block, right_block));
+        VISIT_FOR_CONTROL(expr->left(), empty_block, right_block);
       }
-
       // TODO(kmillikin): Find a way to fix this.  It's ugly that there are
       // actually two empty blocks (one here and one inserted by
       // TestContext::BuildBranch, and that they both have an HSimulate
       // though the second one is not a merge node, and that we really have
       // no good AST ID to put on that first HSimulate.
-      if (empty_block->HasPredecessor()) {
-        empty_block->SetJoinId(expr->id());
-      } else {
-        empty_block = NULL;
-      }
-
-      if (right_block->HasPredecessor()) {
-        right_block->SetJoinId(expr->RightId());
-        set_current_block(right_block);
-        CHECK_BAILOUT(VisitForEffect(expr->right()));
-        right_block = current_block();
-      } else {
-        right_block = NULL;
-      }
-
-      HBasicBlock* join_block =
-          CreateJoin(empty_block, right_block, expr->id());
+      empty_block->SetJoinId(expr->id());
+      right_block->SetJoinId(expr->RightId());
+      set_current_block(right_block);
+      VISIT_FOR_EFFECT(expr->right());
+
+      empty_block->Goto(join_block);
+      current_block()->Goto(join_block);
+      join_block->SetJoinId(expr->id());
       set_current_block(join_block);
       // We did not materialize any value in the predecessor environments,
       // so there is no need to handle it here.
     }
 
   } else {
-    CHECK_ALIVE(VisitForValue(expr->left()));
-    CHECK_ALIVE(VisitForValue(expr->right()));
+    VISIT_FOR_VALUE(expr->left());
+    VISIT_FOR_VALUE(expr->right());
 
     HValue* right = Pop();
     HValue* left = Pop();
@@ -5108,12 +4978,9 @@ Representation HGraphBuilder::ToRepresentation(TypeInfo info) {
 
 
 void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
   if (IsClassOfTest(expr)) {
     CallRuntime* call = expr->left()->AsCallRuntime();
-    CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+    VISIT_FOR_VALUE(call->arguments()->at(0));
     HValue* value = Pop();
     Literal* literal = expr->right()->AsLiteral();
     Handle<String> rhs = Handle<String>::cast(literal->handle());
@@ -5129,7 +4996,8 @@ void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
   if ((expr->op() == Token::EQ || expr->op() == Token::EQ_STRICT) &&
       left_unary != NULL && left_unary->op() == Token::TYPEOF &&
       right_literal != NULL && right_literal->handle()->IsString()) {
-    CHECK_ALIVE(VisitForTypeOf(left_unary->expression()));
+    VisitForTypeOf(left_unary->expression());
+    if (HasStackOverflow()) return;
     HValue* left = Pop();
     HInstruction* instr = new(zone()) HTypeofIs(left,
         Handle<String>::cast(right_literal->handle()));
@@ -5138,8 +5006,8 @@ void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
     return;
   }
 
-  CHECK_ALIVE(VisitForValue(expr->left()));
-  CHECK_ALIVE(VisitForValue(expr->right()));
+  VISIT_FOR_VALUE(expr->left());
+  VISIT_FOR_VALUE(expr->right());
 
   HValue* right = Pop();
   HValue* left = Pop();
@@ -5184,7 +5052,7 @@ void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
       instr = new(zone()) HInstanceOfKnownGlobal(left, target);
     }
   } else if (op == Token::IN) {
-    return Bailout("Unsupported comparison: in");
+    BAILOUT("Unsupported comparison: in");
   } else if (type_info.IsNonPrimitive()) {
     switch (op) {
       case Token::EQ:
@@ -5197,7 +5065,7 @@ void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
         break;
       }
       default:
-        return Bailout("Unsupported non-primitive compare");
+        BAILOUT("Unsupported non-primitive compare");
         break;
     }
   } else {
@@ -5212,10 +5080,7 @@ void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
 
 
 void HGraphBuilder::VisitCompareToNull(CompareToNull* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  CHECK_ALIVE(VisitForValue(expr->expression()));
+  VISIT_FOR_VALUE(expr->expression());
 
   HValue* value = Pop();
   HIsNull* compare = new(zone()) HIsNull(value, expr->is_strict());
@@ -5224,10 +5089,7 @@ void HGraphBuilder::VisitCompareToNull(CompareToNull* expr) {
 
 
 void HGraphBuilder::VisitThisFunction(ThisFunction* expr) {
-  ASSERT(!HasStackOverflow());
-  ASSERT(current_block() != NULL);
-  ASSERT(current_block()->HasPredecessor());
-  return Bailout("ThisFunction");
+  BAILOUT("ThisFunction");
 }
 
 
@@ -5242,7 +5104,7 @@ void HGraphBuilder::VisitDeclaration(Declaration* decl) {
       (slot != NULL && slot->type() == Slot::LOOKUP) ||
       decl->mode() == Variable::CONST ||
       decl->fun() != NULL) {
-    return Bailout("unsupported declaration");
+    BAILOUT("unsupported declaration");
   }
 }
 
@@ -5251,7 +5113,7 @@ void HGraphBuilder::VisitDeclaration(Declaration* decl) {
 // Support for types.
 void HGraphBuilder::GenerateIsSmi(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HIsSmi* result = new(zone()) HIsSmi(value);
   ast_context()->ReturnInstruction(result, call->id());
@@ -5260,7 +5122,7 @@ void HGraphBuilder::GenerateIsSmi(CallRuntime* call) {
 
 void HGraphBuilder::GenerateIsSpecObject(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HHasInstanceType* result =
       new(zone()) HHasInstanceType(value, FIRST_JS_OBJECT_TYPE, LAST_TYPE);
@@ -5270,7 +5132,7 @@ void HGraphBuilder::GenerateIsSpecObject(CallRuntime* call) {
 
 void HGraphBuilder::GenerateIsFunction(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HHasInstanceType* result =
       new(zone()) HHasInstanceType(value, JS_FUNCTION_TYPE);
@@ -5280,7 +5142,7 @@ void HGraphBuilder::GenerateIsFunction(CallRuntime* call) {
 
 void HGraphBuilder::GenerateHasCachedArrayIndex(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HHasCachedArrayIndex* result = new(zone()) HHasCachedArrayIndex(value);
   ast_context()->ReturnInstruction(result, call->id());
@@ -5289,7 +5151,7 @@ void HGraphBuilder::GenerateHasCachedArrayIndex(CallRuntime* call) {
 
 void HGraphBuilder::GenerateIsArray(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HHasInstanceType* result = new(zone()) HHasInstanceType(value, JS_ARRAY_TYPE);
   ast_context()->ReturnInstruction(result, call->id());
@@ -5298,7 +5160,7 @@ void HGraphBuilder::GenerateIsArray(CallRuntime* call) {
 
 void HGraphBuilder::GenerateIsRegExp(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HHasInstanceType* result =
       new(zone()) HHasInstanceType(value, JS_REGEXP_TYPE);
@@ -5308,7 +5170,7 @@ void HGraphBuilder::GenerateIsRegExp(CallRuntime* call) {
 
 void HGraphBuilder::GenerateIsObject(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HIsObject* test = new(zone()) HIsObject(value);
   ast_context()->ReturnInstruction(test, call->id());
@@ -5316,19 +5178,18 @@ void HGraphBuilder::GenerateIsObject(CallRuntime* call) {
 
 
 void HGraphBuilder::GenerateIsNonNegativeSmi(CallRuntime* call) {
-  return Bailout("inlined runtime function: IsNonNegativeSmi");
+  BAILOUT("inlined runtime function: IsNonNegativeSmi");
 }
 
 
 void HGraphBuilder::GenerateIsUndetectableObject(CallRuntime* call) {
-  return Bailout("inlined runtime function: IsUndetectableObject");
+  BAILOUT("inlined runtime function: IsUndetectableObject");
 }
 
 
 void HGraphBuilder::GenerateIsStringWrapperSafeForDefaultValueOf(
     CallRuntime* call) {
-  return Bailout(
-      "inlined runtime function: IsStringWrapperSafeForDefaultValueOf");
+  BAILOUT("inlined runtime function: IsStringWrapperSafeForDefaultValueOf");
 }
 
 
@@ -5357,7 +5218,7 @@ void HGraphBuilder::GenerateArgumentsLength(CallRuntime* call) {
 
 void HGraphBuilder::GenerateArguments(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* index = Pop();
   HInstruction* elements = AddInstruction(new(zone()) HArgumentsElements);
   HInstruction* length = AddInstruction(new(zone()) HArgumentsLength(elements));
@@ -5371,13 +5232,13 @@ void HGraphBuilder::GenerateArguments(CallRuntime* call) {
 void HGraphBuilder::GenerateClassOf(CallRuntime* call) {
   // The special form detected by IsClassOfTest is detected before we get here
   // and does not cause a bailout.
-  return Bailout("inlined runtime function: ClassOf");
+  BAILOUT("inlined runtime function: ClassOf");
 }
 
 
 void HGraphBuilder::GenerateValueOf(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HValueOf* result = new(zone()) HValueOf(value);
   ast_context()->ReturnInstruction(result, call->id());
@@ -5385,15 +5246,15 @@ void HGraphBuilder::GenerateValueOf(CallRuntime* call) {
 
 
 void HGraphBuilder::GenerateSetValueOf(CallRuntime* call) {
-  return Bailout("inlined runtime function: SetValueOf");
+  BAILOUT("inlined runtime function: SetValueOf");
 }
 
 
 // Fast support for charCodeAt(n).
 void HGraphBuilder::GenerateStringCharCodeAt(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 2);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
+  VISIT_FOR_VALUE(call->arguments()->at(1));
   HValue* index = Pop();
   HValue* string = Pop();
   HStringCharCodeAt* result = BuildStringCharCodeAt(string, index);
@@ -5404,7 +5265,7 @@ void HGraphBuilder::GenerateStringCharCodeAt(CallRuntime* call) {
 // Fast support for string.charAt(n) and string[n].
 void HGraphBuilder::GenerateStringCharFromCode(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* char_code = Pop();
   HStringCharFromCode* result = new(zone()) HStringCharFromCode(char_code);
   ast_context()->ReturnInstruction(result, call->id());
@@ -5414,8 +5275,8 @@ void HGraphBuilder::GenerateStringCharFromCode(CallRuntime* call) {
 // Fast support for string.charAt(n) and string[n].
 void HGraphBuilder::GenerateStringCharAt(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 2);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
+  VISIT_FOR_VALUE(call->arguments()->at(1));
   HValue* index = Pop();
   HValue* string = Pop();
   HStringCharCodeAt* char_code = BuildStringCharCodeAt(string, index);
@@ -5428,8 +5289,8 @@ void HGraphBuilder::GenerateStringCharAt(CallRuntime* call) {
 // Fast support for object equality testing.
 void HGraphBuilder::GenerateObjectEquals(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 2);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
+  VISIT_FOR_VALUE(call->arguments()->at(1));
   HValue* right = Pop();
   HValue* left = Pop();
   HCompareJSObjectEq* result = new(zone()) HCompareJSObjectEq(left, right);
@@ -5445,14 +5306,15 @@ void HGraphBuilder::GenerateLog(CallRuntime* call) {
 
 // Fast support for Math.random().
 void HGraphBuilder::GenerateRandomHeapNumber(CallRuntime* call) {
-  return Bailout("inlined runtime function: RandomHeapNumber");
+  BAILOUT("inlined runtime function: RandomHeapNumber");
 }
 
 
 // Fast support for StringAdd.
 void HGraphBuilder::GenerateStringAdd(CallRuntime* call) {
   ASSERT_EQ(2, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result = new(zone()) HCallStub(context, CodeStub::StringAdd, 2);
@@ -5464,7 +5326,8 @@ void HGraphBuilder::GenerateStringAdd(CallRuntime* call) {
 // Fast support for SubString.
 void HGraphBuilder::GenerateSubString(CallRuntime* call) {
   ASSERT_EQ(3, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result = new(zone()) HCallStub(context, CodeStub::SubString, 3);
@@ -5476,7 +5339,8 @@ void HGraphBuilder::GenerateSubString(CallRuntime* call) {
 // Fast support for StringCompare.
 void HGraphBuilder::GenerateStringCompare(CallRuntime* call) {
   ASSERT_EQ(2, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result =
@@ -5489,7 +5353,8 @@ void HGraphBuilder::GenerateStringCompare(CallRuntime* call) {
 // Support for direct calls from JavaScript to native RegExp code.
 void HGraphBuilder::GenerateRegExpExec(CallRuntime* call) {
   ASSERT_EQ(4, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result = new(zone()) HCallStub(context, CodeStub::RegExpExec, 4);
@@ -5501,7 +5366,8 @@ void HGraphBuilder::GenerateRegExpExec(CallRuntime* call) {
 // Construct a RegExp exec result with two in-object properties.
 void HGraphBuilder::GenerateRegExpConstructResult(CallRuntime* call) {
   ASSERT_EQ(3, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result =
@@ -5513,14 +5379,15 @@ void HGraphBuilder::GenerateRegExpConstructResult(CallRuntime* call) {
 
 // Support for fast native caches.
 void HGraphBuilder::GenerateGetFromCache(CallRuntime* call) {
-  return Bailout("inlined runtime function: GetFromCache");
+  BAILOUT("inlined runtime function: GetFromCache");
 }
 
 
 // Fast support for number to string.
 void HGraphBuilder::GenerateNumberToString(CallRuntime* call) {
   ASSERT_EQ(1, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result =
@@ -5534,35 +5401,21 @@ void HGraphBuilder::GenerateNumberToString(CallRuntime* call) {
 // indices. This should only be used if the indices are known to be
 // non-negative and within bounds of the elements array at the call site.
 void HGraphBuilder::GenerateSwapElements(CallRuntime* call) {
-  return Bailout("inlined runtime function: SwapElements");
+  BAILOUT("inlined runtime function: SwapElements");
 }
 
 
 // Fast call for custom callbacks.
 void HGraphBuilder::GenerateCallFunction(CallRuntime* call) {
-  // 1 ~ The function to call is not itself an argument to the call.
-  int arg_count = call->arguments()->length() - 1;
-  ASSERT(arg_count >= 1);  // There's always at least a receiver.
-
-  for (int i = 0; i < arg_count; ++i) {
-    CHECK_ALIVE(VisitArgument(call->arguments()->at(i)));
-  }
-  CHECK_ALIVE(VisitForValue(call->arguments()->last()));
-  HValue* function = Pop();
-  HContext* context = new HContext;
-  AddInstruction(context);
-  HInvokeFunction* result =
-      new(zone()) HInvokeFunction(context, function, arg_count);
-  Drop(arg_count);
-  ast_context()->ReturnInstruction(result, call->id());
+  BAILOUT("inlined runtime function: CallFunction");
 }
 
 
 // Fast call to math functions.
 void HGraphBuilder::GenerateMathPow(CallRuntime* call) {
   ASSERT_EQ(2, call->arguments()->length());
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
+  VISIT_FOR_VALUE(call->arguments()->at(1));
   HValue* right = Pop();
   HValue* left = Pop();
   HPower* result = new(zone()) HPower(left, right);
@@ -5572,7 +5425,8 @@ void HGraphBuilder::GenerateMathPow(CallRuntime* call) {
 
 void HGraphBuilder::GenerateMathSin(CallRuntime* call) {
   ASSERT_EQ(1, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result =
@@ -5585,7 +5439,8 @@ void HGraphBuilder::GenerateMathSin(CallRuntime* call) {
 
 void HGraphBuilder::GenerateMathCos(CallRuntime* call) {
   ASSERT_EQ(1, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result =
@@ -5598,7 +5453,8 @@ void HGraphBuilder::GenerateMathCos(CallRuntime* call) {
 
 void HGraphBuilder::GenerateMathLog(CallRuntime* call) {
   ASSERT_EQ(1, call->arguments()->length());
-  CHECK_ALIVE(VisitArgumentList(call->arguments()));
+  VisitArgumentList(call->arguments());
+  CHECK_BAILOUT;
   HContext* context = new(zone()) HContext;
   AddInstruction(context);
   HCallStub* result =
@@ -5610,19 +5466,19 @@ void HGraphBuilder::GenerateMathLog(CallRuntime* call) {
 
 
 void HGraphBuilder::GenerateMathSqrt(CallRuntime* call) {
-  return Bailout("inlined runtime function: MathSqrt");
+  BAILOUT("inlined runtime function: MathSqrt");
 }
 
 
 // Check whether two RegExps are equivalent
 void HGraphBuilder::GenerateIsRegExpEquivalent(CallRuntime* call) {
-  return Bailout("inlined runtime function: IsRegExpEquivalent");
+  BAILOUT("inlined runtime function: IsRegExpEquivalent");
 }
 
 
 void HGraphBuilder::GenerateGetCachedArrayIndex(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 1);
-  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  VISIT_FOR_VALUE(call->arguments()->at(0));
   HValue* value = Pop();
   HGetCachedArrayIndex* result = new(zone()) HGetCachedArrayIndex(value);
   ast_context()->ReturnInstruction(result, call->id());
@@ -5630,12 +5486,15 @@ void HGraphBuilder::GenerateGetCachedArrayIndex(CallRuntime* call) {
 
 
 void HGraphBuilder::GenerateFastAsciiArrayJoin(CallRuntime* call) {
-  return Bailout("inlined runtime function: FastAsciiArrayJoin");
+  BAILOUT("inlined runtime function: FastAsciiArrayJoin");
 }
 
 
+#undef BAILOUT
 #undef CHECK_BAILOUT
-#undef CHECK_ALIVE
+#undef VISIT_FOR_EFFECT
+#undef VISIT_FOR_VALUE
+#undef ADD_TO_SUBGRAPH
 
 
 HEnvironment::HEnvironment(HEnvironment* outer,
diff --git a/src/ia32/assembler-ia32.h b/src/ia32/assembler-ia32.h
index 079dca75..46fda3b4 100644
--- a/src/ia32/assembler-ia32.h
+++ b/src/ia32/assembler-ia32.h
@@ -296,6 +296,7 @@ class Immediate BASE_EMBEDDED {
   RelocInfo::Mode rmode_;
 
   friend class Assembler;
+  friend class MacroAssembler;
 };
 
 
diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc
index 275e8e29..5d32095f 100644
--- a/src/ia32/code-stubs-ia32.cc
+++ b/src/ia32/code-stubs-ia32.cc
@@ -446,9 +446,6 @@ void TypeRecordingBinaryOpStub::Generate(MacroAssembler* masm) {
     case TRBinaryOpIC::ODDBALL:
       GenerateOddballStub(masm);
       break;
-    case TRBinaryOpIC::BOTH_STRING:
-      GenerateBothStringStub(masm);
-      break;
     case TRBinaryOpIC::STRING:
       GenerateStringStub(masm);
       break;
@@ -912,38 +909,6 @@ void TypeRecordingBinaryOpStub::GenerateStringStub(MacroAssembler* masm) {
 }
 
 
-void TypeRecordingBinaryOpStub::GenerateBothStringStub(MacroAssembler* masm) {
-  Label call_runtime;
-  ASSERT(operands_type_ == TRBinaryOpIC::BOTH_STRING);
-  ASSERT(op_ == Token::ADD);
-  // If both arguments are strings, call the string add stub.
-  // Otherwise, do a transition.
-
-  // Registers containing left and right operands respectively.
-  Register left = edx;
-  Register right = eax;
-
-  // Test if left operand is a string.
-  __ test(left, Immediate(kSmiTagMask));
-  __ j(zero, &call_runtime);
-  __ CmpObjectType(left, FIRST_NONSTRING_TYPE, ecx);
-  __ j(above_equal, &call_runtime);
-
-  // Test if right operand is a string.
-  __ test(right, Immediate(kSmiTagMask));
-  __ j(zero, &call_runtime);
-  __ CmpObjectType(right, FIRST_NONSTRING_TYPE, ecx);
-  __ j(above_equal, &call_runtime);
-
-  StringAddStub string_add_stub(NO_STRING_CHECK_IN_STUB);
-  GenerateRegisterArgsPush(masm);
-  __ TailCallStub(&string_add_stub);
-
-  __ bind(&call_runtime);
-  GenerateTypeTransition(masm);
-}
-
-
 void TypeRecordingBinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
   Label call_runtime;
   ASSERT(operands_type_ == TRBinaryOpIC::INT32);
@@ -1155,25 +1120,23 @@ void TypeRecordingBinaryOpStub::GenerateOddballStub(MacroAssembler* masm) {
     GenerateAddStrings(masm);
   }
 
-  Factory* factory = masm->isolate()->factory();
-
   // Convert odd ball arguments to numbers.
   NearLabel check, done;
-  __ cmp(edx, factory->undefined_value());
+  __ cmp(edx, FACTORY->undefined_value());
   __ j(not_equal, &check);
   if (Token::IsBitOp(op_)) {
     __ xor_(edx, Operand(edx));
   } else {
-    __ mov(edx, Immediate(factory->nan_value()));
+    __ mov(edx, Immediate(FACTORY->nan_value()));
   }
   __ jmp(&done);
   __ bind(&check);
-  __ cmp(eax, factory->undefined_value());
+  __ cmp(eax, FACTORY->undefined_value());
   __ j(not_equal, &done);
   if (Token::IsBitOp(op_)) {
     __ xor_(eax, Operand(eax));
   } else {
-    __ mov(eax, Immediate(factory->nan_value()));
+    __ mov(eax, Immediate(FACTORY->nan_value()));
   }
   __ bind(&done);
 
@@ -4084,7 +4047,12 @@ void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
   __ cmp(Operand::StaticVariable(js_entry_sp), Immediate(0));
   __ j(not_equal, &not_outermost_js);
   __ mov(Operand::StaticVariable(js_entry_sp), ebp);
+  __ push(Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+  Label cont;
+  __ jmp(&cont);
   __ bind(&not_outermost_js);
+  __ push(Immediate(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME)));
+  __ bind(&cont);
 #endif
 
   // Call a faked try-block that does the invoke.
@@ -4130,23 +4098,20 @@ void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
   __ call(Operand(edx));
 
   // Unlink this frame from the handler chain.
-  __ pop(Operand::StaticVariable(ExternalReference(
-      Isolate::k_handler_address,
-      masm->isolate())));
-  // Pop next_sp.
-  __ add(Operand(esp), Immediate(StackHandlerConstants::kSize - kPointerSize));
+  __ PopTryHandler();
 
+  __ bind(&exit);
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  // If current EBP value is the same as js_entry_sp value, it means that
-  // the current function is the outermost.
-  __ cmp(ebp, Operand::StaticVariable(js_entry_sp));
+  // Check if the current stack frame is marked as the outermost JS frame.
+  __ pop(ebx);
+  __ cmp(Operand(ebx),
+         Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
   __ j(not_equal, &not_outermost_js_2);
   __ mov(Operand::StaticVariable(js_entry_sp), Immediate(0));
   __ bind(&not_outermost_js_2);
 #endif
 
   // Restore the top frame descriptor from the stack.
-  __ bind(&exit);
   __ pop(Operand::StaticVariable(ExternalReference(
       Isolate::k_c_entry_fp_address,
       masm->isolate())));
diff --git a/src/ia32/code-stubs-ia32.h b/src/ia32/code-stubs-ia32.h
index cf736829..80a75cd8 100644
--- a/src/ia32/code-stubs-ia32.h
+++ b/src/ia32/code-stubs-ia32.h
@@ -153,7 +153,6 @@ class TypeRecordingBinaryOpStub: public CodeStub {
   void GenerateHeapNumberStub(MacroAssembler* masm);
   void GenerateOddballStub(MacroAssembler* masm);
   void GenerateStringStub(MacroAssembler* masm);
-  void GenerateBothStringStub(MacroAssembler* masm);
   void GenerateGenericStub(MacroAssembler* masm);
   void GenerateAddStrings(MacroAssembler* masm);
 
diff --git a/src/ia32/full-codegen-ia32.cc b/src/ia32/full-codegen-ia32.cc
index 69d5e773..5d153a81 100644
--- a/src/ia32/full-codegen-ia32.cc
+++ b/src/ia32/full-codegen-ia32.cc
@@ -192,7 +192,7 @@ void FullCodeGenerator::Generate(CompilationInfo* info) {
     __ lea(edx,
            Operand(ebp, StandardFrameConstants::kCallerSPOffset + offset));
     __ push(edx);
-    __ push(Immediate(Smi::FromInt(scope()->num_parameters())));
+    __ SafePush(Immediate(Smi::FromInt(scope()->num_parameters())));
     // Arguments to ArgumentsAccessStub:
     //   function, receiver address, parameter count.
     // The stub will rewrite receiver and parameter count if the previous
@@ -381,13 +381,20 @@ void FullCodeGenerator::EffectContext::Plug(Handle<Object> lit) const {
 
 void FullCodeGenerator::AccumulatorValueContext::Plug(
     Handle<Object> lit) const {
-  __ Set(result_register(), Immediate(lit));
+  if (lit->IsSmi()) {
+    __ SafeSet(result_register(), Immediate(lit));
+  } else {
+    __ Set(result_register(), Immediate(lit));
+  }
 }
 
 
 void FullCodeGenerator::StackValueContext::Plug(Handle<Object> lit) const {
-  // Immediates can be pushed directly.
-  __ push(Immediate(lit));
+  if (lit->IsSmi()) {
+    __ SafePush(Immediate(lit));
+  } else {
+    __ push(Immediate(lit));
+  }
 }
 
 
@@ -730,7 +737,7 @@ void FullCodeGenerator::EmitDeclaration(Variable* variable,
       }
       ASSERT(prop->key()->AsLiteral() != NULL &&
              prop->key()->AsLiteral()->handle()->IsSmi());
-      __ Set(ecx, Immediate(prop->key()->AsLiteral()->handle()));
+      __ SafeSet(ecx, Immediate(prop->key()->AsLiteral()->handle()));
 
       Handle<Code> ic = is_strict_mode()
           ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict()
@@ -1184,7 +1191,7 @@ void FullCodeGenerator::EmitDynamicLoadFromSlotFastCase(
           __ mov(edx,
                  ContextSlotOperandCheckExtensions(obj_proxy->var()->AsSlot(),
                                                    slow));
-          __ mov(eax, Immediate(key_literal->handle()));
+          __ SafeSet(eax, Immediate(key_literal->handle()));
           Handle<Code> ic =
               isolate()->builtins()->KeyedLoadIC_Initialize();
           EmitCallIC(ic, RelocInfo::CODE_TARGET);
@@ -1269,7 +1276,7 @@ void FullCodeGenerator::EmitVariableLoad(Variable* var) {
     ASSERT(key_literal->handle()->IsSmi());
 
     // Load the key.
-    __ mov(eax, Immediate(key_literal->handle()));
+    __ SafeSet(eax, Immediate(key_literal->handle()));
 
     // Do a keyed property load.
     Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize();
@@ -1540,7 +1547,7 @@ void FullCodeGenerator::VisitAssignment(Assignment* expr) {
           MemOperand slot_operand =
               EmitSlotSearch(obj_proxy->var()->AsSlot(), ecx);
           __ push(slot_operand);
-          __ mov(eax, Immediate(property->key()->AsLiteral()->handle()));
+          __ SafeSet(eax, Immediate(property->key()->AsLiteral()->handle()));
         } else {
           VisitForStackValue(property->obj());
           VisitForAccumulatorValue(property->key());
@@ -1553,7 +1560,7 @@ void FullCodeGenerator::VisitAssignment(Assignment* expr) {
           MemOperand slot_operand =
               EmitSlotSearch(obj_proxy->var()->AsSlot(), ecx);
           __ push(slot_operand);
-          __ push(Immediate(property->key()->AsLiteral()->handle()));
+          __ SafePush(Immediate(property->key()->AsLiteral()->handle()));
         } else {
           VisitForStackValue(property->obj());
           VisitForStackValue(property->key());
@@ -1632,6 +1639,7 @@ void FullCodeGenerator::VisitAssignment(Assignment* expr) {
 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) {
   SetSourcePosition(prop->position());
   Literal* key = prop->key()->AsLiteral();
+  ASSERT(!key->handle()->IsSmi());
   __ mov(ecx, Immediate(key->handle()));
   Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
   EmitCallIC(ic, RelocInfo::CODE_TARGET);
@@ -1796,7 +1804,7 @@ void FullCodeGenerator::EmitAssignment(Expression* expr, int bailout_ast_id) {
           EmitVariableLoad(prop->obj()->AsVariableProxy()->var());
         }
         __ mov(edx, eax);
-        __ Set(ecx, Immediate(prop->key()->AsLiteral()->handle()));
+        __ SafeSet(ecx, Immediate(prop->key()->AsLiteral()->handle()));
       } else {
         VisitForStackValue(prop->obj());
         VisitForAccumulatorValue(prop->key());
@@ -2307,7 +2315,7 @@ void FullCodeGenerator::VisitCallNew(CallNew* expr) {
   SetSourcePosition(expr->position());
 
   // Load function and argument count into edi and eax.
-  __ Set(eax, Immediate(arg_count));
+  __ SafeSet(eax, Immediate(arg_count));
   __ mov(edi, Operand(esp, arg_count * kPointerSize));
 
   Handle<Code> construct_builtin =
@@ -2647,7 +2655,7 @@ void FullCodeGenerator::EmitArguments(ZoneList<Expression*>* args) {
   // parameter count in eax.
   VisitForAccumulatorValue(args->at(0));
   __ mov(edx, eax);
-  __ mov(eax, Immediate(Smi::FromInt(scope()->num_parameters())));
+  __ SafeSet(eax, Immediate(Smi::FromInt(scope()->num_parameters())));
   ArgumentsAccessStub stub(ArgumentsAccessStub::READ_ELEMENT);
   __ CallStub(&stub);
   context()->Plug(eax);
@@ -2659,7 +2667,7 @@ void FullCodeGenerator::EmitArgumentsLength(ZoneList<Expression*>* args) {
 
   Label exit;
   // Get the number of formal parameters.
-  __ Set(eax, Immediate(Smi::FromInt(scope()->num_parameters())));
+  __ SafeSet(eax, Immediate(Smi::FromInt(scope()->num_parameters())));
 
   // Check if the calling frame is an arguments adaptor frame.
   __ mov(ebx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
@@ -3087,14 +3095,15 @@ void FullCodeGenerator::EmitMathSqrt(ZoneList<Expression*>* args) {
 void FullCodeGenerator::EmitCallFunction(ZoneList<Expression*>* args) {
   ASSERT(args->length() >= 2);
 
-  int arg_count = args->length() - 2;  // 2 ~ receiver and function.
-  for (int i = 0; i < arg_count + 1; ++i) {
-    VisitForStackValue(args->at(i));
+  int arg_count = args->length() - 2;  // For receiver and function.
+  VisitForStackValue(args->at(0));  // Receiver.
+  for (int i = 0; i < arg_count; i++) {
+    VisitForStackValue(args->at(i + 1));
   }
-  VisitForAccumulatorValue(args->last());  // Function.
+  VisitForAccumulatorValue(args->at(arg_count + 1));  // Function.
 
-  // InvokeFunction requires the function in edi. Move it in there.
-  __ mov(edi, result_register());
+  // InvokeFunction requires function in edi. Move it in there.
+  if (!result_register().is(edi)) __ mov(edi, result_register());
   ParameterCount count(arg_count);
   __ InvokeFunction(edi, count, CALL_FUNCTION);
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
@@ -3818,7 +3827,7 @@ void FullCodeGenerator::VisitCountOperation(CountOperation* expr) {
         MemOperand slot_operand =
             EmitSlotSearch(obj_proxy->var()->AsSlot(), ecx);
         __ push(slot_operand);
-        __ mov(eax, Immediate(prop->key()->AsLiteral()->handle()));
+        __ SafeSet(eax, Immediate(prop->key()->AsLiteral()->handle()));
       } else {
         VisitForStackValue(prop->obj());
         VisitForAccumulatorValue(prop->key());
@@ -4253,7 +4262,30 @@ void FullCodeGenerator::EmitCallIC(Handle<Code> ic, RelocInfo::Mode mode) {
     default:
       break;
   }
+
   __ call(ic, mode);
+
+  // Crankshaft doesn't need patching of inlined loads and stores.
+  // When compiling the snapshot we need to produce code that works
+  // with and without Crankshaft.
+  if (V8::UseCrankshaft() && !Serializer::enabled()) {
+    return;
+  }
+
+  // If we're calling a (keyed) load or store stub, we have to mark
+  // the call as containing no inlined code so we will not attempt to
+  // patch it.
+  switch (ic->kind()) {
+    case Code::LOAD_IC:
+    case Code::KEYED_LOAD_IC:
+    case Code::STORE_IC:
+    case Code::KEYED_STORE_IC:
+      __ nop();  // Signals no inlined code.
+      break;
+    default:
+      // Do nothing.
+      break;
+  }
 }
 
 
@@ -4274,6 +4306,7 @@ void FullCodeGenerator::EmitCallIC(Handle<Code> ic, JumpPatchSite* patch_site) {
     default:
       break;
   }
+
   __ call(ic, RelocInfo::CODE_TARGET);
   if (patch_site != NULL && patch_site->is_bound()) {
     patch_site->EmitPatchInfo();
diff --git a/src/ia32/ic-ia32.cc b/src/ia32/ic-ia32.cc
index 4106f010..b7af03c4 100644
--- a/src/ia32/ic-ia32.cc
+++ b/src/ia32/ic-ia32.cc
@@ -371,6 +371,12 @@ static void GenerateNumberDictionaryLoad(MacroAssembler* masm,
 }
 
 
+// The offset from the inlined patch site to the start of the
+// inlined load instruction.  It is 7 bytes (test eax, imm) plus
+// 6 bytes (jne slow_label).
+const int LoadIC::kOffsetToLoadInstruction = 13;
+
+
 void LoadIC::GenerateArrayLength(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- eax    : receiver
@@ -1267,6 +1273,172 @@ void LoadIC::GenerateMiss(MacroAssembler* masm) {
 }
 
 
+bool LoadIC::PatchInlinedLoad(Address address, Object* map, int offset) {
+  if (V8::UseCrankshaft()) return false;
+
+  // The address of the instruction following the call.
+  Address test_instruction_address =
+      address + Assembler::kCallTargetAddressOffset;
+  // If the instruction following the call is not a test eax, nothing
+  // was inlined.
+  if (*test_instruction_address != Assembler::kTestEaxByte) return false;
+
+  Address delta_address = test_instruction_address + 1;
+  // The delta to the start of the map check instruction.
+  int delta = *reinterpret_cast<int*>(delta_address);
+
+  // The map address is the last 4 bytes of the 7-byte
+  // operand-immediate compare instruction, so we add 3 to get the
+  // offset to the last 4 bytes.
+  Address map_address = test_instruction_address + delta + 3;
+  *(reinterpret_cast<Object**>(map_address)) = map;
+
+  // The offset is in the last 4 bytes of a six byte
+  // memory-to-register move instruction, so we add 2 to get the
+  // offset to the last 4 bytes.
+  Address offset_address =
+      test_instruction_address + delta + kOffsetToLoadInstruction + 2;
+  *reinterpret_cast<int*>(offset_address) = offset - kHeapObjectTag;
+  return true;
+}
+
+
+// One byte opcode for mov ecx,0xXXXXXXXX.
+// Marks inlined contextual loads using all kinds of cells. Generated
+// code has the hole check:
+//   mov reg, <cell>
+//   mov reg, (<cell>, value offset)
+//   cmp reg, <the hole>
+//   je  slow
+//   ;; use reg
+static const byte kMovEcxByte = 0xB9;
+
+// One byte opcode for mov edx,0xXXXXXXXX.
+// Marks inlined contextual loads using only "don't delete"
+// cells. Generated code doesn't have the hole check:
+//   mov reg, <cell>
+//   mov reg, (<cell>, value offset)
+//   ;; use reg
+static const byte kMovEdxByte = 0xBA;
+
+bool LoadIC::PatchInlinedContextualLoad(Address address,
+                                        Object* map,
+                                        Object* cell,
+                                        bool is_dont_delete) {
+  if (V8::UseCrankshaft()) return false;
+
+  // The address of the instruction following the call.
+  Address mov_instruction_address =
+      address + Assembler::kCallTargetAddressOffset;
+  // If the instruction following the call is not a mov ecx/edx,
+  // nothing was inlined.
+  byte b = *mov_instruction_address;
+  if (b != kMovEcxByte && b != kMovEdxByte) return false;
+  // If we don't have the hole check generated, we can only support
+  // "don't delete" cells.
+  if (b == kMovEdxByte && !is_dont_delete) return false;
+
+  Address delta_address = mov_instruction_address + 1;
+  // The delta to the start of the map check instruction.
+  int delta = *reinterpret_cast<int*>(delta_address);
+
+  // The map address is the last 4 bytes of the 7-byte
+  // operand-immediate compare instruction, so we add 3 to get the
+  // offset to the last 4 bytes.
+  Address map_address = mov_instruction_address + delta + 3;
+  *(reinterpret_cast<Object**>(map_address)) = map;
+
+  // The cell is in the last 4 bytes of a five byte mov reg, imm32
+  // instruction, so we add 1 to get the offset to the last 4 bytes.
+  Address offset_address =
+      mov_instruction_address + delta + kOffsetToLoadInstruction + 1;
+  *reinterpret_cast<Object**>(offset_address) = cell;
+  return true;
+}
+
+
+bool StoreIC::PatchInlinedStore(Address address, Object* map, int offset) {
+  if (V8::UseCrankshaft()) return false;
+
+  // The address of the instruction following the call.
+  Address test_instruction_address =
+      address + Assembler::kCallTargetAddressOffset;
+
+  // If the instruction following the call is not a test eax, nothing
+  // was inlined.
+  if (*test_instruction_address != Assembler::kTestEaxByte) return false;
+
+  // Extract the encoded deltas from the test eax instruction.
+  Address encoded_offsets_address = test_instruction_address + 1;
+  int encoded_offsets = *reinterpret_cast<int*>(encoded_offsets_address);
+  int delta_to_map_check = -(encoded_offsets & 0xFFFF);
+  int delta_to_record_write = encoded_offsets >> 16;
+
+  // Patch the map to check. The map address is the last 4 bytes of
+  // the 7-byte operand-immediate compare instruction.
+  Address map_check_address = test_instruction_address + delta_to_map_check;
+  Address map_address = map_check_address + 3;
+  *(reinterpret_cast<Object**>(map_address)) = map;
+
+  // Patch the offset in the store instruction. The offset is in the
+  // last 4 bytes of a six byte register-to-memory move instruction.
+  Address offset_address =
+      map_check_address + StoreIC::kOffsetToStoreInstruction + 2;
+  // The offset should have initial value (kMaxInt - 1), cleared value
+  // (-1) or we should be clearing the inlined version.
+  ASSERT(*reinterpret_cast<int*>(offset_address) == kMaxInt - 1 ||
+         *reinterpret_cast<int*>(offset_address) == -1 ||
+         (offset == 0 && map == HEAP->null_value()));
+  *reinterpret_cast<int*>(offset_address) = offset - kHeapObjectTag;
+
+  // Patch the offset in the write-barrier code. The offset is the
+  // last 4 bytes of a six byte lea instruction.
+  offset_address = map_check_address + delta_to_record_write + 2;
+  // The offset should have initial value (kMaxInt), cleared value
+  // (-1) or we should be clearing the inlined version.
+  ASSERT(*reinterpret_cast<int*>(offset_address) == kMaxInt ||
+         *reinterpret_cast<int*>(offset_address) == -1 ||
+         (offset == 0 && map == HEAP->null_value()));
+  *reinterpret_cast<int*>(offset_address) = offset - kHeapObjectTag;
+
+  return true;
+}
+
+
+static bool PatchInlinedMapCheck(Address address, Object* map) {
+  if (V8::UseCrankshaft()) return false;
+
+  Address test_instruction_address =
+      address + Assembler::kCallTargetAddressOffset;
+  // The keyed load has a fast inlined case if the IC call instruction
+  // is immediately followed by a test instruction.
+  if (*test_instruction_address != Assembler::kTestEaxByte) return false;
+
+  // Fetch the offset from the test instruction to the map cmp
+  // instruction.  This offset is stored in the last 4 bytes of the 5
+  // byte test instruction.
+  Address delta_address = test_instruction_address + 1;
+  int delta = *reinterpret_cast<int*>(delta_address);
+  // Compute the map address.  The map address is in the last 4 bytes
+  // of the 7-byte operand-immediate compare instruction, so we add 3
+  // to the offset to get the map address.
+  Address map_address = test_instruction_address + delta + 3;
+  // Patch the map check.
+  *(reinterpret_cast<Object**>(map_address)) = map;
+  return true;
+}
+
+
+bool KeyedLoadIC::PatchInlinedLoad(Address address, Object* map) {
+  return PatchInlinedMapCheck(address, map);
+}
+
+
+bool KeyedStoreIC::PatchInlinedStore(Address address, Object* map) {
+  return PatchInlinedMapCheck(address, map);
+}
+
+
 void KeyedLoadIC::GenerateMiss(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- eax    : key
@@ -1347,6 +1519,12 @@ void StoreIC::GenerateMiss(MacroAssembler* masm) {
 }
 
 
+// The offset from the inlined patch site to the start of the inlined
+// store instruction.  It is 7 bytes (test reg, imm) plus 6 bytes (jne
+// slow_label).
+const int StoreIC::kOffsetToStoreInstruction = 13;
+
+
 void StoreIC::GenerateArrayLength(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- eax    : value
diff --git a/src/ia32/lithium-codegen-ia32.cc b/src/ia32/lithium-codegen-ia32.cc
index 46c71e8b..0f96f78c 100644
--- a/src/ia32/lithium-codegen-ia32.cc
+++ b/src/ia32/lithium-codegen-ia32.cc
@@ -77,7 +77,7 @@ bool LCodeGen::GenerateCode() {
 
 void LCodeGen::FinishCode(Handle<Code> code) {
   ASSERT(is_done());
-  code->set_stack_slots(GetStackSlotCount());
+  code->set_stack_slots(StackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
   PopulateDeoptimizationData(code);
   Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(code);
@@ -132,7 +132,7 @@ bool LCodeGen::GeneratePrologue() {
   __ push(edi);  // Callee's JS function.
 
   // Reserve space for the stack slots needed by the code.
-  int slots = GetStackSlotCount();
+  int slots = StackSlotCount();
   if (slots > 0) {
     if (FLAG_debug_code) {
       __ mov(Operand(eax), Immediate(slots));
@@ -254,7 +254,7 @@ bool LCodeGen::GenerateDeferredCode() {
 
 bool LCodeGen::GenerateSafepointTable() {
   ASSERT(is_done());
-  safepoints_.Emit(masm(), GetStackSlotCount());
+  safepoints_.Emit(masm(), StackSlotCount());
   return !is_aborted();
 }
 
@@ -386,7 +386,7 @@ void LCodeGen::AddToTranslation(Translation* translation,
     translation->StoreDoubleStackSlot(op->index());
   } else if (op->IsArgument()) {
     ASSERT(is_tagged);
-    int src_index = GetStackSlotCount() + op->index();
+    int src_index = StackSlotCount() + op->index();
     translation->StoreStackSlot(src_index);
   } else if (op->IsRegister()) {
     Register reg = ToRegister(op);
@@ -2057,7 +2057,7 @@ void LCodeGen::DoReturn(LReturn* instr) {
   }
   __ mov(esp, ebp);
   __ pop(ebp);
-  __ Ret((GetParameterCount() + 1) * kPointerSize, ecx);
+  __ Ret((ParameterCount() + 1) * kPointerSize, ecx);
 }
 
 
@@ -2493,7 +2493,7 @@ void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
   SafepointGenerator safepoint_generator(this,
                                          pointers,
                                          env->deoptimization_index());
-  ParameterCount actual(eax);
+  v8::internal::ParameterCount actual(eax);
   __ InvokeFunction(function, actual, CALL_FUNCTION, &safepoint_generator);
 }
 
@@ -2707,16 +2707,25 @@ void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {
   Register output_reg = ToRegister(instr->result());
   XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));
 
-  Label below_half, done;
   // xmm_scratch = 0.5
   ExternalReference one_half = ExternalReference::address_of_one_half();
   __ movdbl(xmm_scratch, Operand::StaticVariable(one_half));
 
-  __ ucomisd(xmm_scratch, input_reg);
-  __ j(above, &below_half);
   // input = input + 0.5
   __ addsd(input_reg, xmm_scratch);
 
+  // We need to return -0 for the input range [-0.5, 0[, otherwise
+  // compute Math.floor(value + 0.5).
+  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+    __ ucomisd(input_reg, xmm_scratch);
+    DeoptimizeIf(below_equal, instr->environment());
+  } else {
+    // If we don't need to bailout on -0, we check only bailout
+    // on negative inputs.
+    __ xorpd(xmm_scratch, xmm_scratch);  // Zero the register.
+    __ ucomisd(input_reg, xmm_scratch);
+    DeoptimizeIf(below, instr->environment());
+  }
 
   // Compute Math.floor(value + 0.5).
   // Use truncating instruction (OK because input is positive).
@@ -2725,27 +2734,6 @@ void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {
   // Overflow is signalled with minint.
   __ cmp(output_reg, 0x80000000u);
   DeoptimizeIf(equal, instr->environment());
-  __ jmp(&done);
-
-  __ bind(&below_half);
-
-  // We return 0 for the input range [+0, 0.5[, or [-0.5, 0.5[ if
-  // we can ignore the difference between a result of -0 and +0.
-  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-    // If the sign is positive, we return +0.
-    __ movmskpd(output_reg, input_reg);
-    __ test(output_reg, Immediate(1));
-    DeoptimizeIf(not_zero, instr->environment());
-  } else {
-    // If the input is >= -0.5, we return +0.
-    __ mov(output_reg, Immediate(0xBF000000));
-    __ movd(xmm_scratch, Operand(output_reg));
-    __ cvtss2sd(xmm_scratch, xmm_scratch);
-    __ ucomisd(input_reg, xmm_scratch);
-    DeoptimizeIf(below, instr->environment());
-  }
-  __ Set(output_reg, Immediate(0));
-  __ bind(&done);
 }
 
 
@@ -2905,21 +2893,6 @@ void LCodeGen::DoUnaryMathOperation(LUnaryMathOperation* instr) {
 }
 
 
-void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
-  ASSERT(ToRegister(instr->context()).is(esi));
-  ASSERT(ToRegister(instr->function()).is(edi));
-  ASSERT(instr->HasPointerMap());
-  ASSERT(instr->HasDeoptimizationEnvironment());
-  LPointerMap* pointers = instr->pointer_map();
-  LEnvironment* env = instr->deoptimization_environment();
-  RecordPosition(pointers->position());
-  RegisterEnvironmentForDeoptimization(env);
-  SafepointGenerator generator(this, pointers, env->deoptimization_index());
-  ParameterCount count(instr->arity());
-  __ InvokeFunction(edi, count, CALL_FUNCTION, &generator);
-}
-
-
 void LCodeGen::DoCallKeyed(LCallKeyed* instr) {
   ASSERT(ToRegister(instr->context()).is(esi));
   ASSERT(ToRegister(instr->key()).is(ecx));
@@ -3323,22 +3296,6 @@ void LCodeGen::DoStringLength(LStringLength* instr) {
 }
 
 
-void LCodeGen::DoStringAdd(LStringAdd* instr) {
-  if (instr->left()->IsConstantOperand()) {
-    __ push(ToImmediate(instr->left()));
-  } else {
-    __ push(ToOperand(instr->left()));
-  }
-  if (instr->right()->IsConstantOperand()) {
-    __ push(ToImmediate(instr->right()));
-  } else {
-    __ push(ToOperand(instr->right()));
-  }
-  StringAddStub stub(NO_STRING_CHECK_IN_STUB);
-  CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr, RESTORE_CONTEXT);
-}
-
-
 void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
   LOperand* input = instr->InputAt(0);
   ASSERT(input->IsRegister() || input->IsStackSlot());
diff --git a/src/ia32/lithium-codegen-ia32.h b/src/ia32/lithium-codegen-ia32.h
index f8bbea31..6d42cd78 100644
--- a/src/ia32/lithium-codegen-ia32.h
+++ b/src/ia32/lithium-codegen-ia32.h
@@ -147,8 +147,8 @@ class LCodeGen BASE_EMBEDDED {
                        Register temporary,
                        Register temporary2);
 
-  int GetStackSlotCount() const { return chunk()->spill_slot_count(); }
-  int GetParameterCount() const { return scope()->num_parameters(); }
+  int StackSlotCount() const { return chunk()->spill_slot_count(); }
+  int ParameterCount() const { return scope()->num_parameters(); }
 
   void Abort(const char* format, ...);
   void Comment(const char* format, ...);
diff --git a/src/ia32/lithium-ia32.cc b/src/ia32/lithium-ia32.cc
index aa91a834..9ccd1897 100644
--- a/src/ia32/lithium-ia32.cc
+++ b/src/ia32/lithium-ia32.cc
@@ -71,21 +71,22 @@ void LOsrEntry::MarkSpilledDoubleRegister(int allocation_index,
 
 #ifdef DEBUG
 void LInstruction::VerifyCall() {
-  // Call instructions can use only fixed registers as temporaries and
-  // outputs because all registers are blocked by the calling convention.
-  // Inputs operands must use a fixed register or use-at-start policy or
-  // a non-register policy.
+  // Call instructions can use only fixed registers as
+  // temporaries and outputs because all registers
+  // are blocked by the calling convention.
+  // Inputs must use a fixed register.
   ASSERT(Output() == NULL ||
          LUnallocated::cast(Output())->HasFixedPolicy() ||
          !LUnallocated::cast(Output())->HasRegisterPolicy());
   for (UseIterator it(this); it.HasNext(); it.Advance()) {
-    LUnallocated* operand = LUnallocated::cast(it.Next());
-    ASSERT(operand->HasFixedPolicy() ||
-           operand->IsUsedAtStart());
+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
   }
   for (TempIterator it(this); it.HasNext(); it.Advance()) {
-    LUnallocated* operand = LUnallocated::cast(it.Next());
-    ASSERT(operand->HasFixedPolicy() ||!operand->HasRegisterPolicy());
+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
   }
 }
 #endif
@@ -302,15 +303,6 @@ void LStoreContextSlot::PrintDataTo(StringStream* stream) {
 }
 
 
-void LInvokeFunction::PrintDataTo(StringStream* stream) {
-  stream->Add("= ");
-  InputAt(0)->PrintTo(stream);
-  stream->Add(" ");
-  InputAt(1)->PrintTo(stream);
-  stream->Add(" #%d / ", arity());
-}
-
-
 void LCallKeyed::PrintDataTo(StringStream* stream) {
   stream->Add("[ecx] #%d / ", arity());
 }
@@ -1230,15 +1222,6 @@ LInstruction* LChunkBuilder::DoCallConstantFunction(
 }
 
 
-LInstruction* LChunkBuilder::DoInvokeFunction(HInvokeFunction* instr) {
-  LOperand* context = UseFixed(instr->context(), esi);
-  LOperand* function = UseFixed(instr->function(), edi);
-  argument_count_ -= instr->argument_count();
-  LInvokeFunction* result = new LInvokeFunction(context, function);
-  return MarkAsCall(DefineFixed(result, eax), instr, CANNOT_DEOPTIMIZE_EAGERLY);
-}
-
-
 LInstruction* LChunkBuilder::DoUnaryMathOperation(HUnaryMathOperation* instr) {
   BuiltinFunctionId op = instr->op();
   if (op == kMathLog) {
@@ -2019,13 +2002,6 @@ LInstruction* LChunkBuilder::DoStoreNamedGeneric(HStoreNamedGeneric* instr) {
 }
 
 
-LInstruction* LChunkBuilder::DoStringAdd(HStringAdd* instr) {
-  LOperand* left = UseOrConstantAtStart(instr->left());
-  LOperand* right = UseOrConstantAtStart(instr->right());
-  return MarkAsCall(DefineFixed(new LStringAdd(left, right), eax), instr);
-}
-
-
 LInstruction* LChunkBuilder::DoStringCharCodeAt(HStringCharCodeAt* instr) {
   LOperand* string = UseRegister(instr->string());
   LOperand* index = UseRegisterOrConstant(instr->index());
@@ -2070,8 +2046,7 @@ LInstruction* LChunkBuilder::DoFunctionLiteral(HFunctionLiteral* instr) {
 
 LInstruction* LChunkBuilder::DoDeleteProperty(HDeleteProperty* instr) {
   LDeleteProperty* result =
-      new LDeleteProperty(UseAtStart(instr->object()),
-                          UseOrConstantAtStart(instr->key()));
+      new LDeleteProperty(Use(instr->object()), UseOrConstant(instr->key()));
   return MarkAsCall(DefineFixed(result, eax), instr);
 }
 
diff --git a/src/ia32/lithium-ia32.h b/src/ia32/lithium-ia32.h
index 76c90be8..9ace8f86 100644
--- a/src/ia32/lithium-ia32.h
+++ b/src/ia32/lithium-ia32.h
@@ -39,7 +39,6 @@ namespace internal {
 // Forward declarations.
 class LCodeGen;
 
-
 #define LITHIUM_ALL_INSTRUCTION_LIST(V)         \
   V(ControlInstruction)                         \
   V(Call)                                       \
@@ -107,7 +106,6 @@ class LCodeGen;
   V(InstanceOfAndBranch)                        \
   V(InstanceOfKnownGlobal)                      \
   V(Integer32ToDouble)                          \
-  V(InvokeFunction)                             \
   V(IsNull)                                     \
   V(IsNullAndBranch)                            \
   V(IsObject)                                   \
@@ -156,7 +154,6 @@ class LCodeGen;
   V(StoreKeyedSpecializedArrayElement)          \
   V(StoreNamedField)                            \
   V(StoreNamedGeneric)                          \
-  V(StringAdd)                                  \
   V(StringCharCodeAt)                           \
   V(StringCharFromCode)                         \
   V(StringLength)                               \
@@ -1453,25 +1450,6 @@ class LCallConstantFunction: public LTemplateInstruction<1, 0, 0> {
 };
 
 
-class LInvokeFunction: public LTemplateInstruction<1, 2, 0> {
- public:
-  LInvokeFunction(LOperand* context, LOperand* function) {
-    inputs_[0] = context;
-    inputs_[1] = function;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
-  DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
-
-  LOperand* context() { return inputs_[0]; }
-  LOperand* function() { return inputs_[1]; }
-
-  virtual void PrintDataTo(StringStream* stream);
-
-  int arity() const { return hydrogen()->argument_count() - 1; }
-};
-
-
 class LCallKeyed: public LTemplateInstruction<1, 2, 0> {
  public:
   LCallKeyed(LOperand* context, LOperand* key) {
@@ -1791,21 +1769,6 @@ class LStoreKeyedGeneric: public LTemplateInstruction<0, 4, 0> {
 };
 
 
-class LStringAdd: public LTemplateInstruction<1, 2, 0> {
- public:
-  LStringAdd(LOperand* left, LOperand* right) {
-    inputs_[0] = left;
-    inputs_[1] = right;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add")
-  DECLARE_HYDROGEN_ACCESSOR(StringAdd)
-
-  LOperand* left() { return inputs_[0]; }
-  LOperand* right() { return inputs_[1]; }
-};
-
-
 class LStringCharCodeAt: public LTemplateInstruction<1, 2, 0> {
  public:
   LStringCharCodeAt(LOperand* string, LOperand* index) {
diff --git a/src/ia32/macro-assembler-ia32.cc b/src/ia32/macro-assembler-ia32.cc
index ad567bca..13394cbc 100644
--- a/src/ia32/macro-assembler-ia32.cc
+++ b/src/ia32/macro-assembler-ia32.cc
@@ -164,7 +164,7 @@ void MacroAssembler::DebugBreak() {
 
 void MacroAssembler::Set(Register dst, const Immediate& x) {
   if (x.is_zero()) {
-    xor_(dst, Operand(dst));  // shorter than mov
+    xor_(dst, Operand(dst));  // Shorter than mov.
   } else {
     mov(dst, x);
   }
@@ -176,6 +176,33 @@ void MacroAssembler::Set(const Operand& dst, const Immediate& x) {
 }
 
 
+bool MacroAssembler::IsUnsafeImmediate(const Immediate& x) {
+  static const int kMaxImmediateBits = 17;
+  if (x.rmode_ != RelocInfo::NONE) return false;
+  return !is_intn(x.x_, kMaxImmediateBits);
+}
+
+
+void MacroAssembler::SafeSet(Register dst, const Immediate& x) {
+  if (IsUnsafeImmediate(x) && jit_cookie() != 0) {
+    Set(dst, Immediate(x.x_ ^ jit_cookie()));
+    xor_(dst, jit_cookie());
+  } else {
+    Set(dst, x);
+  }
+}
+
+
+void MacroAssembler::SafePush(const Immediate& x) {
+  if (IsUnsafeImmediate(x) && jit_cookie() != 0) {
+    push(Immediate(x.x_ ^ jit_cookie()));
+    xor_(Operand(esp, 0), Immediate(jit_cookie()));
+  } else {
+    push(x);
+  }
+}
+
+
 void MacroAssembler::CmpObjectType(Register heap_object,
                                    InstanceType type,
                                    Register map) {
diff --git a/src/ia32/macro-assembler-ia32.h b/src/ia32/macro-assembler-ia32.h
index 69092726..b9862645 100644
--- a/src/ia32/macro-assembler-ia32.h
+++ b/src/ia32/macro-assembler-ia32.h
@@ -197,6 +197,11 @@ class MacroAssembler: public Assembler {
   void Set(Register dst, const Immediate& x);
   void Set(const Operand& dst, const Immediate& x);
 
+  // Support for constant splitting.
+  bool IsUnsafeImmediate(const Immediate& x);
+  void SafeSet(Register dst, const Immediate& x);
+  void SafePush(const Immediate& x);
+
   // Compare object type for heap object.
   // Incoming register is heap_object and outgoing register is map.
   void CmpObjectType(Register heap_object, InstanceType type, Register map);
diff --git a/src/ia32/regexp-macro-assembler-ia32.cc b/src/ia32/regexp-macro-assembler-ia32.cc
index 067f8c87..5b2f208d 100644
--- a/src/ia32/regexp-macro-assembler-ia32.cc
+++ b/src/ia32/regexp-macro-assembler-ia32.cc
@@ -662,7 +662,7 @@ void RegExpMacroAssemblerIA32::Fail() {
 }
 
 
-Handle<Object> RegExpMacroAssemblerIA32::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerIA32::GetCode(Handle<String> source) {
   // Finalize code - write the entry point code now we know how many
   // registers we need.
 
@@ -879,7 +879,7 @@ Handle<Object> RegExpMacroAssemblerIA32::GetCode(Handle<String> source) {
                                            Code::ComputeFlags(Code::REGEXP),
                                            masm_->CodeObject());
   PROFILE(masm_->isolate(), RegExpCodeCreateEvent(*code, *source));
-  return Handle<Object>::cast(code);
+  return Handle<HeapObject>::cast(code);
 }
 
 
diff --git a/src/ia32/regexp-macro-assembler-ia32.h b/src/ia32/regexp-macro-assembler-ia32.h
index 0af61f21..70606da1 100644
--- a/src/ia32/regexp-macro-assembler-ia32.h
+++ b/src/ia32/regexp-macro-assembler-ia32.h
@@ -80,7 +80,7 @@ class RegExpMacroAssemblerIA32: public NativeRegExpMacroAssembler {
   virtual void CheckPosition(int cp_offset, Label* on_outside_input);
   virtual bool CheckSpecialCharacterClass(uc16 type, Label* on_no_match);
   virtual void Fail();
-  virtual Handle<Object> GetCode(Handle<String> source);
+  virtual Handle<HeapObject> GetCode(Handle<String> source);
   virtual void GoTo(Label* label);
   virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
   virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
diff --git a/src/ic.cc b/src/ic.cc
index 22999227..99eb21fa 100644
--- a/src/ic.cc
+++ b/src/ic.cc
@@ -304,23 +304,54 @@ void CallICBase::Clear(Address address, Code* target) {
 }
 
 
+void KeyedLoadIC::ClearInlinedVersion(Address address) {
+  // Insert null as the map to check for to make sure the map check fails
+  // sending control flow to the IC instead of the inlined version.
+  PatchInlinedLoad(address, HEAP->null_value());
+}
+
+
 void KeyedLoadIC::Clear(Address address, Code* target) {
   if (target->ic_state() == UNINITIALIZED) return;
   // Make sure to also clear the map used in inline fast cases.  If we
   // do not clear these maps, cached code can keep objects alive
   // through the embedded maps.
+  ClearInlinedVersion(address);
   SetTargetAtAddress(address, initialize_stub());
 }
 
 
+void LoadIC::ClearInlinedVersion(Address address) {
+  // Reset the map check of the inlined inobject property load (if
+  // present) to guarantee failure by holding an invalid map (the null
+  // value).  The offset can be patched to anything.
+  Heap* heap = HEAP;
+  PatchInlinedLoad(address, heap->null_value(), 0);
+  PatchInlinedContextualLoad(address,
+                             heap->null_value(),
+                             heap->null_value(),
+                             true);
+}
+
+
 void LoadIC::Clear(Address address, Code* target) {
   if (target->ic_state() == UNINITIALIZED) return;
+  ClearInlinedVersion(address);
   SetTargetAtAddress(address, initialize_stub());
 }
 
 
+void StoreIC::ClearInlinedVersion(Address address) {
+  // Reset the map check of the inlined inobject property store (if
+  // present) to guarantee failure by holding an invalid map (the null
+  // value).  The offset can be patched to anything.
+  PatchInlinedStore(address, HEAP->null_value(), 0);
+}
+
+
 void StoreIC::Clear(Address address, Code* target) {
   if (target->ic_state() == UNINITIALIZED) return;
+  ClearInlinedVersion(address);
   SetTargetAtAddress(address,
       (target->extra_ic_state() == kStrictMode)
         ? initialize_stub_strict()
@@ -328,6 +359,21 @@ void StoreIC::Clear(Address address, Code* target) {
 }
 
 
+void KeyedStoreIC::ClearInlinedVersion(Address address) {
+  // Insert null as the elements map to check for.  This will make
+  // sure that the elements fast-case map check fails so that control
+  // flows to the IC instead of the inlined version.
+  PatchInlinedStore(address, HEAP->null_value());
+}
+
+
+void KeyedStoreIC::RestoreInlinedVersion(Address address) {
+  // Restore the fast-case elements map check so that the inlined
+  // version can be used again.
+  PatchInlinedStore(address, HEAP->fixed_array_map());
+}
+
+
 void KeyedStoreIC::Clear(Address address, Code* target) {
   if (target->ic_state() == UNINITIALIZED) return;
   SetTargetAtAddress(address,
@@ -827,6 +873,9 @@ MaybeObject* LoadIC::Load(State state,
 #endif
       if (state == PREMONOMORPHIC) {
         if (object->IsString()) {
+          Map* map = HeapObject::cast(*object)->map();
+          const int offset = String::kLengthOffset;
+          PatchInlinedLoad(address(), map, offset);
           set_target(isolate()->builtins()->builtin(
               Builtins::kLoadIC_StringLength));
         } else {
@@ -854,6 +903,9 @@ MaybeObject* LoadIC::Load(State state,
       if (FLAG_trace_ic) PrintF("[LoadIC : +#length /array]\n");
 #endif
       if (state == PREMONOMORPHIC) {
+        Map* map = HeapObject::cast(*object)->map();
+        const int offset = JSArray::kLengthOffset;
+        PatchInlinedLoad(address(), map, offset);
         set_target(isolate()->builtins()->builtin(
             Builtins::kLoadIC_ArrayLength));
       } else {
@@ -896,6 +948,63 @@ MaybeObject* LoadIC::Load(State state,
     LOG(isolate(), SuspectReadEvent(*name, *object));
   }
 
+  bool can_be_inlined_precheck =
+      FLAG_use_ic &&
+      lookup.IsProperty() &&
+      lookup.IsCacheable() &&
+      lookup.holder() == *object &&
+      !object->IsAccessCheckNeeded();
+
+  bool can_be_inlined =
+      can_be_inlined_precheck &&
+      state == PREMONOMORPHIC &&
+      lookup.type() == FIELD;
+
+  bool can_be_inlined_contextual =
+      can_be_inlined_precheck &&
+      state == UNINITIALIZED &&
+      lookup.holder()->IsGlobalObject() &&
+      lookup.type() == NORMAL;
+
+  if (can_be_inlined) {
+    Map* map = lookup.holder()->map();
+    // Property's index in the properties array.  If negative we have
+    // an inobject property.
+    int index = lookup.GetFieldIndex() - map->inobject_properties();
+    if (index < 0) {
+      // Index is an offset from the end of the object.
+      int offset = map->instance_size() + (index * kPointerSize);
+      if (PatchInlinedLoad(address(), map, offset)) {
+        set_target(megamorphic_stub());
+        TRACE_IC_NAMED("[LoadIC : inline patch %s]\n", name);
+        return lookup.holder()->FastPropertyAt(lookup.GetFieldIndex());
+      } else {
+        TRACE_IC_NAMED("[LoadIC : no inline patch %s (patching failed)]\n",
+                       name);
+      }
+    } else {
+      TRACE_IC_NAMED("[LoadIC : no inline patch %s (not inobject)]\n", name);
+    }
+  } else if (can_be_inlined_contextual) {
+    Map* map = lookup.holder()->map();
+    JSGlobalPropertyCell* cell = JSGlobalPropertyCell::cast(
+        lookup.holder()->property_dictionary()->ValueAt(
+            lookup.GetDictionaryEntry()));
+    if (PatchInlinedContextualLoad(address(),
+                                   map,
+                                   cell,
+                                   lookup.IsDontDelete())) {
+      set_target(megamorphic_stub());
+      TRACE_IC_NAMED("[LoadIC : inline contextual patch %s]\n", name);
+      ASSERT(cell->value() != isolate()->heap()->the_hole_value());
+      return cell->value();
+    }
+  } else {
+    if (FLAG_use_ic && state == PREMONOMORPHIC) {
+      TRACE_IC_NAMED("[LoadIC : no inline patch %s (not inlinable)]\n", name);
+    }
+  }
+
   // Update inline cache and stub cache.
   if (FLAG_use_ic) {
     UpdateCaches(&lookup, state, object, name);
@@ -1185,6 +1294,18 @@ MaybeObject* KeyedLoadIC::Load(State state,
 #ifdef DEBUG
     TraceIC("KeyedLoadIC", key, state, target());
 #endif  // DEBUG
+
+    // For JSObjects with fast elements that are not value wrappers
+    // and that do not have indexed interceptors, we initialize the
+    // inlined fast case (if present) by patching the inlined map
+    // check.
+    if (object->IsJSObject() &&
+        !object->IsJSValue() &&
+        !JSObject::cast(*object)->HasIndexedInterceptor() &&
+        JSObject::cast(*object)->HasFastElements()) {
+      Map* map = JSObject::cast(*object)->map();
+      PatchInlinedLoad(address(), map);
+    }
   }
 
   // Get the property.
@@ -1350,7 +1471,57 @@ MaybeObject* StoreIC::Store(State state,
     LookupResult lookup;
 
     if (LookupForWrite(*receiver, *name, &lookup)) {
-      // Generate a stub for this store.
+      bool can_be_inlined =
+          state == UNINITIALIZED &&
+          lookup.IsProperty() &&
+          lookup.holder() == *receiver &&
+          lookup.type() == FIELD &&
+          !receiver->IsAccessCheckNeeded();
+
+      if (can_be_inlined) {
+        Map* map = lookup.holder()->map();
+        // Property's index in the properties array.  If negative we have
+        // an inobject property.
+        int index = lookup.GetFieldIndex() - map->inobject_properties();
+        if (index < 0) {
+          // Index is an offset from the end of the object.
+          int offset = map->instance_size() + (index * kPointerSize);
+          if (PatchInlinedStore(address(), map, offset)) {
+            set_target((strict_mode == kStrictMode)
+                         ? megamorphic_stub_strict()
+                         : megamorphic_stub());
+#ifdef DEBUG
+            if (FLAG_trace_ic) {
+              PrintF("[StoreIC : inline patch %s]\n", *name->ToCString());
+            }
+#endif
+            return receiver->SetProperty(*name, *value, NONE, strict_mode);
+#ifdef DEBUG
+
+          } else {
+            if (FLAG_trace_ic) {
+              PrintF("[StoreIC : no inline patch %s (patching failed)]\n",
+                     *name->ToCString());
+            }
+          }
+        } else {
+          if (FLAG_trace_ic) {
+            PrintF("[StoreIC : no inline patch %s (not inobject)]\n",
+                   *name->ToCString());
+          }
+        }
+      } else {
+        if (state == PREMONOMORPHIC) {
+          if (FLAG_trace_ic) {
+            PrintF("[StoreIC : no inline patch %s (not inlinable)]\n",
+                   *name->ToCString());
+#endif
+          }
+        }
+      }
+
+      // If no inlined store ic was patched, generate a stub for this
+      // store.
       UpdateCaches(&lookup, state, strict_mode, receiver, name, value);
     } else {
       // Strict mode doesn't allow setting non-existent global property
@@ -1819,7 +1990,6 @@ const char* TRBinaryOpIC::GetName(TypeInfo type_info) {
     case INT32: return "Int32s";
     case HEAP_NUMBER: return "HeapNumbers";
     case ODDBALL: return "Oddball";
-    case BOTH_STRING: return "BothStrings";
     case STRING: return "Strings";
     case GENERIC: return "Generic";
     default: return "Invalid";
@@ -1835,7 +2005,6 @@ TRBinaryOpIC::State TRBinaryOpIC::ToState(TypeInfo type_info) {
     case INT32:
     case HEAP_NUMBER:
     case ODDBALL:
-    case BOTH_STRING:
     case STRING:
       return MONOMORPHIC;
     case GENERIC:
@@ -1850,17 +2019,12 @@ TRBinaryOpIC::TypeInfo TRBinaryOpIC::JoinTypes(TRBinaryOpIC::TypeInfo x,
                                                TRBinaryOpIC::TypeInfo y) {
   if (x == UNINITIALIZED) return y;
   if (y == UNINITIALIZED) return x;
-  if (x == y) return x;
-  if (x == BOTH_STRING && y == STRING) return STRING;
-  if (x == STRING && y == BOTH_STRING) return STRING;
-  if (x == STRING || x == BOTH_STRING || y == STRING || y == BOTH_STRING) {
-    return GENERIC;
-  }
-  if (x > y) return x;
+  if (x == STRING && y == STRING) return STRING;
+  if (x == STRING || y == STRING) return GENERIC;
+  if (x >= y) return x;
   return y;
 }
 
-
 TRBinaryOpIC::TypeInfo TRBinaryOpIC::GetTypeInfo(Handle<Object> left,
                                                  Handle<Object> right) {
   ::v8::internal::TypeInfo left_type =
@@ -1882,11 +2046,9 @@ TRBinaryOpIC::TypeInfo TRBinaryOpIC::GetTypeInfo(Handle<Object> left,
     return HEAP_NUMBER;
   }
 
-  // Patching for fast string ADD makes sense even if only one of the
-  // arguments is a string.
-  if (left_type.IsString())  {
-    return right_type.IsString() ? BOTH_STRING : STRING;
-  } else if (right_type.IsString()) {
+  if (left_type.IsString() || right_type.IsString()) {
+    // Patching for fast string ADD makes sense even if only one of the
+    // arguments is a string.
     return STRING;
   }
 
@@ -1919,11 +2081,11 @@ RUNTIME_FUNCTION(MaybeObject*, TypeRecordingBinaryOp_Patch) {
   TRBinaryOpIC::TypeInfo type = TRBinaryOpIC::GetTypeInfo(left, right);
   type = TRBinaryOpIC::JoinTypes(type, previous_type);
   TRBinaryOpIC::TypeInfo result_type = TRBinaryOpIC::UNINITIALIZED;
-  if ((type == TRBinaryOpIC::STRING || type == TRBinaryOpIC::BOTH_STRING) &&
-      op != Token::ADD) {
+  if (type == TRBinaryOpIC::STRING && op != Token::ADD) {
     type = TRBinaryOpIC::GENERIC;
   }
-  if (type == TRBinaryOpIC::SMI && previous_type == TRBinaryOpIC::SMI) {
+  if (type == TRBinaryOpIC::SMI &&
+      previous_type == TRBinaryOpIC::SMI) {
     if (op == Token::DIV || op == Token::MUL || kSmiValueSize == 32) {
       // Arithmetic on two Smi inputs has yielded a heap number.
       // That is the only way to get here from the Smi stub.
@@ -1935,7 +2097,8 @@ RUNTIME_FUNCTION(MaybeObject*, TypeRecordingBinaryOp_Patch) {
       result_type = TRBinaryOpIC::INT32;
     }
   }
-  if (type == TRBinaryOpIC::INT32 && previous_type == TRBinaryOpIC::INT32) {
+  if (type == TRBinaryOpIC::INT32 &&
+      previous_type == TRBinaryOpIC::INT32) {
     // We must be here because an operation on two INT32 types overflowed.
     result_type = TRBinaryOpIC::HEAP_NUMBER;
   }
diff --git a/src/ic.h b/src/ic.h
index 7b7ab434..911cbd83 100644
--- a/src/ic.h
+++ b/src/ic.h
@@ -296,6 +296,14 @@ class LoadIC: public IC {
                                    bool support_wrappers);
   static void GenerateFunctionPrototype(MacroAssembler* masm);
 
+  // Clear the use of the inlined version.
+  static void ClearInlinedVersion(Address address);
+
+  // The offset from the inlined patch site to the start of the
+  // inlined load instruction.  It is architecture-dependent, and not
+  // used on ARM.
+  static const int kOffsetToLoadInstruction;
+
  private:
   // Update the inline cache and the global stub cache based on the
   // lookup result.
@@ -320,6 +328,13 @@ class LoadIC: public IC {
 
   static void Clear(Address address, Code* target);
 
+  static bool PatchInlinedLoad(Address address, Object* map, int index);
+
+  static bool PatchInlinedContextualLoad(Address address,
+                                         Object* map,
+                                         Object* cell,
+                                         bool is_dont_delete);
+
   friend class IC;
 };
 
@@ -346,6 +361,9 @@ class KeyedLoadIC: public IC {
 
   static void GenerateIndexedInterceptor(MacroAssembler* masm);
 
+  // Clear the use of the inlined version.
+  static void ClearInlinedVersion(Address address);
+
   // Bit mask to be tested against bit field for the cases when
   // generic stub should go into slow case.
   // Access check is necessary explicitly since generic stub does not perform
@@ -389,6 +407,10 @@ class KeyedLoadIC: public IC {
 
   static void Clear(Address address, Code* target);
 
+  // Support for patching the map that is checked in an inlined
+  // version of keyed load.
+  static bool PatchInlinedLoad(Address address, Object* map);
+
   friend class IC;
 };
 
@@ -415,6 +437,13 @@ class StoreIC: public IC {
   static void GenerateGlobalProxy(MacroAssembler* masm,
                                   StrictModeFlag strict_mode);
 
+  // Clear the use of an inlined version.
+  static void ClearInlinedVersion(Address address);
+
+  // The offset from the inlined patch site to the start of the
+  // inlined store instruction.
+  static const int kOffsetToStoreInstruction;
+
  private:
   // Update the inline cache and the global stub cache based on the
   // lookup result.
@@ -460,6 +489,10 @@ class StoreIC: public IC {
 
   static void Clear(Address address, Code* target);
 
+  // Support for patching the index and the map that is checked in an
+  // inlined version of the named store.
+  static bool PatchInlinedStore(Address address, Object* map, int index);
+
   friend class IC;
 };
 
@@ -481,6 +514,12 @@ class KeyedStoreIC: public IC {
                                          StrictModeFlag strict_mode);
   static void GenerateGeneric(MacroAssembler* masm, StrictModeFlag strict_mode);
 
+  // Clear the inlined version so the IC is always hit.
+  static void ClearInlinedVersion(Address address);
+
+  // Restore the inlined version so the fast case can get hit.
+  static void RestoreInlinedVersion(Address address);
+
  private:
   // Update the inline cache.
   void UpdateCaches(LookupResult* lookup,
@@ -525,6 +564,14 @@ class KeyedStoreIC: public IC {
 
   static void Clear(Address address, Code* target);
 
+  // Support for patching the map that is checked in an inlined
+  // version of keyed store.
+  // The address is the patch point for the IC call
+  // (Assembler::kCallTargetAddressOffset before the end of
+  // the call/return address).
+  // The map is the new map that the inlined code should check against.
+  static bool PatchInlinedStore(Address address, Object* map);
+
   friend class IC;
 };
 
@@ -539,7 +586,6 @@ class TRBinaryOpIC: public IC {
     INT32,
     HEAP_NUMBER,
     ODDBALL,
-    BOTH_STRING,  // Only used for addition operation.
     STRING,  // Only used for addition operation.  At least one string operand.
     GENERIC
   };
diff --git a/src/jsregexp.cc b/src/jsregexp.cc
index 06aae352..66b63325 100644
--- a/src/jsregexp.cc
+++ b/src/jsregexp.cc
@@ -858,12 +858,25 @@ RegExpEngine::CompilationResult RegExpCompiler::Assemble(
     RegExpNode* start,
     int capture_count,
     Handle<String> pattern) {
+  Heap* heap = pattern->GetHeap();
+
+  bool use_slow_safe_regexp_compiler = false;
+  if (heap->total_regexp_code_generated() >
+          RegExpImpl::kRegWxpCompiledLimit &&
+      heap->isolate()->memory_allocator()->SizeExecutable() >
+          RegExpImpl::kRegExpExecutableMemoryLimit) {
+    use_slow_safe_regexp_compiler = true;
+  }
+
+  macro_assembler->set_slow_safe(use_slow_safe_regexp_compiler);
+
 #ifdef DEBUG
   if (FLAG_trace_regexp_assembler)
     macro_assembler_ = new RegExpMacroAssemblerTracer(macro_assembler);
   else
 #endif
     macro_assembler_ = macro_assembler;
+
   List <RegExpNode*> work_list(0);
   work_list_ = &work_list;
   Label fail;
@@ -877,7 +890,8 @@ RegExpEngine::CompilationResult RegExpCompiler::Assemble(
   }
   if (reg_exp_too_big_) return IrregexpRegExpTooBig();
 
-  Handle<Object> code = macro_assembler_->GetCode(pattern);
+  Handle<HeapObject> code = macro_assembler_->GetCode(pattern);
+  heap->IncreaseTotalRegexpCodeGenerated(code->Size());
   work_list_ = NULL;
 #ifdef DEBUG
   if (FLAG_print_code) {
diff --git a/src/jsregexp.h b/src/jsregexp.h
index b9b2f604..d56b650a 100644
--- a/src/jsregexp.h
+++ b/src/jsregexp.h
@@ -175,6 +175,14 @@ class RegExpImpl {
   static ByteArray* IrregexpByteCode(FixedArray* re, bool is_ascii);
   static Code* IrregexpNativeCode(FixedArray* re, bool is_ascii);
 
+  // Limit the space regexps take up on the heap.  In order to limit this we
+  // would like to keep track of the amount of regexp code on the heap.  This
+  // is not tracked, however.  As a conservative approximation we track the
+  // total regexp code compiled including code that has subsequently been freed
+  // and the total executable memory at any point.
+  static const int kRegExpExecutableMemoryLimit = 16 * MB;
+  static const int kRegWxpCompiledLimit = 1 * MB;
+
  private:
   static String* last_ascii_string_;
   static String* two_byte_cached_string_;
diff --git a/src/mark-compact.cc b/src/mark-compact.cc
index bd36459d..68a50622 100644
--- a/src/mark-compact.cc
+++ b/src/mark-compact.cc
@@ -1077,6 +1077,12 @@ void MarkCompactCollector::MarkUnmarkedObject(HeapObject* object) {
 
 
 void MarkCompactCollector::MarkMapContents(Map* map) {
+  // Mark prototype transitions array but don't push it into marking stack.
+  // This will make references from it weak. We will clean dead prototype
+  // transitions in ClearNonLiveTransitions.
+  FixedArray* prototype_transitions = map->unchecked_prototype_transitions();
+  if (!prototype_transitions->IsMarked()) SetMark(prototype_transitions);
+
   MarkDescriptorArray(reinterpret_cast<DescriptorArray*>(
       *HeapObject::RawField(map, Map::kInstanceDescriptorsOffset)));
 
@@ -1494,7 +1500,7 @@ bool MarkCompactCollector::SafeIsMap(HeapObject* object) {
 
 
 void MarkCompactCollector::ClearNonLiveTransitions() {
-  HeapObjectIterator map_iterator(heap() ->map_space(), &SizeOfMarkedObject);
+  HeapObjectIterator map_iterator(heap()->map_space(), &SizeOfMarkedObject);
   // Iterate over the map space, setting map transitions that go from
   // a marked map to an unmarked map to null transitions.  At the same time,
   // set all the prototype fields of maps back to their original value,
@@ -1522,6 +1528,41 @@ void MarkCompactCollector::ClearNonLiveTransitions() {
       map->unchecked_constructor()->unchecked_shared()->AttachInitialMap(map);
     }
 
+    // Clear dead prototype transitions.
+    FixedArray* prototype_transitions = map->unchecked_prototype_transitions();
+    if (prototype_transitions->length() > 0) {
+      int finger = Smi::cast(prototype_transitions->get(0))->value();
+      int new_finger = 1;
+      for (int i = 1; i < finger; i += 2) {
+        Object* prototype = prototype_transitions->get(i);
+        Object* cached_map = prototype_transitions->get(i + 1);
+        if (HeapObject::cast(prototype)->IsMarked() &&
+            HeapObject::cast(cached_map)->IsMarked()) {
+          if (new_finger != i) {
+            prototype_transitions->set_unchecked(heap_,
+                                                 new_finger,
+                                                 prototype,
+                                                 UPDATE_WRITE_BARRIER);
+            prototype_transitions->set_unchecked(heap_,
+                                                 new_finger + 1,
+                                                 cached_map,
+                                                 SKIP_WRITE_BARRIER);
+          }
+          new_finger += 2;
+        }
+      }
+
+      // Fill slots that became free with undefined value.
+      Object* undefined = heap()->raw_unchecked_undefined_value();
+      for (int i = new_finger; i < finger; i++) {
+        prototype_transitions->set_unchecked(heap_,
+                                             i,
+                                             undefined,
+                                             SKIP_WRITE_BARRIER);
+      }
+      prototype_transitions->set_unchecked(0, Smi::FromInt(new_finger));
+    }
+
     // Follow the chain of back pointers to find the prototype.
     Map* current = map;
     while (SafeIsMap(current)) {
diff --git a/src/messages.js b/src/messages.js
index e657fc05..d8810dce 100644
--- a/src/messages.js
+++ b/src/messages.js
@@ -212,7 +212,9 @@ function FormatMessage(message) {
       invalid_preparser_data:       ["Invalid preparser data for function ", "%0"],
       strict_mode_with:             ["Strict mode code may not include a with statement"],
       strict_catch_variable:        ["Catch variable may not be eval or arguments in strict mode"],
-      too_many_parameters:          ["Too many parameters in function definition"],
+      too_many_arguments:           ["Too many arguments in function call (only 32766 allowed)"],
+      too_many_parameters:          ["Too many parameters in function definition (only 32766 allowed)"],
+      too_many_variables:           ["Too many variables declared (only 32767 allowed)"],
       strict_param_name:            ["Parameter name eval or arguments is not allowed in strict mode"],
       strict_param_dupe:            ["Strict mode function may not have duplicate parameter names"],
       strict_var_name:              ["Variable name may not be eval or arguments in strict mode"],
diff --git a/src/mips/regexp-macro-assembler-mips.cc b/src/mips/regexp-macro-assembler-mips.cc
index d1dbc435..9f9e976a 100644
--- a/src/mips/regexp-macro-assembler-mips.cc
+++ b/src/mips/regexp-macro-assembler-mips.cc
@@ -259,9 +259,9 @@ void RegExpMacroAssemblerMIPS::Fail() {
 }
 
 
-Handle<Object> RegExpMacroAssemblerMIPS::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerMIPS::GetCode(Handle<String> source) {
   UNIMPLEMENTED_MIPS();
-  return Handle<Object>::null();
+  return Handle<HeapObject>::null();
 }
 
 
diff --git a/src/mips/regexp-macro-assembler-mips.h b/src/mips/regexp-macro-assembler-mips.h
index 2f4319f9..7310c9d4 100644
--- a/src/mips/regexp-macro-assembler-mips.h
+++ b/src/mips/regexp-macro-assembler-mips.h
@@ -81,7 +81,7 @@ class RegExpMacroAssemblerMIPS: public NativeRegExpMacroAssembler {
   virtual bool CheckSpecialCharacterClass(uc16 type,
                                           Label* on_no_match);
   virtual void Fail();
-  virtual Handle<Object> GetCode(Handle<String> source);
+  virtual Handle<HeapObject> GetCode(Handle<String> source);
   virtual void GoTo(Label* label);
   virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
   virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
diff --git a/src/natives.h b/src/natives.h
index 92f0d90b..1df94b08 100644
--- a/src/natives.h
+++ b/src/natives.h
@@ -1,4 +1,4 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
+// Copyright 2006-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:
@@ -36,7 +36,7 @@ typedef bool (*NativeSourceCallback)(Vector<const char> name,
                                      int index);
 
 enum NativeType {
-  CORE, EXPERIMENTAL, D8, I18N
+  CORE, D8, I18N
 };
 
 template <NativeType type>
@@ -57,7 +57,6 @@ class NativesCollection {
 };
 
 typedef NativesCollection<CORE> Natives;
-typedef NativesCollection<EXPERIMENTAL> ExperimentalNatives;
 
 } }  // namespace v8::internal
 
diff --git a/src/objects-inl.h b/src/objects-inl.h
index 823b2dad..65aec5dc 100644
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -2515,6 +2515,12 @@ JSFunction* Map::unchecked_constructor() {
 }
 
 
+FixedArray* Map::unchecked_prototype_transitions() {
+  return reinterpret_cast<FixedArray*>(
+      READ_FIELD(this, kPrototypeTransitionsOffset));
+}
+
+
 Code::Flags Code::flags() {
   return static_cast<Flags>(READ_INT_FIELD(this, kFlagsOffset));
 }
@@ -2923,6 +2929,7 @@ MaybeObject* Map::GetSlowElementsMap() {
 ACCESSORS(Map, instance_descriptors, DescriptorArray,
           kInstanceDescriptorsOffset)
 ACCESSORS(Map, code_cache, Object, kCodeCacheOffset)
+ACCESSORS(Map, prototype_transitions, FixedArray, kPrototypeTransitionsOffset)
 ACCESSORS(Map, constructor, Object, kConstructorOffset)
 
 ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)
diff --git a/src/objects.cc b/src/objects.cc
index 6ce4c441..a20548c6 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -3713,39 +3713,68 @@ void Map::RemoveFromCodeCache(String* name, Code* code, int index) {
 
 
 void Map::TraverseTransitionTree(TraverseCallback callback, void* data) {
+  // Traverse the transition tree without using a stack.  We do this by
+  // reversing the pointers in the maps and descriptor arrays.
   Map* current = this;
   Map* meta_map = heap()->meta_map();
+  Object** map_or_index_field = NULL;
   while (current != meta_map) {
     DescriptorArray* d = reinterpret_cast<DescriptorArray*>(
         *RawField(current, Map::kInstanceDescriptorsOffset));
-    if (d == heap()->empty_descriptor_array()) {
-      Map* prev = current->map();
-      current->set_map(meta_map);
-      callback(current, data);
-      current = prev;
-      continue;
-    }
-
-    FixedArray* contents = reinterpret_cast<FixedArray*>(
-        d->get(DescriptorArray::kContentArrayIndex));
-    Object** map_or_index_field = RawField(contents, HeapObject::kMapOffset);
-    Object* map_or_index = *map_or_index_field;
-    bool map_done = true;
-    for (int i = map_or_index->IsSmi() ? Smi::cast(map_or_index)->value() : 0;
-         i < contents->length();
-         i += 2) {
-      PropertyDetails details(Smi::cast(contents->get(i + 1)));
-      if (details.IsTransition()) {
-        Map* next = reinterpret_cast<Map*>(contents->get(i));
+    if (!d->IsEmpty()) {
+      FixedArray* contents = reinterpret_cast<FixedArray*>(
+          d->get(DescriptorArray::kContentArrayIndex));
+      map_or_index_field = RawField(contents, HeapObject::kMapOffset);
+      Object* map_or_index = *map_or_index_field;
+      bool map_done = true;  // Controls a nested continue statement.
+      for (int i = map_or_index->IsSmi() ? Smi::cast(map_or_index)->value() : 0;
+           i < contents->length();
+           i += 2) {
+        PropertyDetails details(Smi::cast(contents->get(i + 1)));
+        if (details.IsTransition()) {
+          // Found a map in the transition array.  We record our progress in
+          // the transition array by recording the current map in the map field
+          // of the next map and recording the index in the transition array in
+          // the map field of the array.
+          Map* next = Map::cast(contents->get(i));
+          next->set_map(current);
+          *map_or_index_field = Smi::FromInt(i + 2);
+          current = next;
+          map_done = false;
+          break;
+        }
+      }
+      if (!map_done) continue;
+    }
+    // That was the regular transitions, now for the prototype transitions.
+    FixedArray* prototype_transitions =
+        current->unchecked_prototype_transitions();
+    Object** proto_map_or_index_field =
+        RawField(prototype_transitions, HeapObject::kMapOffset);
+    Object* map_or_index = *proto_map_or_index_field;
+    const int start = 2;
+    int i = map_or_index->IsSmi() ? Smi::cast(map_or_index)->value() : start;
+    if (i < prototype_transitions->length()) {
+      // Found a map in the prototype transition array.  Record progress in
+      // an analogous way to the regular transitions array above.
+      Object* perhaps_map = prototype_transitions->get(i);
+      if (perhaps_map->IsMap()) {
+        Map* next = Map::cast(perhaps_map);
         next->set_map(current);
-        *map_or_index_field = Smi::FromInt(i + 2);
+        *proto_map_or_index_field =
+            Smi::FromInt(i + 2);
         current = next;
-        map_done = false;
-        break;
+        continue;
       }
     }
-    if (!map_done) continue;
-    *map_or_index_field = heap()->fixed_array_map();
+    *proto_map_or_index_field = heap()->fixed_array_map();
+    if (map_or_index_field != NULL) {
+      *map_or_index_field = heap()->fixed_array_map();
+    }
+
+    // The callback expects a map to have a real map as its map, so we save
+    // the map field, which is being used to track the traversal and put the
+    // correct map (the meta_map) in place while we do the callback.
     Map* prev = current->map();
     current->set_map(meta_map);
     callback(current, data);
@@ -6874,6 +6903,49 @@ MaybeObject* JSObject::SetElementsLength(Object* len) {
 }
 
 
+Object* Map::GetPrototypeTransition(Object* prototype) {
+  FixedArray* cache = prototype_transitions();
+  int capacity = cache->length();
+  if (capacity == 0) return NULL;
+  int finger = Smi::cast(cache->get(0))->value();
+  for (int i = 1; i < finger; i += 2) {
+    if (cache->get(i) == prototype) return cache->get(i + 1);
+  }
+  return NULL;
+}
+
+
+MaybeObject* Map::PutPrototypeTransition(Object* prototype, Map* map) {
+  // Don't cache prototype transition if this map is shared.
+  if (is_shared() || !FLAG_cache_prototype_transitions) return this;
+
+  FixedArray* cache = prototype_transitions();
+
+  int capacity = cache->length();
+
+  int finger = (capacity == 0) ? 1 : Smi::cast(cache->get(0))->value();
+
+  if (finger >= capacity) {
+    if (capacity > kMaxCachedPrototypeTransitions) return this;
+
+    FixedArray* new_cache;
+    { MaybeObject* maybe_cache = heap()->AllocateFixedArray(finger * 2 + 1);
+      if (!maybe_cache->To<FixedArray>(&new_cache)) return maybe_cache;
+    }
+
+    for (int i = 1; i < capacity; i++) new_cache->set(i, cache->get(i));
+    cache = new_cache;
+    set_prototype_transitions(cache);
+  }
+
+  cache->set(finger, prototype);
+  cache->set(finger + 1, map);
+  cache->set(0, Smi::FromInt(finger + 2));
+
+  return cache;
+}
+
+
 MaybeObject* JSObject::SetPrototype(Object* value,
                                     bool skip_hidden_prototypes) {
   Heap* heap = GetHeap();
@@ -6924,11 +6996,25 @@ MaybeObject* JSObject::SetPrototype(Object* value,
   }
 
   // Set the new prototype of the object.
-  Object* new_map;
-  { MaybeObject* maybe_new_map = real_receiver->map()->CopyDropTransitions();
-    if (!maybe_new_map->ToObject(&new_map)) return maybe_new_map;
+  Map* map = real_receiver->map();
+
+  // Nothing to do if prototype is already set.
+  if (map->prototype() == value) return value;
+
+  Object* new_map = map->GetPrototypeTransition(value);
+  if (new_map == NULL) {
+    { MaybeObject* maybe_new_map = map->CopyDropTransitions();
+      if (!maybe_new_map->ToObject(&new_map)) return maybe_new_map;
+    }
+
+    { MaybeObject* maybe_new_cache =
+          map->PutPrototypeTransition(value, Map::cast(new_map));
+      if (maybe_new_cache->IsFailure()) return maybe_new_cache;
+    }
+
+    Map::cast(new_map)->set_prototype(value);
   }
-  Map::cast(new_map)->set_prototype(value);
+  ASSERT(Map::cast(new_map)->prototype() == value);
   real_receiver->set_map(Map::cast(new_map));
 
   heap->ClearInstanceofCache();
diff --git a/src/objects.h b/src/objects.h
index 03445e87..e966b3de 100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -613,6 +613,7 @@ enum CompareResult {
 
 class StringStream;
 class ObjectVisitor;
+class Failure;
 
 struct ValueInfo : public Malloced {
   ValueInfo() : type(FIRST_TYPE), ptr(NULL), str(NULL), number(0) { }
@@ -639,6 +640,10 @@ class MaybeObject BASE_EMBEDDED {
     *obj = reinterpret_cast<Object*>(this);
     return true;
   }
+  inline Failure* ToFailureUnchecked() {
+    ASSERT(IsFailure());
+    return reinterpret_cast<Failure*>(this);
+  }
   inline Object* ToObjectUnchecked() {
     ASSERT(!IsFailure());
     return reinterpret_cast<Object*>(this);
@@ -648,6 +653,13 @@ class MaybeObject BASE_EMBEDDED {
     return reinterpret_cast<Object*>(this);
   }
 
+  template<typename T>
+  inline bool To(T** obj) {
+    if (IsFailure()) return false;
+    *obj = T::cast(reinterpret_cast<Object*>(this));
+    return true;
+  }
+
 #ifdef OBJECT_PRINT
   // Prints this object with details.
   inline void Print() {
@@ -3712,6 +3724,16 @@ class Map: public HeapObject {
   // [stub cache]: contains stubs compiled for this map.
   DECL_ACCESSORS(code_cache, Object)
 
+  // [prototype transitions]: cache of prototype transitions.
+  // Prototype transition is a transition that happens
+  // when we change object's prototype to a new one.
+  // Cache format:
+  //    0: finger - index of the first free cell in the cache
+  //    1 + 2 * i: prototype
+  //    2 + 2 * i: target map
+  DECL_ACCESSORS(prototype_transitions, FixedArray)
+  inline FixedArray* unchecked_prototype_transitions();
+
   // Lookup in the map's instance descriptors and fill out the result
   // with the given holder if the name is found. The holder may be
   // NULL when this function is used from the compiler.
@@ -3811,6 +3833,12 @@ class Map: public HeapObject {
 
   void TraverseTransitionTree(TraverseCallback callback, void* data);
 
+  static const int kMaxCachedPrototypeTransitions = 256;
+
+  Object* GetPrototypeTransition(Object* prototype);
+
+  MaybeObject* PutPrototypeTransition(Object* prototype, Map* map);
+
   static const int kMaxPreAllocatedPropertyFields = 255;
 
   // Layout description.
@@ -3821,14 +3849,16 @@ class Map: public HeapObject {
   static const int kInstanceDescriptorsOffset =
       kConstructorOffset + kPointerSize;
   static const int kCodeCacheOffset = kInstanceDescriptorsOffset + kPointerSize;
-  static const int kPadStart = kCodeCacheOffset + kPointerSize;
+  static const int kPrototypeTransitionsOffset =
+      kCodeCacheOffset + kPointerSize;
+  static const int kPadStart = kPrototypeTransitionsOffset + kPointerSize;
   static const int kSize = MAP_POINTER_ALIGN(kPadStart);
 
   // Layout of pointer fields. Heap iteration code relies on them
   // being continiously allocated.
   static const int kPointerFieldsBeginOffset = Map::kPrototypeOffset;
   static const int kPointerFieldsEndOffset =
-      Map::kCodeCacheOffset + kPointerSize;
+      Map::kPrototypeTransitionsOffset + kPointerSize;
 
   // Byte offsets within kInstanceSizesOffset.
   static const int kInstanceSizeOffset = kInstanceSizesOffset + 0;
diff --git a/src/parser.cc b/src/parser.cc
index cf84bfab..266f77d5 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -1308,7 +1308,7 @@ VariableProxy* Parser::Declare(Handle<String> name,
     var = top_scope_->LocalLookup(name);
     if (var == NULL) {
       // Declare the name.
-      var = top_scope_->DeclareLocal(name, mode);
+      var = top_scope_->DeclareLocal(name, mode, Scope::VAR_OR_CONST);
     } else {
       // The name was declared before; check for conflicting
       // re-declarations. If the previous declaration was a const or the
@@ -1580,6 +1580,12 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN,
                        is_const /* always bound for CONST! */,
                        CHECK_OK);
     nvars++;
+    if (top_scope_->num_var_or_const() > kMaxNumFunctionLocals) {
+      ReportMessageAt(scanner().location(), "too_many_variables",
+                      Vector<const char*>::empty());
+      *ok = false;
+      return NULL;
+    }
 
     // Parse initialization expression if present and/or needed. A
     // declaration of the form:
@@ -3495,6 +3501,12 @@ ZoneList<Expression*>* Parser::ParseArguments(bool* ok) {
   while (!done) {
     Expression* argument = ParseAssignmentExpression(true, CHECK_OK);
     result->Add(argument);
+    if (result->length() > kMaxNumFunctionParameters) {
+      ReportMessageAt(scanner().location(), "too_many_arguments",
+                      Vector<const char*>::empty());
+      *ok = false;
+      return NULL;
+    }
     done = (peek() == Token::RPAREN);
     if (!done) Expect(Token::COMMA, CHECK_OK);
   }
@@ -3562,7 +3574,9 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> var_name,
         reserved_loc = scanner().location();
       }
 
-      Variable* parameter = top_scope_->DeclareLocal(param_name, Variable::VAR);
+      Variable* parameter = top_scope_->DeclareLocal(param_name,
+                                                     Variable::VAR,
+                                                     Scope::PARAMETER);
       top_scope_->AddParameter(parameter);
       num_parameters++;
       if (num_parameters > kMaxNumFunctionParameters) {
diff --git a/src/parser.h b/src/parser.h
index a63651af..64f13030 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -448,6 +448,7 @@ class Parser {
   // construct a hashable id, so if more than 2^17 are allowed, this
   // should be checked.
   static const int kMaxNumFunctionParameters = 32766;
+  static const int kMaxNumFunctionLocals = 32767;
   FunctionLiteral* ParseLazy(CompilationInfo* info,
                              UC16CharacterStream* source,
                              ZoneScope* zone_scope);
diff --git a/src/platform-linux.cc b/src/platform-linux.cc
index 1ecd8fc8..c60658fb 100644
--- a/src/platform-linux.cc
+++ b/src/platform-linux.cc
@@ -922,19 +922,28 @@ class SignalSender : public Thread {
         vm_tgid_(getpid()),
         interval_(interval) {}
 
+  static void InstallSignalHandler() {
+    struct sigaction sa;
+    sa.sa_sigaction = ProfilerSignalHandler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = SA_RESTART | SA_SIGINFO;
+    signal_handler_installed_ =
+        (sigaction(SIGPROF, &sa, &old_signal_handler_) == 0);
+  }
+
+  static void RestoreSignalHandler() {
+    if (signal_handler_installed_) {
+      sigaction(SIGPROF, &old_signal_handler_, 0);
+      signal_handler_installed_ = false;
+    }
+  }
+
   static void AddActiveSampler(Sampler* sampler) {
     ScopedLock lock(mutex_);
     SamplerRegistry::AddActiveSampler(sampler);
     if (instance_ == NULL) {
-      // Install a signal handler.
-      struct sigaction sa;
-      sa.sa_sigaction = ProfilerSignalHandler;
-      sigemptyset(&sa.sa_mask);
-      sa.sa_flags = SA_RESTART | SA_SIGINFO;
-      signal_handler_installed_ =
-          (sigaction(SIGPROF, &sa, &old_signal_handler_) == 0);
-
-      // Start a thread that sends SIGPROF signal to VM threads.
+      // Start a thread that will send SIGPROF signal to VM threads,
+      // when CPU profiling will be enabled.
       instance_ = new SignalSender(sampler->interval());
       instance_->Start();
     } else {
@@ -950,12 +959,7 @@ class SignalSender : public Thread {
       instance_->Join();
       delete instance_;
       instance_ = NULL;
-
-      // Restore the old signal handler.
-      if (signal_handler_installed_) {
-        sigaction(SIGPROF, &old_signal_handler_, 0);
-        signal_handler_installed_ = false;
-      }
+      RestoreSignalHandler();
     }
   }
 
@@ -967,6 +971,10 @@ class SignalSender : public Thread {
       bool cpu_profiling_enabled =
           (state == SamplerRegistry::HAS_CPU_PROFILING_SAMPLERS);
       bool runtime_profiler_enabled = RuntimeProfiler::IsEnabled();
+      if (cpu_profiling_enabled && !signal_handler_installed_)
+        InstallSignalHandler();
+      else if (!cpu_profiling_enabled && signal_handler_installed_)
+        RestoreSignalHandler();
       // When CPU profiling is enabled both JavaScript and C++ code is
       // profiled. We must not suspend.
       if (!cpu_profiling_enabled) {
diff --git a/src/regexp-macro-assembler-irregexp.cc b/src/regexp-macro-assembler-irregexp.cc
index d41a97ca..322efa13 100644
--- a/src/regexp-macro-assembler-irregexp.cc
+++ b/src/regexp-macro-assembler-irregexp.cc
@@ -435,7 +435,8 @@ void RegExpMacroAssemblerIrregexp::IfRegisterEqPos(int register_index,
 }
 
 
-Handle<Object> RegExpMacroAssemblerIrregexp::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerIrregexp::GetCode(
+    Handle<String> source) {
   Bind(&backtrack_);
   Emit(BC_POP_BT, 0);
   Handle<ByteArray> array = FACTORY->NewByteArray(length());
diff --git a/src/regexp-macro-assembler-irregexp.h b/src/regexp-macro-assembler-irregexp.h
index 9deea86f..75cf8bf9 100644
--- a/src/regexp-macro-assembler-irregexp.h
+++ b/src/regexp-macro-assembler-irregexp.h
@@ -106,7 +106,7 @@ class RegExpMacroAssemblerIrregexp: public RegExpMacroAssembler {
   virtual void IfRegisterEqPos(int register_index, Label* if_eq);
 
   virtual IrregexpImplementation Implementation();
-  virtual Handle<Object> GetCode(Handle<String> source);
+  virtual Handle<HeapObject> GetCode(Handle<String> source);
  private:
   void Expand();
   // Code and bitmap emission.
diff --git a/src/regexp-macro-assembler-tracer.cc b/src/regexp-macro-assembler-tracer.cc
index fa2c6579..b32d71db 100644
--- a/src/regexp-macro-assembler-tracer.cc
+++ b/src/regexp-macro-assembler-tracer.cc
@@ -365,7 +365,7 @@ RegExpMacroAssembler::IrregexpImplementation
 }
 
 
-Handle<Object> RegExpMacroAssemblerTracer::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerTracer::GetCode(Handle<String> source) {
   PrintF(" GetCode(%s);\n", *(source->ToCString()));
   return assembler_->GetCode(source);
 }
diff --git a/src/regexp-macro-assembler-tracer.h b/src/regexp-macro-assembler-tracer.h
index 1fb6d544..8c6cf3ab 100644
--- a/src/regexp-macro-assembler-tracer.h
+++ b/src/regexp-macro-assembler-tracer.h
@@ -71,7 +71,7 @@ class RegExpMacroAssemblerTracer: public RegExpMacroAssembler {
   virtual bool CheckSpecialCharacterClass(uc16 type,
                                           Label* on_no_match);
   virtual void Fail();
-  virtual Handle<Object> GetCode(Handle<String> source);
+  virtual Handle<HeapObject> GetCode(Handle<String> source);
   virtual void GoTo(Label* label);
   virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
   virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
diff --git a/src/regexp-macro-assembler.cc b/src/regexp-macro-assembler.cc
index ea41db63..55782431 100644
--- a/src/regexp-macro-assembler.cc
+++ b/src/regexp-macro-assembler.cc
@@ -35,7 +35,7 @@
 namespace v8 {
 namespace internal {
 
-RegExpMacroAssembler::RegExpMacroAssembler() {
+RegExpMacroAssembler::RegExpMacroAssembler() : slow_safe_compiler_(false) {
 }
 
 
@@ -54,7 +54,8 @@ bool RegExpMacroAssembler::CanReadUnaligned() {
 
 #ifndef V8_INTERPRETED_REGEXP  // Avoid unused code, e.g., on ARM.
 
-NativeRegExpMacroAssembler::NativeRegExpMacroAssembler() {
+NativeRegExpMacroAssembler::NativeRegExpMacroAssembler()
+    : RegExpMacroAssembler() {
 }
 
 
@@ -64,7 +65,7 @@ NativeRegExpMacroAssembler::~NativeRegExpMacroAssembler() {
 
 bool NativeRegExpMacroAssembler::CanReadUnaligned() {
 #ifdef V8_TARGET_CAN_READ_UNALIGNED
-  return true;
+  return !slow_safe();
 #else
   return false;
 #endif
diff --git a/src/regexp-macro-assembler.h b/src/regexp-macro-assembler.h
index 1268e783..0314c707 100644
--- a/src/regexp-macro-assembler.h
+++ b/src/regexp-macro-assembler.h
@@ -130,7 +130,7 @@ class RegExpMacroAssembler {
     return false;
   }
   virtual void Fail() = 0;
-  virtual Handle<Object> GetCode(Handle<String> source) = 0;
+  virtual Handle<HeapObject> GetCode(Handle<String> source) = 0;
   virtual void GoTo(Label* label) = 0;
   // Check whether a register is >= a given constant and go to a label if it
   // is.  Backtracks instead if the label is NULL.
@@ -162,6 +162,13 @@ class RegExpMacroAssembler {
   virtual void WriteCurrentPositionToRegister(int reg, int cp_offset) = 0;
   virtual void ClearRegisters(int reg_from, int reg_to) = 0;
   virtual void WriteStackPointerToRegister(int reg) = 0;
+
+  // Controls the generation of large inlined constants in the code.
+  void set_slow_safe(bool ssc) { slow_safe_compiler_ = ssc; }
+  bool slow_safe() { return slow_safe_compiler_; }
+
+ private:
+  bool slow_safe_compiler_;
 };
 
 
diff --git a/src/runtime-profiler.cc b/src/runtime-profiler.cc
index 8d258ace..97f03416 100644
--- a/src/runtime-profiler.cc
+++ b/src/runtime-profiler.cc
@@ -1,4 +1,4 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
+// 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:
@@ -153,7 +153,6 @@ void RuntimeProfiler::Optimize(JSFunction* function, bool eager, int delay) {
   if (FLAG_trace_opt) {
     PrintF("[marking (%s) ", eager ? "eagerly" : "lazily");
     function->PrintName();
-    PrintF(" 0x%" V8PRIxPTR, reinterpret_cast<intptr_t>(function->address()));
     PrintF(" for recompilation");
     if (delay > 0) {
       PrintF(" (delayed %0.3f ms)", static_cast<double>(delay) / 1000);
diff --git a/src/runtime.cc b/src/runtime.cc
index 53c048e9..7335da89 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -2713,7 +2713,7 @@ MUST_USE_RESULT static MaybeObject* StringReplaceRegExpWithEmptyString(
     end = RegExpImpl::GetCapture(match_info_array, 1);
   }
 
-  int length = subject->length();
+  int length = subject_handle->length();
   int new_length = length - (end - start);
   if (new_length == 0) {
     return isolate->heap()->empty_string();
@@ -6597,16 +6597,9 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_RoundNumber) {
   int exponent = number->get_exponent();
   int sign = number->get_sign();
 
-  if (exponent < -1) {
-    // Number in range ]-0.5..0.5[. These always round to +/-zero.
-    if (sign) return isolate->heap()->minus_zero_value();
-    return Smi::FromInt(0);
-  }
-
-  // We compare with kSmiValueSize - 2 because (2^30 - 0.1) has exponent 29 and
-  // should be rounded to 2^30, which is not smi (for 31-bit smis, similar
-  // agument holds for 32-bit smis).
-  if (!sign && exponent < kSmiValueSize - 2) {
+  // We compare with kSmiValueSize - 3 because (2^30 - 0.1) has exponent 29 and
+  // should be rounded to 2^30, which is not smi.
+  if (!sign && exponent <= kSmiValueSize - 3) {
     return Smi::FromInt(static_cast<int>(value + 0.5));
   }
 
@@ -10485,7 +10478,7 @@ static Handle<Context> CopyWithContextChain(Handle<Context> context_chain,
   // Recursively copy the with contexts.
   Handle<Context> previous(context_chain->previous());
   Handle<JSObject> extension(JSObject::cast(context_chain->extension()));
-  Handle<Context> context = CopyWithContextChain(previous, function_context);
+  Handle<Context> context = CopyWithContextChain(function_context, previous);
   return context->GetIsolate()->factory()->NewWithContext(
       context, extension, context_chain->IsCatchContext());
 }
diff --git a/src/scopes.cc b/src/scopes.cc
index 7d9bce5c..8df93c5d 100644
--- a/src/scopes.cc
+++ b/src/scopes.cc
@@ -202,6 +202,7 @@ void Scope::SetDefaults(Type type,
   inner_scope_calls_eval_ = false;
   outer_scope_is_eval_scope_ = false;
   force_eager_compilation_ = false;
+  num_var_or_const_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
   scope_info_ = scope_info;
@@ -364,12 +365,17 @@ Variable* Scope::DeclareFunctionVar(Handle<String> name) {
 }
 
 
-Variable* Scope::DeclareLocal(Handle<String> name, Variable::Mode mode) {
+Variable* Scope::DeclareLocal(Handle<String> name,
+                              Variable::Mode mode,
+                              LocalType type) {
   // DYNAMIC variables are introduces during variable allocation,
   // INTERNAL variables are allocated explicitly, and TEMPORARY
   // variables are allocated via NewTemporary().
   ASSERT(!resolved());
   ASSERT(mode == Variable::VAR || mode == Variable::CONST);
+  if (type == VAR_OR_CONST) {
+    num_var_or_const_++;
+  }
   return variables_.Declare(this, name, mode, true, Variable::NORMAL);
 }
 
diff --git a/src/scopes.h b/src/scopes.h
index 18db0cdd..a0e56a47 100644
--- a/src/scopes.h
+++ b/src/scopes.h
@@ -95,6 +95,11 @@ class Scope: public ZoneObject {
     GLOBAL_SCOPE    // the top-level scope for a program or a top-level eval
   };
 
+  enum LocalType {
+    PARAMETER,
+    VAR_OR_CONST
+  };
+
   Scope(Scope* outer_scope, Type type);
 
   virtual ~Scope() { }
@@ -134,7 +139,9 @@ class Scope: public ZoneObject {
 
   // Declare a local variable in this scope. If the variable has been
   // declared before, the previously declared variable is returned.
-  virtual Variable* DeclareLocal(Handle<String> name, Variable::Mode mode);
+  virtual Variable* DeclareLocal(Handle<String> name,
+                                 Variable::Mode mode,
+                                 LocalType type);
 
   // Declare an implicit global variable in this scope which must be a
   // global scope.  The variable was introduced (possibly from an inner
@@ -282,6 +289,9 @@ class Scope: public ZoneObject {
   // cases the context parameter is an empty handle.
   void AllocateVariables(Handle<Context> context);
 
+  // Current number of var or const locals.
+  int num_var_or_const() { return num_var_or_const_; }
+
   // Result of variable allocation.
   int num_stack_slots() const { return num_stack_slots_; }
   int num_heap_slots() const { return num_heap_slots_; }
@@ -373,6 +383,9 @@ class Scope: public ZoneObject {
   bool outer_scope_is_eval_scope_;
   bool force_eager_compilation_;
 
+  // Computed as variables are declared.
+  int num_var_or_const_;
+
   // Computed via AllocateVariables; function scopes only.
   int num_stack_slots_;
   int num_heap_slots_;
diff --git a/src/top.cc b/src/top.cc
index a8dba710..842d269b 100644
--- a/src/top.cc
+++ b/src/top.cc
@@ -1,4 +1,4 @@
-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// 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:
@@ -572,6 +572,7 @@ Failure* Isolate::ReThrow(MaybeObject* exception, MessageLocation* location) {
 
   // Set the exception being re-thrown.
   set_pending_exception(exception);
+  if (exception->IsFailure()) return exception->ToFailureUnchecked();
   return Failure::Exception();
 }
 
diff --git a/src/type-info.cc b/src/type-info.cc
index 1940601c..4069c83d 100644
--- a/src/type-info.cc
+++ b/src/type-info.cc
@@ -275,8 +275,6 @@ TypeInfo TypeFeedbackOracle::BinaryType(BinaryOperation* expr) {
         return TypeInfo::Integer32();
       case TRBinaryOpIC::HEAP_NUMBER:
         return TypeInfo::Double();
-      case TRBinaryOpIC::BOTH_STRING:
-        return TypeInfo::String();
       case TRBinaryOpIC::STRING:
       case TRBinaryOpIC::GENERIC:
         return unknown;
diff --git a/src/v8natives.js b/src/v8natives.js
index 4fcf0ac4..429cea5e 100644
--- a/src/v8natives.js
+++ b/src/v8natives.js
@@ -147,17 +147,6 @@ function GlobalEval(x) {
 }
 
 
-// execScript for IE compatibility.
-function GlobalExecScript(expr, lang) {
-  // NOTE: We don't care about the character casing.
-  if (!lang || /javascript/i.test(lang)) {
-    var f = %CompileString(ToString(expr));
-    %_CallFunction(%GlobalReceiver(global), f);
-  }
-  return null;
-}
-
-
 // ----------------------------------------------------------------------------
 
 
@@ -177,8 +166,7 @@ function SetupGlobal() {
     "isFinite", GlobalIsFinite,
     "parseInt", GlobalParseInt,
     "parseFloat", GlobalParseFloat,
-    "eval", GlobalEval,
-    "execScript", GlobalExecScript
+    "eval", GlobalEval
   ));
 }
 
diff --git a/src/version.cc b/src/version.cc
index 25939c2b..71a07db9 100644
--- a/src/version.cc
+++ b/src/version.cc
@@ -33,9 +33,9 @@
 // NOTE these macros are used by the SCons build script so their names
 // cannot be changed without changing the SCons build script.
 #define MAJOR_VERSION     3
-#define MINOR_VERSION     3
-#define BUILD_NUMBER      0
-#define PATCH_LEVEL       1
+#define MINOR_VERSION     2
+#define BUILD_NUMBER      10
+#define PATCH_LEVEL       16
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
 #define IS_CANDIDATE_VERSION 0
diff --git a/src/x64/assembler-x64.cc b/src/x64/assembler-x64.cc
index c06bc0c4..6e4f0050 100644
--- a/src/x64/assembler-x64.cc
+++ b/src/x64/assembler-x64.cc
@@ -1328,7 +1328,7 @@ void Assembler::jmp(Handle<Code> target, RelocInfo::Mode rmode) {
 void Assembler::jmp(NearLabel* L) {
   EnsureSpace ensure_space(this);
   if (L->is_bound()) {
-    const int short_size = sizeof(int8_t);
+    const int short_size = 2;
     int offs = L->pos() - pc_offset();
     ASSERT(offs <= 0);
     ASSERT(is_int8(offs - short_size));
@@ -2540,24 +2540,6 @@ void Assembler::movq(Register dst, XMMRegister src) {
 }
 
 
-void Assembler::movq(XMMRegister dst, XMMRegister src) {
-  EnsureSpace ensure_space(this);
-  if (dst.low_bits() == 4) {
-    // Avoid unnecessary SIB byte.
-    emit(0xf3);
-    emit_optional_rex_32(dst, src);
-    emit(0x0F);
-    emit(0x7e);
-    emit_sse_operand(dst, src);
-  } else {
-    emit(0x66);
-    emit_optional_rex_32(src, dst);
-    emit(0x0F);
-    emit(0xD6);
-    emit_sse_operand(src, dst);
-  }
-}
-
 void Assembler::movdqa(const Operand& dst, XMMRegister src) {
   EnsureSpace ensure_space(this);
   emit(0x66);
@@ -2621,42 +2603,6 @@ void Assembler::movsd(XMMRegister dst, const Operand& src) {
 }
 
 
-void Assembler::movaps(XMMRegister dst, XMMRegister src) {
-  EnsureSpace ensure_space(this);
-  if (src.low_bits() == 4) {
-    // Try to avoid an unnecessary SIB byte.
-    emit_optional_rex_32(src, dst);
-    emit(0x0F);
-    emit(0x29);
-    emit_sse_operand(src, dst);
-  } else {
-    emit_optional_rex_32(dst, src);
-    emit(0x0F);
-    emit(0x28);
-    emit_sse_operand(dst, src);
-  }
-}
-
-
-void Assembler::movapd(XMMRegister dst, XMMRegister src) {
-  EnsureSpace ensure_space(this);
-  if (src.low_bits() == 4) {
-    // Try to avoid an unnecessary SIB byte.
-    emit(0x66);
-    emit_optional_rex_32(src, dst);
-    emit(0x0F);
-    emit(0x29);
-    emit_sse_operand(src, dst);
-  } else {
-    emit(0x66);
-    emit_optional_rex_32(dst, src);
-    emit(0x0F);
-    emit(0x28);
-    emit_sse_operand(dst, src);
-  }
-}
-
-
 void Assembler::movss(XMMRegister dst, const Operand& src) {
   EnsureSpace ensure_space(this);
   emit(0xF3);  // single
@@ -2887,15 +2833,6 @@ void Assembler::xorpd(XMMRegister dst, XMMRegister src) {
 }
 
 
-void Assembler::xorps(XMMRegister dst, XMMRegister src) {
-  EnsureSpace ensure_space(this);
-  emit_optional_rex_32(dst, src);
-  emit(0x0F);
-  emit(0x57);
-  emit_sse_operand(dst, src);
-}
-
-
 void Assembler::sqrtsd(XMMRegister dst, XMMRegister src) {
   EnsureSpace ensure_space(this);
   emit(0xF2);
@@ -2926,21 +2863,6 @@ void Assembler::ucomisd(XMMRegister dst, const Operand& src) {
 }
 
 
-void Assembler::roundsd(XMMRegister dst, XMMRegister src,
-                        Assembler::RoundingMode mode) {
-  ASSERT(CpuFeatures::IsEnabled(SSE4_1));
-  EnsureSpace ensure_space(this);
-  emit(0x66);
-  emit_optional_rex_32(dst, src);
-  emit(0x0f);
-  emit(0x3a);
-  emit(0x0b);
-  emit_sse_operand(dst, src);
-  // Mask precision exeption.
-  emit(static_cast<byte>(mode) | 0x8);
-}
-
-
 void Assembler::movmskpd(Register dst, XMMRegister src) {
   EnsureSpace ensure_space(this);
   emit(0x66);
diff --git a/src/x64/assembler-x64.h b/src/x64/assembler-x64.h
index 8a9938ba..94532778 100644
--- a/src/x64/assembler-x64.h
+++ b/src/x64/assembler-x64.h
@@ -1291,24 +1291,15 @@ class Assembler : public AssemblerBase {
   void movd(Register dst, XMMRegister src);
   void movq(XMMRegister dst, Register src);
   void movq(Register dst, XMMRegister src);
-  void movq(XMMRegister dst, XMMRegister src);
   void extractps(Register dst, XMMRegister src, byte imm8);
 
-  // Don't use this unless it's important to keep the
-  // top half of the destination register unchanged.
-  // Used movaps when moving double values and movq for integer
-  // values in xmm registers.
-  void movsd(XMMRegister dst, XMMRegister src);
-
   void movsd(const Operand& dst, XMMRegister src);
+  void movsd(XMMRegister dst, XMMRegister src);
   void movsd(XMMRegister dst, const Operand& src);
 
   void movdqa(const Operand& dst, XMMRegister src);
   void movdqa(XMMRegister dst, const Operand& src);
 
-  void movapd(XMMRegister dst, XMMRegister src);
-  void movaps(XMMRegister dst, XMMRegister src);
-
   void movss(XMMRegister dst, const Operand& src);
   void movss(const Operand& dst, XMMRegister src);
 
@@ -1340,21 +1331,11 @@ class Assembler : public AssemblerBase {
   void andpd(XMMRegister dst, XMMRegister src);
   void orpd(XMMRegister dst, XMMRegister src);
   void xorpd(XMMRegister dst, XMMRegister src);
-  void xorps(XMMRegister dst, XMMRegister src);
   void sqrtsd(XMMRegister dst, XMMRegister src);
 
   void ucomisd(XMMRegister dst, XMMRegister src);
   void ucomisd(XMMRegister dst, const Operand& src);
 
-  enum RoundingMode {
-    kRoundToNearest = 0x0,
-    kRoundDown      = 0x1,
-    kRoundUp        = 0x2,
-    kRoundToZero    = 0x3
-  };
-
-  void roundsd(XMMRegister dst, XMMRegister src, RoundingMode mode);
-
   void movmskpd(Register dst, XMMRegister src);
 
   // The first argument is the reg field, the second argument is the r/m field.
diff --git a/src/x64/code-stubs-x64.cc b/src/x64/code-stubs-x64.cc
index 76fcc88c..c3653857 100644
--- a/src/x64/code-stubs-x64.cc
+++ b/src/x64/code-stubs-x64.cc
@@ -266,7 +266,7 @@ void ToBooleanStub::Generate(MacroAssembler* masm) {
   __ j(not_equal, &true_result);
   // HeapNumber => false iff +0, -0, or NaN.
   // These three cases set the zero flag when compared to zero using ucomisd.
-  __ xorps(xmm0, xmm0);
+  __ xorpd(xmm0, xmm0);
   __ ucomisd(xmm0, FieldOperand(rax, HeapNumber::kValueOffset));
   __ j(zero, &false_result);
   // Fall through to |true_result|.
@@ -372,9 +372,6 @@ void TypeRecordingBinaryOpStub::Generate(MacroAssembler* masm) {
     case TRBinaryOpIC::ODDBALL:
       GenerateOddballStub(masm);
       break;
-    case TRBinaryOpIC::BOTH_STRING:
-      GenerateBothStringStub(masm);
-      break;
     case TRBinaryOpIC::STRING:
       GenerateStringStub(masm);
       break;
@@ -633,7 +630,7 @@ void TypeRecordingBinaryOpStub::GenerateFloatingPointCode(
         // already loaded heap_number_map.
         __ AllocateInNewSpace(HeapNumber::kSize,
                               rax,
-                              rcx,
+                              rdx,
                               no_reg,
                               &allocation_failed,
                               TAG_OBJECT);
@@ -653,7 +650,7 @@ void TypeRecordingBinaryOpStub::GenerateFloatingPointCode(
         // We need tagged values in rdx and rax for the following code,
         // not int32 in rax and rcx.
         __ Integer32ToSmi(rax, rcx);
-        __ Integer32ToSmi(rdx, rax);
+        __ Integer32ToSmi(rdx, rbx);
         __ jmp(allocation_failure);
       }
       break;
@@ -774,36 +771,6 @@ void TypeRecordingBinaryOpStub::GenerateStringStub(MacroAssembler* masm) {
 }
 
 
-void TypeRecordingBinaryOpStub::GenerateBothStringStub(MacroAssembler* masm) {
-  Label call_runtime;
-  ASSERT(operands_type_ == TRBinaryOpIC::BOTH_STRING);
-  ASSERT(op_ == Token::ADD);
-  // If both arguments are strings, call the string add stub.
-  // Otherwise, do a transition.
-
-  // Registers containing left and right operands respectively.
-  Register left = rdx;
-  Register right = rax;
-
-  // Test if left operand is a string.
-  __ JumpIfSmi(left, &call_runtime);
-  __ CmpObjectType(left, FIRST_NONSTRING_TYPE, rcx);
-  __ j(above_equal, &call_runtime);
-
-  // Test if right operand is a string.
-  __ JumpIfSmi(right, &call_runtime);
-  __ CmpObjectType(right, FIRST_NONSTRING_TYPE, rcx);
-  __ j(above_equal, &call_runtime);
-
-  StringAddStub string_add_stub(NO_STRING_CHECK_IN_STUB);
-  GenerateRegisterArgsPush(masm);
-  __ TailCallStub(&string_add_stub);
-
-  __ bind(&call_runtime);
-  GenerateTypeTransition(masm);
-}
-
-
 void TypeRecordingBinaryOpStub::GenerateOddballStub(MacroAssembler* masm) {
   Label call_runtime;
 
@@ -1602,7 +1569,7 @@ void MathPowStub::Generate(MacroAssembler* masm) {
   __ bind(&no_neg);
 
   // Load xmm1 with 1.
-  __ movaps(xmm1, xmm3);
+  __ movsd(xmm1, xmm3);
   NearLabel while_true;
   NearLabel no_multiply;
 
@@ -1620,8 +1587,8 @@ void MathPowStub::Generate(MacroAssembler* masm) {
   __ j(positive, &allocate_return);
   // Special case if xmm1 has reached infinity.
   __ divsd(xmm3, xmm1);
-  __ movaps(xmm1, xmm3);
-  __ xorps(xmm0, xmm0);
+  __ movsd(xmm1, xmm3);
+  __ xorpd(xmm0, xmm0);
   __ ucomisd(xmm0, xmm1);
   __ j(equal, &call_runtime);
 
@@ -1669,11 +1636,11 @@ void MathPowStub::Generate(MacroAssembler* masm) {
 
   // Calculates reciprocal of square root.
   // sqrtsd returns -0 when input is -0.  ECMA spec requires +0.
-  __ xorps(xmm1, xmm1);
+  __ xorpd(xmm1, xmm1);
   __ addsd(xmm1, xmm0);
   __ sqrtsd(xmm1, xmm1);
   __ divsd(xmm3, xmm1);
-  __ movaps(xmm1, xmm3);
+  __ movsd(xmm1, xmm3);
   __ jmp(&allocate_return);
 
   // Test for 0.5.
@@ -1686,8 +1653,8 @@ void MathPowStub::Generate(MacroAssembler* masm) {
   __ j(not_equal, &call_runtime);
   // Calculates square root.
   // sqrtsd returns -0 when input is -0.  ECMA spec requires +0.
-  __ xorps(xmm1, xmm1);
-  __ addsd(xmm1, xmm0);  // Convert -0 to 0.
+  __ xorpd(xmm1, xmm1);
+  __ addsd(xmm1, xmm0);
   __ sqrtsd(xmm1, xmm1);
 
   __ bind(&allocate_return);
@@ -2363,10 +2330,9 @@ void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm,
   // Heap::GetNumberStringCache.
   Label is_smi;
   Label load_result_from_cache;
-  Factory* factory = masm->isolate()->factory();
   if (!object_is_smi) {
     __ JumpIfSmi(object, &is_smi);
-    __ CheckMap(object, factory->heap_number_map(), not_found, true);
+    __ CheckMap(object, FACTORY->heap_number_map(), not_found, true);
 
     STATIC_ASSERT(8 == kDoubleSize);
     __ movl(scratch, FieldOperand(object, HeapNumber::kValueOffset + 4));
@@ -2453,7 +2419,6 @@ void CompareStub::Generate(MacroAssembler* masm) {
   ASSERT(lhs_.is(no_reg) && rhs_.is(no_reg));
 
   Label check_unequal_objects, done;
-  Factory* factory = masm->isolate()->factory();
 
   // Compare two smis if required.
   if (include_smi_compare_) {
@@ -2501,6 +2466,7 @@ void CompareStub::Generate(MacroAssembler* masm) {
     // Note: if cc_ != equal, never_nan_nan_ is not used.
     // We cannot set rax to EQUAL until just before return because
     // rax must be unchanged on jump to not_identical.
+
     if (never_nan_nan_ && (cc_ == equal)) {
       __ Set(rax, EQUAL);
       __ ret(0);
@@ -2508,7 +2474,7 @@ void CompareStub::Generate(MacroAssembler* masm) {
       NearLabel heap_number;
       // If it's not a heap number, then return equal for (in)equality operator.
       __ Cmp(FieldOperand(rdx, HeapObject::kMapOffset),
-             factory->heap_number_map());
+             FACTORY->heap_number_map());
       __ j(equal, &heap_number);
       if (cc_ != equal) {
         // Call runtime on identical JSObjects.  Otherwise return equal.
@@ -2553,7 +2519,7 @@ void CompareStub::Generate(MacroAssembler* masm) {
 
         // Check if the non-smi operand is a heap number.
         __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
-               factory->heap_number_map());
+               FACTORY->heap_number_map());
         // If heap number, handle it in the slow case.
         __ j(equal, &slow);
         // Return non-equal.  ebx (the lower half of rbx) is not zero.
@@ -3077,9 +3043,14 @@ void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
   __ Load(rax, js_entry_sp);
   __ testq(rax, rax);
   __ j(not_zero, &not_outermost_js);
+  __ Push(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
   __ movq(rax, rbp);
   __ Store(js_entry_sp, rax);
+  Label cont;
+  __ jmp(&cont);
   __ bind(&not_outermost_js);
+  __ Push(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME));
+  __ bind(&cont);
 #endif
 
   // Call a faked try-block that does the invoke.
@@ -3121,27 +3092,21 @@ void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
   __ call(kScratchRegister);
 
   // Unlink this frame from the handler chain.
-  Operand handler_operand =
-      masm->ExternalOperand(ExternalReference(Isolate::k_handler_address,
-                                              isolate));
-  __ pop(handler_operand);
-  // Pop next_sp.
-  __ addq(rsp, Immediate(StackHandlerConstants::kSize - kPointerSize));
+  __ PopTryHandler();
 
+  __ bind(&exit);
 #ifdef ENABLE_LOGGING_AND_PROFILING
-  // If current RBP value is the same as js_entry_sp value, it means that
-  // the current function is the outermost.
-  __ movq(kScratchRegister, js_entry_sp);
-  __ cmpq(rbp, Operand(kScratchRegister, 0));
+  // Check if the current stack frame is marked as the outermost JS frame.
+  __ pop(rbx);
+  __ Cmp(rbx, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
   __ j(not_equal, &not_outermost_js_2);
+  __ movq(kScratchRegister, js_entry_sp);
   __ movq(Operand(kScratchRegister, 0), Immediate(0));
   __ bind(&not_outermost_js_2);
 #endif
 
   // Restore the top frame descriptor from the stack.
-  __ bind(&exit);
-  {
-    Operand c_entry_fp_operand = masm->ExternalOperand(c_entry_fp);
+  { Operand c_entry_fp_operand = masm->ExternalOperand(c_entry_fp);
     __ pop(c_entry_fp_operand);
   }
 
@@ -3484,11 +3449,10 @@ void StringCharCodeAtGenerator::GenerateSlow(
     MacroAssembler* masm, const RuntimeCallHelper& call_helper) {
   __ Abort("Unexpected fallthrough to CharCodeAt slow case");
 
-  Factory* factory = masm->isolate()->factory();
   // Index is not a smi.
   __ bind(&index_not_smi_);
   // If index is a heap number, try converting it to an integer.
-  __ CheckMap(index_, factory->heap_number_map(), index_not_number_, true);
+  __ CheckMap(index_, FACTORY->heap_number_map(), index_not_number_, true);
   call_helper.BeforeCall(masm);
   __ push(object_);
   __ push(index_);
diff --git a/src/x64/code-stubs-x64.h b/src/x64/code-stubs-x64.h
index 3b402802..f97d0996 100644
--- a/src/x64/code-stubs-x64.h
+++ b/src/x64/code-stubs-x64.h
@@ -152,7 +152,6 @@ class TypeRecordingBinaryOpStub: public CodeStub {
   void GenerateHeapNumberStub(MacroAssembler* masm);
   void GenerateOddballStub(MacroAssembler* masm);
   void GenerateStringStub(MacroAssembler* masm);
-  void GenerateBothStringStub(MacroAssembler* masm);
   void GenerateGenericStub(MacroAssembler* masm);
 
   void GenerateHeapResultAllocation(MacroAssembler* masm, Label* alloc_failure);
diff --git a/src/x64/disasm-x64.cc b/src/x64/disasm-x64.cc
index 82bc6ef9..2b7b7b7d 100644
--- a/src/x64/disasm-x64.cc
+++ b/src/x64/disasm-x64.cc
@@ -1021,26 +1021,12 @@ int DisassemblerX64::TwoByteOpcodeInstruction(byte* data) {
         current += PrintRightOperand(current);
         AppendToBuffer(", %s, %d", NameOfCPURegister(regop), (*current) & 3);
         current += 1;
-      } else if (third_byte == 0x0b) {
-        get_modrm(*current, &mod, &regop, &rm);
-         // roundsd xmm, xmm/m64, imm8
-        AppendToBuffer("roundsd %s, ", NameOfCPURegister(regop));
-        current += PrintRightOperand(current);
-        AppendToBuffer(", %d", (*current) & 3);
-        current += 1;
       } else {
         UnimplementedInstruction();
       }
     } else {
       get_modrm(*current, &mod, &regop, &rm);
-      if (opcode == 0x28) {
-        AppendToBuffer("movapd %s, ", NameOfXMMRegister(regop));
-        current += PrintRightXMMOperand(current);
-      } else if (opcode == 0x29) {
-        AppendToBuffer("movapd ");
-        current += PrintRightXMMOperand(current);
-        AppendToBuffer(", %s", NameOfXMMRegister(regop));
-      } else if (opcode == 0x6E) {
+      if (opcode == 0x6E) {
         AppendToBuffer("mov%c %s,",
                        rex_w() ? 'q' : 'd',
                        NameOfXMMRegister(regop));
@@ -1058,10 +1044,6 @@ int DisassemblerX64::TwoByteOpcodeInstruction(byte* data) {
         AppendToBuffer("movdqa ");
         current += PrintRightXMMOperand(current);
         AppendToBuffer(", %s", NameOfXMMRegister(regop));
-      } else if (opcode == 0xD6) {
-        AppendToBuffer("movq ");
-        current += PrintRightXMMOperand(current);
-        AppendToBuffer(", %s", NameOfXMMRegister(regop));
       } else {
         const char* mnemonic = "?";
         if (opcode == 0x50) {
@@ -1163,11 +1145,6 @@ int DisassemblerX64::TwoByteOpcodeInstruction(byte* data) {
       get_modrm(*current, &mod, &regop, &rm);
       AppendToBuffer("cvtss2sd %s,", NameOfXMMRegister(regop));
       current += PrintRightXMMOperand(current);
-    } else if (opcode == 0x7E) {
-      int mod, regop, rm;
-      get_modrm(*current, &mod, &regop, &rm);
-      AppendToBuffer("movq %s, ", NameOfXMMRegister(regop));
-      current += PrintRightXMMOperand(current);
     } else {
       UnimplementedInstruction();
     }
@@ -1185,22 +1162,6 @@ int DisassemblerX64::TwoByteOpcodeInstruction(byte* data) {
       current += 4;
     }  // else no immediate displacement.
     AppendToBuffer("nop");
-
-  } else if (opcode == 28) {
-    // movaps xmm, xmm/m128
-    int mod, regop, rm;
-    get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("movaps %s, ", NameOfXMMRegister(regop));
-    current += PrintRightXMMOperand(current);
-
-  } else if (opcode == 29) {
-    // movaps xmm/m128, xmm
-    int mod, regop, rm;
-    get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("movaps");
-    current += PrintRightXMMOperand(current);
-    AppendToBuffer(", %s", NameOfXMMRegister(regop));
-
   } else if (opcode == 0xA2 || opcode == 0x31) {
     // RDTSC or CPUID
     AppendToBuffer("%s", mnemonic);
@@ -1212,13 +1173,6 @@ int DisassemblerX64::TwoByteOpcodeInstruction(byte* data) {
     byte_size_operand_ = idesc.byte_size_operation;
     current += PrintOperands(idesc.mnem, idesc.op_order_, current);
 
-  } else if (opcode == 57) {
-    // xoprps xmm, xmm/m128
-    int mod, regop, rm;
-    get_modrm(*current, &mod, &regop, &rm);
-    AppendToBuffer("xorps %s, ", NameOfXMMRegister(regop));
-    current += PrintRightXMMOperand(current);
-
   } else if ((opcode & 0xF0) == 0x80) {
     // Jcc: Conditional jump (branch).
     current = data + JumpConditional(data);
diff --git a/src/x64/full-codegen-x64.cc b/src/x64/full-codegen-x64.cc
index d5fb7da7..6933d780 100644
--- a/src/x64/full-codegen-x64.cc
+++ b/src/x64/full-codegen-x64.cc
@@ -1398,13 +1398,17 @@ void FullCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
         // Fall through.
       case ObjectLiteral::Property::COMPUTED:
         if (key->handle()->IsSymbol()) {
-          VisitForAccumulatorValue(value);
-          __ Move(rcx, key->handle());
-          __ movq(rdx, Operand(rsp, 0));
           if (property->emit_store()) {
-            Handle<Code> ic = isolate()->builtins()->StoreIC_Initialize();
+            VisitForAccumulatorValue(value);
+            __ Move(rcx, key->handle());
+            __ movq(rdx, Operand(rsp, 0));
+            Handle<Code> ic = is_strict_mode()
+                ? isolate()->builtins()->StoreIC_Initialize_Strict()
+                : isolate()->builtins()->StoreIC_Initialize();
             EmitCallIC(ic, RelocInfo::CODE_TARGET);
             PrepareForBailoutForId(key->id(), NO_REGISTERS);
+          } else {
+            VisitForEffect(value);
           }
           break;
         }
@@ -2758,7 +2762,7 @@ void FullCodeGenerator::EmitRandomHeapNumber(ZoneList<Expression*>* args) {
   __ movd(xmm1, rcx);
   __ movd(xmm0, rax);
   __ cvtss2sd(xmm1, xmm1);
-  __ xorps(xmm0, xmm1);
+  __ xorpd(xmm0, xmm1);
   __ subsd(xmm0, xmm1);
   __ movsd(FieldOperand(rbx, HeapNumber::kValueOffset), xmm0);
 
@@ -3043,14 +3047,15 @@ void FullCodeGenerator::EmitMathSqrt(ZoneList<Expression*>* args) {
 void FullCodeGenerator::EmitCallFunction(ZoneList<Expression*>* args) {
   ASSERT(args->length() >= 2);
 
-  int arg_count = args->length() - 2;  // 2 ~ receiver and function.
-  for (int i = 0; i < arg_count + 1; i++) {
-    VisitForStackValue(args->at(i));
+  int arg_count = args->length() - 2;  // For receiver and function.
+  VisitForStackValue(args->at(0));  // Receiver.
+  for (int i = 0; i < arg_count; i++) {
+    VisitForStackValue(args->at(i + 1));
   }
-  VisitForAccumulatorValue(args->last());  // Function.
+  VisitForAccumulatorValue(args->at(arg_count + 1));  // Function.
 
-  // InvokeFunction requires the function in rdi. Move it in there.
-  __ movq(rdi, result_register());
+  // InvokeFunction requires function in rdi. Move it in there.
+  if (!result_register().is(rdi)) __ movq(rdi, result_register());
   ParameterCount count(arg_count);
   __ InvokeFunction(rdi, count, CALL_FUNCTION);
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
@@ -4231,7 +4236,30 @@ void FullCodeGenerator::EmitCallIC(Handle<Code> ic, RelocInfo::Mode mode) {
     default:
       break;
   }
+
   __ call(ic, mode);
+
+  // Crankshaft doesn't need patching of inlined loads and stores.
+  // When compiling the snapshot we need to produce code that works
+  // with and without Crankshaft.
+  if (V8::UseCrankshaft() && !Serializer::enabled()) {
+    return;
+  }
+
+  // If we're calling a (keyed) load or store stub, we have to mark
+  // the call as containing no inlined code so we will not attempt to
+  // patch it.
+  switch (ic->kind()) {
+    case Code::LOAD_IC:
+    case Code::KEYED_LOAD_IC:
+    case Code::STORE_IC:
+    case Code::KEYED_STORE_IC:
+      __ nop();  // Signals no inlined code.
+      break;
+    default:
+      // Do nothing.
+      break;
+  }
 }
 
 
@@ -4252,6 +4280,7 @@ void FullCodeGenerator::EmitCallIC(Handle<Code> ic, JumpPatchSite* patch_site) {
     default:
       break;
   }
+
   __ call(ic, RelocInfo::CODE_TARGET);
   if (patch_site != NULL && patch_site->is_bound()) {
     patch_site->EmitPatchInfo();
diff --git a/src/x64/ic-x64.cc b/src/x64/ic-x64.cc
index 5ed89b5d..5ca56ac7 100644
--- a/src/x64/ic-x64.cc
+++ b/src/x64/ic-x64.cc
@@ -381,6 +381,11 @@ static void GenerateNumberDictionaryLoad(MacroAssembler* masm,
 }
 
 
+// The offset from the inlined patch site to the start of the inlined
+// load instruction.
+const int LoadIC::kOffsetToLoadInstruction = 20;
+
+
 void LoadIC::GenerateArrayLength(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- rax    : receiver
@@ -1292,6 +1297,130 @@ void LoadIC::GenerateMiss(MacroAssembler* masm) {
 }
 
 
+bool LoadIC::PatchInlinedLoad(Address address, Object* map, int offset) {
+  if (V8::UseCrankshaft()) return false;
+
+  // The address of the instruction following the call.
+  Address test_instruction_address =
+      address + Assembler::kCallTargetAddressOffset;
+  // If the instruction following the call is not a test rax, nothing
+  // was inlined.
+  if (*test_instruction_address != Assembler::kTestEaxByte) return false;
+
+  Address delta_address = test_instruction_address + 1;
+  // The delta to the start of the map check instruction.
+  int delta = *reinterpret_cast<int*>(delta_address);
+
+  // The map address is the last 8 bytes of the 10-byte
+  // immediate move instruction, so we add 2 to get the
+  // offset to the last 8 bytes.
+  Address map_address = test_instruction_address + delta + 2;
+  *(reinterpret_cast<Object**>(map_address)) = map;
+
+  // The offset is in the 32-bit displacement of a seven byte
+  // memory-to-register move instruction (REX.W 0x88 ModR/M disp32),
+  // so we add 3 to get the offset of the displacement.
+  Address offset_address =
+      test_instruction_address + delta + kOffsetToLoadInstruction + 3;
+  *reinterpret_cast<int*>(offset_address) = offset - kHeapObjectTag;
+  return true;
+}
+
+
+bool LoadIC::PatchInlinedContextualLoad(Address address,
+                                        Object* map,
+                                        Object* cell,
+                                        bool is_dont_delete) {
+  // TODO(<bug#>): implement this.
+  return false;
+}
+
+
+bool StoreIC::PatchInlinedStore(Address address, Object* map, int offset) {
+  if (V8::UseCrankshaft()) return false;
+
+  // The address of the instruction following the call.
+  Address test_instruction_address =
+      address + Assembler::kCallTargetAddressOffset;
+
+  // If the instruction following the call is not a test rax, nothing
+  // was inlined.
+  if (*test_instruction_address != Assembler::kTestEaxByte) return false;
+
+  // Extract the encoded deltas from the test rax instruction.
+  Address encoded_offsets_address = test_instruction_address + 1;
+  int encoded_offsets = *reinterpret_cast<int*>(encoded_offsets_address);
+  int delta_to_map_check = -(encoded_offsets & 0xFFFF);
+  int delta_to_record_write = encoded_offsets >> 16;
+
+  // Patch the map to check. The map address is the last 8 bytes of
+  // the 10-byte immediate move instruction.
+  Address map_check_address = test_instruction_address + delta_to_map_check;
+  Address map_address = map_check_address + 2;
+  *(reinterpret_cast<Object**>(map_address)) = map;
+
+  // Patch the offset in the store instruction. The offset is in the
+  // last 4 bytes of a 7 byte register-to-memory move instruction.
+  Address offset_address =
+      map_check_address + StoreIC::kOffsetToStoreInstruction + 3;
+  // The offset should have initial value (kMaxInt - 1), cleared value
+  // (-1) or we should be clearing the inlined version.
+  ASSERT(*reinterpret_cast<int*>(offset_address) == kMaxInt - 1 ||
+         *reinterpret_cast<int*>(offset_address) == -1 ||
+         (offset == 0 && map == HEAP->null_value()));
+  *reinterpret_cast<int*>(offset_address) = offset - kHeapObjectTag;
+
+  // Patch the offset in the write-barrier code. The offset is the
+  // last 4 bytes of a 7 byte lea instruction.
+  offset_address = map_check_address + delta_to_record_write + 3;
+  // The offset should have initial value (kMaxInt), cleared value
+  // (-1) or we should be clearing the inlined version.
+  ASSERT(*reinterpret_cast<int*>(offset_address) == kMaxInt ||
+         *reinterpret_cast<int*>(offset_address) == -1 ||
+         (offset == 0 && map == HEAP->null_value()));
+  *reinterpret_cast<int*>(offset_address) = offset - kHeapObjectTag;
+
+  return true;
+}
+
+
+static bool PatchInlinedMapCheck(Address address, Object* map) {
+  if (V8::UseCrankshaft()) return false;
+
+  // Arguments are address of start of call sequence that called
+  // the IC,
+  Address test_instruction_address =
+      address + Assembler::kCallTargetAddressOffset;
+  // The keyed load has a fast inlined case if the IC call instruction
+  // is immediately followed by a test instruction.
+  if (*test_instruction_address != Assembler::kTestEaxByte) return false;
+
+  // Fetch the offset from the test instruction to the map compare
+  // instructions (starting with the 64-bit immediate mov of the map
+  // address). This offset is stored in the last 4 bytes of the 5
+  // byte test instruction.
+  Address delta_address = test_instruction_address + 1;
+  int delta = *reinterpret_cast<int*>(delta_address);
+  // Compute the map address.  The map address is in the last 8 bytes
+  // of the 10-byte immediate mov instruction (incl. REX prefix), so we add 2
+  // to the offset to get the map address.
+  Address map_address = test_instruction_address + delta + 2;
+  // Patch the map check.
+  *(reinterpret_cast<Object**>(map_address)) = map;
+  return true;
+}
+
+
+bool KeyedLoadIC::PatchInlinedLoad(Address address, Object* map) {
+  return PatchInlinedMapCheck(address, map);
+}
+
+
+bool KeyedStoreIC::PatchInlinedStore(Address address, Object* map) {
+  return PatchInlinedMapCheck(address, map);
+}
+
+
 void KeyedLoadIC::GenerateMiss(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- rax    : key
@@ -1374,6 +1503,11 @@ void StoreIC::GenerateMiss(MacroAssembler* masm) {
 }
 
 
+// The offset from the inlined patch site to the start of the inlined
+// store instruction.
+const int StoreIC::kOffsetToStoreInstruction = 20;
+
+
 void StoreIC::GenerateArrayLength(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- rax    : value
diff --git a/src/x64/lithium-codegen-x64.cc b/src/x64/lithium-codegen-x64.cc
index c242874c..202e7a24 100644
--- a/src/x64/lithium-codegen-x64.cc
+++ b/src/x64/lithium-codegen-x64.cc
@@ -91,7 +91,7 @@ bool LCodeGen::GenerateCode() {
 
 void LCodeGen::FinishCode(Handle<Code> code) {
   ASSERT(is_done());
-  code->set_stack_slots(GetStackSlotCount());
+  code->set_stack_slots(StackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
   PopulateDeoptimizationData(code);
   Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(code);
@@ -146,7 +146,7 @@ bool LCodeGen::GeneratePrologue() {
   __ push(rdi);  // Callee's JS function.
 
   // Reserve space for the stack slots needed by the code.
-  int slots = GetStackSlotCount();
+  int slots = StackSlotCount();
   if (slots > 0) {
     if (FLAG_debug_code) {
       __ Set(rax, slots);
@@ -290,7 +290,7 @@ bool LCodeGen::GenerateSafepointTable() {
   while (byte_count-- > 0) {
     __ int3();
   }
-  safepoints_.Emit(masm(), GetStackSlotCount());
+  safepoints_.Emit(masm(), StackSlotCount());
   return !is_aborted();
 }
 
@@ -418,7 +418,7 @@ void LCodeGen::AddToTranslation(Translation* translation,
     translation->StoreDoubleStackSlot(op->index());
   } else if (op->IsArgument()) {
     ASSERT(is_tagged);
-    int src_index = GetStackSlotCount() + op->index();
+    int src_index = StackSlotCount() + op->index();
     translation->StoreStackSlot(src_index);
   } else if (op->IsRegister()) {
     Register reg = ToRegister(op);
@@ -1111,7 +1111,7 @@ void LCodeGen::DoConstantD(LConstantD* instr) {
   // Use xor to produce +0.0 in a fast and compact way, but avoid to
   // do so if the constant is -0.0.
   if (int_val == 0) {
-    __ xorps(res, res);
+    __ xorpd(res, res);
   } else {
     Register tmp = ToRegister(instr->TempAt(0));
     __ Set(tmp, int_val);
@@ -1223,12 +1223,12 @@ void LCodeGen::DoArithmeticD(LArithmeticD* instr) {
       break;
     case Token::MOD:
       __ PrepareCallCFunction(2);
-      __ movaps(xmm0, left);
+      __ movsd(xmm0, left);
       ASSERT(right.is(xmm1));
       __ CallCFunction(
           ExternalReference::double_fp_operation(Token::MOD, isolate()), 2);
       __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
-      __ movaps(result, xmm0);
+      __ movsd(result, xmm0);
       break;
     default:
       UNREACHABLE();
@@ -1287,7 +1287,7 @@ void LCodeGen::DoBranch(LBranch* instr) {
     EmitBranch(true_block, false_block, not_zero);
   } else if (r.IsDouble()) {
     XMMRegister reg = ToDoubleRegister(instr->InputAt(0));
-    __ xorps(xmm0, xmm0);
+    __ xorpd(xmm0, xmm0);
     __ ucomisd(reg, xmm0);
     EmitBranch(true_block, false_block, not_equal);
   } else {
@@ -1322,7 +1322,7 @@ void LCodeGen::DoBranch(LBranch* instr) {
 
       // HeapNumber => false iff +0, -0, or NaN. These three cases set the
       // zero flag when compared to zero using ucomisd.
-      __ xorps(xmm0, xmm0);
+      __ xorpd(xmm0, xmm0);
       __ ucomisd(xmm0, FieldOperand(reg, HeapNumber::kValueOffset));
       __ j(zero, false_label);
       __ jmp(true_label);
@@ -2058,7 +2058,7 @@ void LCodeGen::DoReturn(LReturn* instr) {
   }
   __ movq(rsp, rbp);
   __ pop(rbp);
-  __ Ret((GetParameterCount() + 1) * kPointerSize, rcx);
+  __ Ret((ParameterCount() + 1) * kPointerSize, rcx);
 }
 
 
@@ -2507,19 +2507,25 @@ void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
                                          env->deoptimization_index());
   v8::internal::ParameterCount actual(rax);
   __ InvokeFunction(function, actual, CALL_FUNCTION, &safepoint_generator);
-  __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
 }
 
 
 void LCodeGen::DoPushArgument(LPushArgument* instr) {
   LOperand* argument = instr->InputAt(0);
-  EmitPushTaggedOperand(argument);
+  if (argument->IsConstantOperand()) {
+    EmitPushConstantOperand(argument);
+  } else if (argument->IsRegister()) {
+    __ push(ToRegister(argument));
+  } else {
+    ASSERT(!argument->IsDoubleRegister());
+    __ push(ToOperand(argument));
+  }
 }
 
 
 void LCodeGen::DoContext(LContext* instr) {
   Register result = ToRegister(instr->result());
-  __ movq(result, rsi);
+  __ movq(result, Operand(rbp, StandardFrameConstants::kContextOffset));
 }
 
 
@@ -2671,7 +2677,7 @@ void LCodeGen::DoMathAbs(LUnaryMathOperation* instr) {
   if (r.IsDouble()) {
     XMMRegister scratch = xmm0;
     XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));
-    __ xorps(scratch, scratch);
+    __ xorpd(scratch, scratch);
     __ subsd(scratch, input_reg);
     __ andpd(input_reg, scratch);
   } else if (r.IsInteger32()) {
@@ -2682,9 +2688,7 @@ void LCodeGen::DoMathAbs(LUnaryMathOperation* instr) {
     Register input_reg = ToRegister(instr->InputAt(0));
     // Smi check.
     __ JumpIfNotSmi(input_reg, deferred->entry());
-    __ SmiToInteger32(input_reg, input_reg);
     EmitIntegerMathAbs(instr);
-    __ Integer32ToSmi(input_reg, input_reg);
     __ bind(deferred->exit());
   }
 }
@@ -2694,36 +2698,21 @@ void LCodeGen::DoMathFloor(LUnaryMathOperation* instr) {
   XMMRegister xmm_scratch = xmm0;
   Register output_reg = ToRegister(instr->result());
   XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));
+  __ xorpd(xmm_scratch, xmm_scratch);  // Zero the register.
+  __ ucomisd(input_reg, xmm_scratch);
 
-  if (CpuFeatures::IsSupported(SSE4_1)) {
-    CpuFeatures::Scope scope(SSE4_1);
-    if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-      // Deoptimize if minus zero.
-      __ movq(output_reg, input_reg);
-      __ subq(output_reg, Immediate(1));
-      DeoptimizeIf(overflow, instr->environment());
-    }
-    __ roundsd(xmm_scratch, input_reg, Assembler::kRoundDown);
-    __ cvttsd2si(output_reg, xmm_scratch);
-    __ cmpl(output_reg, Immediate(0x80000000));
-    DeoptimizeIf(equal, instr->environment());
+  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+    DeoptimizeIf(below_equal, instr->environment());
   } else {
-    __ xorps(xmm_scratch, xmm_scratch);  // Zero the register.
-    __ ucomisd(input_reg, xmm_scratch);
-
-    if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-      DeoptimizeIf(below_equal, instr->environment());
-    } else {
-      DeoptimizeIf(below, instr->environment());
-    }
+    DeoptimizeIf(below, instr->environment());
+  }
 
-    // Use truncating instruction (OK because input is positive).
-    __ cvttsd2si(output_reg, input_reg);
+  // Use truncating instruction (OK because input is positive).
+  __ cvttsd2si(output_reg, input_reg);
 
-    // Overflow is signalled with minint.
-    __ cmpl(output_reg, Immediate(0x80000000));
-    DeoptimizeIf(equal, instr->environment());
-  }
+  // Overflow is signalled with minint.
+  __ cmpl(output_reg, Immediate(0x80000000));
+  DeoptimizeIf(equal, instr->environment());
 }
 
 
@@ -2732,44 +2721,33 @@ void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {
   Register output_reg = ToRegister(instr->result());
   XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));
 
-  Label done;
   // xmm_scratch = 0.5
   __ movq(kScratchRegister, V8_INT64_C(0x3FE0000000000000), RelocInfo::NONE);
   __ movq(xmm_scratch, kScratchRegister);
-  NearLabel below_half;
-  __ ucomisd(xmm_scratch, input_reg);
-  __ j(above, &below_half);  // If input_reg is NaN, this doesn't jump.
+
   // input = input + 0.5
-  // This addition might give a result that isn't the correct for
-  // rounding, due to loss of precision, but only for a number that's
-  // so big that the conversion below will overflow anyway.
   __ addsd(input_reg, xmm_scratch);
-  // Compute Math.floor(input).
-  // Use truncating instruction (OK because input is positive).
-  __ cvttsd2si(output_reg, input_reg);
-  // Overflow is signalled with minint.
-  __ cmpl(output_reg, Immediate(0x80000000));
-  DeoptimizeIf(equal, instr->environment());
-  __ jmp(&done);
 
-  __ bind(&below_half);
+  // We need to return -0 for the input range [-0.5, 0[, otherwise
+  // compute Math.floor(value + 0.5).
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-    // Bailout if negative (including -0).
-    __ movq(output_reg, input_reg);
-    __ testq(output_reg, output_reg);
-    DeoptimizeIf(negative, instr->environment());
+    __ ucomisd(input_reg, xmm_scratch);
+    DeoptimizeIf(below_equal, instr->environment());
   } else {
-    // Bailout if below -0.5, otherwise round to (positive) zero, even
-    // if negative.
-    // xmm_scrach = -0.5
-    __ movq(kScratchRegister, V8_INT64_C(0xBFE0000000000000), RelocInfo::NONE);
-    __ movq(xmm_scratch, kScratchRegister);
+    // If we don't need to bailout on -0, we check only bailout
+    // on negative inputs.
+    __ xorpd(xmm_scratch, xmm_scratch);  // Zero the register.
     __ ucomisd(input_reg, xmm_scratch);
     DeoptimizeIf(below, instr->environment());
   }
-  __ xorl(output_reg, output_reg);
 
-  __ bind(&done);
+  // Compute Math.floor(value + 0.5).
+  // Use truncating instruction (OK because input is positive).
+  __ cvttsd2si(output_reg, input_reg);
+
+  // Overflow is signalled with minint.
+  __ cmpl(output_reg, Immediate(0x80000000));
+  DeoptimizeIf(equal, instr->environment());
 }
 
 
@@ -2784,7 +2762,7 @@ void LCodeGen::DoMathPowHalf(LUnaryMathOperation* instr) {
   XMMRegister xmm_scratch = xmm0;
   XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));
   ASSERT(ToDoubleRegister(instr->result()).is(input_reg));
-  __ xorps(xmm_scratch, xmm_scratch);
+  __ xorpd(xmm_scratch, xmm_scratch);
   __ addsd(input_reg, xmm_scratch);  // Convert -0 to +0.
   __ sqrtsd(input_reg, input_reg);
 }
@@ -2800,7 +2778,7 @@ void LCodeGen::DoPower(LPower* instr) {
   if (exponent_type.IsDouble()) {
     __ PrepareCallCFunction(2);
     // Move arguments to correct registers
-    __ movaps(xmm0, left_reg);
+    __ movsd(xmm0, left_reg);
     ASSERT(ToDoubleRegister(right).is(xmm1));
     __ CallCFunction(
         ExternalReference::power_double_double_function(isolate()), 2);
@@ -2808,7 +2786,7 @@ void LCodeGen::DoPower(LPower* instr) {
     __ PrepareCallCFunction(2);
     // Move arguments to correct registers: xmm0 and edi (not rdi).
     // On Windows, the registers are xmm0 and edx.
-    __ movaps(xmm0, left_reg);
+    __ movsd(xmm0, left_reg);
 #ifdef _WIN64
     ASSERT(ToRegister(right).is(rdx));
 #else
@@ -2834,13 +2812,13 @@ void LCodeGen::DoPower(LPower* instr) {
     __ bind(&call);
     __ PrepareCallCFunction(2);
     // Move arguments to correct registers xmm0 and xmm1.
-    __ movaps(xmm0, left_reg);
+    __ movsd(xmm0, left_reg);
     // Right argument is already in xmm1.
     __ CallCFunction(
         ExternalReference::power_double_double_function(isolate()), 2);
   }
   // Return value is in xmm0.
-  __ movaps(result_reg, xmm0);
+  __ movsd(result_reg, xmm0);
   // Restore context register.
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
 }
@@ -2903,21 +2881,6 @@ void LCodeGen::DoUnaryMathOperation(LUnaryMathOperation* instr) {
 }
 
 
-void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
-  ASSERT(ToRegister(instr->function()).is(rdi));
-  ASSERT(instr->HasPointerMap());
-  ASSERT(instr->HasDeoptimizationEnvironment());
-  LPointerMap* pointers = instr->pointer_map();
-  LEnvironment* env = instr->deoptimization_environment();
-  RecordPosition(pointers->position());
-  RegisterEnvironmentForDeoptimization(env);
-  SafepointGenerator generator(this, pointers, env->deoptimization_index());
-  ParameterCount count(instr->arity());
-  __ InvokeFunction(rdi, count, CALL_FUNCTION, &generator);
-  __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
-}
-
-
 void LCodeGen::DoCallKeyed(LCallKeyed* instr) {
   ASSERT(ToRegister(instr->key()).is(rcx));
   ASSERT(ToRegister(instr->result()).is(rax));
@@ -3124,14 +3087,6 @@ void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
 }
 
 
-void LCodeGen::DoStringAdd(LStringAdd* instr) {
-  EmitPushTaggedOperand(instr->left());
-  EmitPushTaggedOperand(instr->right());
-  StringAddStub stub(NO_STRING_CHECK_IN_STUB);
-  CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
-}
-
-
 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
   class DeferredStringCharCodeAt: public LDeferredCode {
    public:
@@ -3422,7 +3377,7 @@ void LCodeGen::EmitNumberUntagD(Register input_reg,
   DeoptimizeIf(not_equal, env);
 
   // Convert undefined to NaN. Compute NaN as 0/0.
-  __ xorps(result_reg, result_reg);
+  __ xorpd(result_reg, result_reg);
   __ divsd(result_reg, result_reg);
   __ jmp(&done);
 
@@ -3791,7 +3746,14 @@ void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {
 
 void LCodeGen::DoTypeof(LTypeof* instr) {
   LOperand* input = instr->InputAt(0);
-  EmitPushTaggedOperand(input);
+  if (input->IsConstantOperand()) {
+    __ Push(ToHandle(LConstantOperand::cast(input)));
+  } else if (input->IsRegister()) {
+    __ push(ToRegister(input));
+  } else {
+    ASSERT(input->IsStackSlot());
+    __ push(ToOperand(input));
+  }
   CallRuntime(Runtime::kTypeof, 1, instr);
 }
 
@@ -3819,14 +3781,19 @@ void LCodeGen::DoTypeofIs(LTypeofIs* instr) {
 }
 
 
-void LCodeGen::EmitPushTaggedOperand(LOperand* operand) {
-  ASSERT(!operand->IsDoubleRegister());
-  if (operand->IsConstantOperand()) {
-    __ Push(ToHandle(LConstantOperand::cast(operand)));
-  } else if (operand->IsRegister()) {
-    __ push(ToRegister(operand));
+void LCodeGen::EmitPushConstantOperand(LOperand* operand) {
+  ASSERT(operand->IsConstantOperand());
+  LConstantOperand* const_op = LConstantOperand::cast(operand);
+  Handle<Object> literal = chunk_->LookupLiteral(const_op);
+  Representation r = chunk_->LookupLiteralRepresentation(const_op);
+  if (r.IsInteger32()) {
+    ASSERT(literal->IsNumber());
+    __ push(Immediate(static_cast<int32_t>(literal->Number())));
+  } else if (r.IsDouble()) {
+    Abort("unsupported double immediate");
   } else {
-    __ push(ToOperand(operand));
+    ASSERT(r.IsTagged());
+    __ Push(literal);
   }
 }
 
@@ -3972,8 +3939,20 @@ void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
 void LCodeGen::DoDeleteProperty(LDeleteProperty* instr) {
   LOperand* obj = instr->object();
   LOperand* key = instr->key();
-  EmitPushTaggedOperand(obj);
-  EmitPushTaggedOperand(key);
+  // Push object.
+  if (obj->IsRegister()) {
+    __ push(ToRegister(obj));
+  } else {
+    __ push(ToOperand(obj));
+  }
+  // Push key.
+  if (key->IsConstantOperand()) {
+    EmitPushConstantOperand(key);
+  } else if (key->IsRegister()) {
+    __ push(ToRegister(key));
+  } else {
+    __ push(ToOperand(key));
+  }
   ASSERT(instr->HasPointerMap() && instr->HasDeoptimizationEnvironment());
   LPointerMap* pointers = instr->pointer_map();
   LEnvironment* env = instr->deoptimization_environment();
diff --git a/src/x64/lithium-codegen-x64.h b/src/x64/lithium-codegen-x64.h
index 96e0a0f5..34277f6e 100644
--- a/src/x64/lithium-codegen-x64.h
+++ b/src/x64/lithium-codegen-x64.h
@@ -141,8 +141,8 @@ class LCodeGen BASE_EMBEDDED {
                        Register input,
                        Register temporary);
 
-  int GetStackSlotCount() const { return chunk()->spill_slot_count(); }
-  int GetParameterCount() const { return scope()->num_parameters(); }
+  int StackSlotCount() const { return chunk()->spill_slot_count(); }
+  int ParameterCount() const { return scope()->num_parameters(); }
 
   void Abort(const char* format, ...);
   void Comment(const char* format, ...);
@@ -268,9 +268,8 @@ class LCodeGen BASE_EMBEDDED {
                      Handle<Map> type,
                      Handle<String> name);
 
-  // Emits code for pushing either a tagged constant, a (non-double)
-  // register, or a stack slot operand.
-  void EmitPushTaggedOperand(LOperand* operand);
+  // Emits code for pushing a constant operand.
+  void EmitPushConstantOperand(LOperand* operand);
 
   struct JumpTableEntry {
     explicit inline JumpTableEntry(Address entry)
diff --git a/src/x64/lithium-gap-resolver-x64.cc b/src/x64/lithium-gap-resolver-x64.cc
index c3c617c4..cedd0256 100644
--- a/src/x64/lithium-gap-resolver-x64.cc
+++ b/src/x64/lithium-gap-resolver-x64.cc
@@ -214,7 +214,7 @@ void LGapResolver::EmitMove(int index) {
   } else if (source->IsDoubleRegister()) {
     XMMRegister src = cgen_->ToDoubleRegister(source);
     if (destination->IsDoubleRegister()) {
-      __ movaps(cgen_->ToDoubleRegister(destination), src);
+      __ movsd(cgen_->ToDoubleRegister(destination), src);
     } else {
       ASSERT(destination->IsDoubleStackSlot());
       __ movsd(cgen_->ToOperand(destination), src);
@@ -273,9 +273,9 @@ void LGapResolver::EmitSwap(int index) {
     // Swap two double registers.
     XMMRegister source_reg = cgen_->ToDoubleRegister(source);
     XMMRegister destination_reg = cgen_->ToDoubleRegister(destination);
-    __ movaps(xmm0, source_reg);
-    __ movaps(source_reg, destination_reg);
-    __ movaps(destination_reg, xmm0);
+    __ movsd(xmm0, source_reg);
+    __ movsd(source_reg, destination_reg);
+    __ movsd(destination_reg, xmm0);
 
   } else if (source->IsDoubleRegister() || destination->IsDoubleRegister()) {
     // Swap a double register and a double stack slot.
diff --git a/src/x64/lithium-x64.cc b/src/x64/lithium-x64.cc
index 620bbc94..07ca3a51 100644
--- a/src/x64/lithium-x64.cc
+++ b/src/x64/lithium-x64.cc
@@ -71,21 +71,22 @@ void LOsrEntry::MarkSpilledDoubleRegister(int allocation_index,
 
 #ifdef DEBUG
 void LInstruction::VerifyCall() {
-  // Call instructions can use only fixed registers as temporaries and
-  // outputs because all registers are blocked by the calling convention.
-  // Inputs operands must use a fixed register or use-at-start policy or
-  // a non-register policy.
+  // Call instructions can use only fixed registers as
+  // temporaries and outputs because all registers
+  // are blocked by the calling convention.
+  // Inputs must use a fixed register.
   ASSERT(Output() == NULL ||
          LUnallocated::cast(Output())->HasFixedPolicy() ||
          !LUnallocated::cast(Output())->HasRegisterPolicy());
   for (UseIterator it(this); it.HasNext(); it.Advance()) {
-    LUnallocated* operand = LUnallocated::cast(it.Next());
-    ASSERT(operand->HasFixedPolicy() ||
-           operand->IsUsedAtStart());
+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
   }
   for (TempIterator it(this); it.HasNext(); it.Advance()) {
-    LUnallocated* operand = LUnallocated::cast(it.Next());
-    ASSERT(operand->HasFixedPolicy() ||!operand->HasRegisterPolicy());
+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
   }
 }
 #endif
@@ -302,13 +303,6 @@ void LStoreContextSlot::PrintDataTo(StringStream* stream) {
 }
 
 
-void LInvokeFunction::PrintDataTo(StringStream* stream) {
-  stream->Add("= ");
-  InputAt(0)->PrintTo(stream);
-  stream->Add(" #%d / ", arity());
-}
-
-
 void LCallKeyed::PrintDataTo(StringStream* stream) {
   stream->Add("[rcx] #%d / ", arity());
 }
@@ -1217,14 +1211,6 @@ LInstruction* LChunkBuilder::DoCallConstantFunction(
 }
 
 
-LInstruction* LChunkBuilder::DoInvokeFunction(HInvokeFunction* instr) {
-  LOperand* function = UseFixed(instr->function(), rdi);
-  argument_count_ -= instr->argument_count();
-  LInvokeFunction* result = new LInvokeFunction(function);
-  return MarkAsCall(DefineFixed(result, rax), instr, CANNOT_DEOPTIMIZE_EAGERLY);
-}
-
-
 LInstruction* LChunkBuilder::DoUnaryMathOperation(HUnaryMathOperation* instr) {
   BuiltinFunctionId op = instr->op();
   if (op == kMathLog || op == kMathSin || op == kMathCos) {
@@ -1955,13 +1941,6 @@ LInstruction* LChunkBuilder::DoStoreNamedGeneric(HStoreNamedGeneric* instr) {
 }
 
 
-LInstruction* LChunkBuilder::DoStringAdd(HStringAdd* instr) {
-  LOperand* left = UseOrConstantAtStart(instr->left());
-  LOperand* right = UseOrConstantAtStart(instr->right());
-  return MarkAsCall(DefineFixed(new LStringAdd(left, right), rax), instr);
-}
-
-
 LInstruction* LChunkBuilder::DoStringCharCodeAt(HStringCharCodeAt* instr) {
   LOperand* string = UseRegister(instr->string());
   LOperand* index = UseRegisterOrConstant(instr->index());
@@ -2005,8 +1984,7 @@ LInstruction* LChunkBuilder::DoFunctionLiteral(HFunctionLiteral* instr) {
 
 LInstruction* LChunkBuilder::DoDeleteProperty(HDeleteProperty* instr) {
   LDeleteProperty* result =
-      new LDeleteProperty(UseAtStart(instr->object()),
-                          UseOrConstantAtStart(instr->key()));
+      new LDeleteProperty(Use(instr->object()), UseOrConstant(instr->key()));
   return MarkAsCall(DefineFixed(result, rax), instr);
 }
 
diff --git a/src/x64/lithium-x64.h b/src/x64/lithium-x64.h
index 74f48202..15bb8941 100644
--- a/src/x64/lithium-x64.h
+++ b/src/x64/lithium-x64.h
@@ -98,15 +98,14 @@ class LCodeGen;
   V(GlobalObject)                               \
   V(GlobalReceiver)                             \
   V(Goto)                                       \
-  V(HasCachedArrayIndex)                        \
-  V(HasCachedArrayIndexAndBranch)               \
   V(HasInstanceType)                            \
   V(HasInstanceTypeAndBranch)                   \
+  V(HasCachedArrayIndex)                        \
+  V(HasCachedArrayIndexAndBranch)               \
   V(InstanceOf)                                 \
   V(InstanceOfAndBranch)                        \
   V(InstanceOfKnownGlobal)                      \
   V(Integer32ToDouble)                          \
-  V(InvokeFunction)                             \
   V(IsNull)                                     \
   V(IsNullAndBranch)                            \
   V(IsObject)                                   \
@@ -153,7 +152,6 @@ class LCodeGen;
   V(StoreKeyedSpecializedArrayElement)          \
   V(StoreNamedField)                            \
   V(StoreNamedGeneric)                          \
-  V(StringAdd)                                  \
   V(StringCharCodeAt)                           \
   V(StringCharFromCode)                         \
   V(StringLength)                               \
@@ -1395,23 +1393,6 @@ class LCallConstantFunction: public LTemplateInstruction<1, 0, 0> {
 };
 
 
-class LInvokeFunction: public LTemplateInstruction<1, 1, 0> {
- public:
-  explicit LInvokeFunction(LOperand* function) {
-    inputs_[0] = function;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
-  DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
-
-  LOperand* function() { return inputs_[0]; }
-
-  virtual void PrintDataTo(StringStream* stream);
-
-  int arity() const { return hydrogen()->argument_count() - 1; }
-};
-
-
 class LCallKeyed: public LTemplateInstruction<1, 1, 0> {
  public:
   explicit LCallKeyed(LOperand* key) {
@@ -1703,21 +1684,6 @@ class LStoreKeyedGeneric: public LTemplateInstruction<0, 3, 0> {
 };
 
 
-class LStringAdd: public LTemplateInstruction<1, 2, 0> {
- public:
-  LStringAdd(LOperand* left, LOperand* right) {
-    inputs_[0] = left;
-    inputs_[1] = right;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add")
-  DECLARE_HYDROGEN_ACCESSOR(StringAdd)
-
-  LOperand* left() { return inputs_[0]; }
-  LOperand* right() { return inputs_[1]; }
-};
-
-
 class LStringCharCodeAt: public LTemplateInstruction<1, 2, 0> {
  public:
   LStringCharCodeAt(LOperand* string, LOperand* index) {
diff --git a/src/x64/macro-assembler-x64.cc b/src/x64/macro-assembler-x64.cc
index 33942067..7f027f70 100644
--- a/src/x64/macro-assembler-x64.cc
+++ b/src/x64/macro-assembler-x64.cc
@@ -650,7 +650,6 @@ MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(
   Label leave_exit_frame;
   Label write_back;
 
-  Factory* factory = isolate()->factory();
   ExternalReference next_address =
       ExternalReference::handle_scope_next_address();
   const int kNextOffset = 0;
@@ -698,7 +697,7 @@ MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(
 
   // Check if the function scheduled an exception.
   movq(rsi, scheduled_exception_address);
-  Cmp(Operand(rsi, 0), factory->the_hole_value());
+  Cmp(Operand(rsi, 0), FACTORY->the_hole_value());
   j(not_equal, &promote_scheduled_exception);
 
   LeaveApiExitFrame();
@@ -713,7 +712,7 @@ MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(
 
   bind(&empty_result);
   // It was zero; the result is undefined.
-  Move(rax, factory->undefined_value());
+  Move(rax, FACTORY->undefined_value());
   jmp(&prologue);
 
   // HandleScope limit has changed. Delete allocated extensions.
@@ -1248,17 +1247,12 @@ void MacroAssembler::SmiAdd(Register dst,
                             Register src2) {
   // No overflow checking. Use only when it's known that
   // overflowing is impossible.
+  ASSERT(!dst.is(src2));
   if (!dst.is(src1)) {
-    if (emit_debug_code()) {
-      movq(kScratchRegister, src1);
-      addq(kScratchRegister, src2);
-      Check(no_overflow, "Smi addition overflow");
-    }
-    lea(dst, Operand(src1, src2, times_1, 0));
-  } else {
-    addq(dst, src2);
-    Assert(no_overflow, "Smi addition overflow");
+    movq(dst, src1);
   }
+  addq(dst, src2);
+  Assert(no_overflow, "Smi addition overflow");
 }
 
 
@@ -1901,7 +1895,7 @@ void MacroAssembler::AbortIfNotNumber(Register object) {
   Condition is_smi = CheckSmi(object);
   j(is_smi, &ok);
   Cmp(FieldOperand(object, HeapObject::kMapOffset),
-      isolate()->factory()->heap_number_map());
+      FACTORY->heap_number_map());
   Assert(equal, "Operand not a number");
   bind(&ok);
 }
@@ -2158,7 +2152,7 @@ void MacroAssembler::EnterFrame(StackFrame::Type type) {
   push(kScratchRegister);
   if (emit_debug_code()) {
     movq(kScratchRegister,
-         isolate()->factory()->undefined_value(),
+         FACTORY->undefined_value(),
          RelocInfo::EMBEDDED_OBJECT);
     cmpq(Operand(rsp, 0), kScratchRegister);
     Check(not_equal, "code object not properly patched");
@@ -2326,7 +2320,7 @@ void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg,
   // Check the context is a global context.
   if (emit_debug_code()) {
     Cmp(FieldOperand(scratch, HeapObject::kMapOffset),
-        isolate()->factory()->global_context_map());
+        FACTORY->global_context_map());
     Check(equal, "JSGlobalObject::global_context should be a global context.");
   }
 
@@ -2828,7 +2822,7 @@ void MacroAssembler::LoadGlobalFunctionInitialMap(Register function,
   movq(map, FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
   if (emit_debug_code()) {
     Label ok, fail;
-    CheckMap(map, isolate()->factory()->meta_map(), &fail, false);
+    CheckMap(map, FACTORY->meta_map(), &fail, false);
     jmp(&ok);
     bind(&fail);
     Abort("Global functions must have initial map");
diff --git a/src/x64/regexp-macro-assembler-x64.cc b/src/x64/regexp-macro-assembler-x64.cc
index d4ccb0e0..c16da940 100644
--- a/src/x64/regexp-macro-assembler-x64.cc
+++ b/src/x64/regexp-macro-assembler-x64.cc
@@ -703,7 +703,7 @@ void RegExpMacroAssemblerX64::Fail() {
 }
 
 
-Handle<Object> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
+Handle<HeapObject> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
   // Finalize code - write the entry point code now we know how many
   // registers we need.
   // Entry code:
@@ -972,7 +972,7 @@ Handle<Object> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
       code_desc, Code::ComputeFlags(Code::REGEXP),
       masm_.CodeObject());
   PROFILE(isolate, RegExpCodeCreateEvent(*code, *source));
-  return Handle<Object>::cast(code);
+  return Handle<HeapObject>::cast(code);
 }
 
 
diff --git a/src/x64/regexp-macro-assembler-x64.h b/src/x64/regexp-macro-assembler-x64.h
index a83f8cbc..02b510fa 100644
--- a/src/x64/regexp-macro-assembler-x64.h
+++ b/src/x64/regexp-macro-assembler-x64.h
@@ -75,7 +75,7 @@ class RegExpMacroAssemblerX64: public NativeRegExpMacroAssembler {
   virtual bool CheckSpecialCharacterClass(uc16 type,
                                           Label* on_no_match);
   virtual void Fail();
-  virtual Handle<Object> GetCode(Handle<String> source);
+  virtual Handle<HeapObject> GetCode(Handle<String> source);
   virtual void GoTo(Label* label);
   virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
   virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
diff --git a/test/cctest/test-compiler.cc b/test/cctest/test-compiler.cc
index d3dd9c6f..4c5f197b 100644
--- a/test/cctest/test-compiler.cc
+++ b/test/cctest/test-compiler.cc
@@ -31,6 +31,8 @@
 #include "v8.h"
 
 #include "compiler.h"
+#include "disasm.h"
+#include "disassembler.h"
 #include "execution.h"
 #include "factory.h"
 #include "platform.h"
@@ -348,3 +350,51 @@ TEST(GetScriptLineNumber) {
     CHECK_EQ(i, f->GetScriptLineNumber());
   }
 }
+
+
+#ifdef ENABLE_DISASSEMBLER
+static Handle<JSFunction> GetJSFunction(v8::Handle<v8::Object> obj,
+                                 const char* property_name) {
+  v8::Local<v8::Function> fun =
+      v8::Local<v8::Function>::Cast(obj->Get(v8_str(property_name)));
+  return v8::Utils::OpenHandle(*fun);
+}
+
+
+static void CheckCodeForUnsafeLiteral(Handle<JSFunction> f) {
+  // Create a disassembler with default name lookup.
+  disasm::NameConverter name_converter;
+  disasm::Disassembler d(name_converter);
+
+  if (f->code()->kind() == Code::FUNCTION) {
+    Address pc = f->code()->instruction_start();
+    int decode_size =
+        Min(f->code()->instruction_size(),
+            static_cast<int>(f->code()->stack_check_table_offset()));
+    Address end = pc + decode_size;
+
+    v8::internal::EmbeddedVector<char, 128> decode_buffer;
+    while (pc < end) {
+      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);
+    }
+  }
+}
+
+
+TEST(SplitConstantsInFullCompiler) {
+  v8::HandleScope scope;
+  LocalContext env;
+
+  CompileRun("function f() { a = 12345678 }; f();");
+  CheckCodeForUnsafeLiteral(GetJSFunction(env->Global(), "f"));
+  CompileRun("function f(x) { a = 12345678 + x}; f(1);");
+  CheckCodeForUnsafeLiteral(GetJSFunction(env->Global(), "f"));
+  CompileRun("function f(x) { var arguments = 1; x += 12345678}; f(1);");
+  CheckCodeForUnsafeLiteral(GetJSFunction(env->Global(), "f"));
+  CompileRun("function f(x) { var arguments = 1; x = 12345678}; f(1);");
+  CheckCodeForUnsafeLiteral(GetJSFunction(env->Global(), "f"));
+}
+#endif
diff --git a/test/cctest/test-cpu-profiler.cc b/test/cctest/test-cpu-profiler.cc
index 749ac154..17611acb 100644
--- a/test/cctest/test-cpu-profiler.cc
+++ b/test/cctest/test-cpu-profiler.cc
@@ -238,6 +238,49 @@ TEST(CrashIfStoppingLastNonExistentProfile) {
 }
 
 
+// http://code.google.com/p/v8/issues/detail?id=1398
+// Long stacks (exceeding max frames limit) must not be erased.
+TEST(Issue1398) {
+  TestSetup test_setup;
+  CpuProfilesCollection profiles;
+  profiles.StartProfiling("", 1);
+  ProfileGenerator generator(&profiles);
+  ProfilerEventsProcessor processor(i::Isolate::Current(), &generator);
+  processor.Start();
+  while (!processor.running()) {
+    i::Thread::YieldCPU();
+  }
+
+  processor.CodeCreateEvent(i::Logger::BUILTIN_TAG,
+                            "bbb",
+                            ToAddress(0x1200),
+                            0x80);
+
+  i::TickSample* sample = processor.TickSampleEvent();
+  sample->pc = ToAddress(0x1200);
+  sample->tos = 0;
+  sample->frames_count = i::TickSample::kMaxFramesCount;
+  for (int i = 0; i < sample->frames_count; ++i) {
+    sample->stack[i] = ToAddress(0x1200);
+  }
+
+  processor.Stop();
+  processor.Join();
+  CpuProfile* profile =
+      profiles.StopProfiling(TokenEnumerator::kNoSecurityToken, "", 1);
+  CHECK_NE(NULL, profile);
+
+  int actual_depth = 0;
+  const ProfileNode* node = profile->top_down()->root();
+  while (node->children()->length() > 0) {
+    node = node->children()->last();
+    ++actual_depth;
+  }
+
+  CHECK_EQ(1 + i::TickSample::kMaxFramesCount, actual_depth);  // +1 for PC.
+}
+
+
 TEST(DeleteAllCpuProfiles) {
   InitializeVM();
   TestSetup test_setup;
diff --git a/test/cctest/test-deoptimization.cc b/test/cctest/test-deoptimization.cc
index 5ab84f96..056c9818 100644
--- a/test/cctest/test-deoptimization.cc
+++ b/test/cctest/test-deoptimization.cc
@@ -97,8 +97,8 @@ class AllowNativesSyntaxNoInlining {
 };
 
 
-Handle<JSFunction> GetJSFunction(v8::Handle<v8::Object> obj,
-                                 const char* property_name) {
+static Handle<JSFunction> GetJSFunction(v8::Handle<v8::Object> obj,
+                                        const char* property_name) {
   v8::Local<v8::Function> fun =
       v8::Local<v8::Function>::Cast(obj->Get(v8_str(property_name)));
   return v8::Utils::OpenHandle(*fun);
diff --git a/test/mjsunit/apply.js b/test/mjsunit/apply.js
index c166110d..613d37d9 100644
--- a/test/mjsunit/apply.js
+++ b/test/mjsunit/apply.js
@@ -33,43 +33,43 @@ function f1(a) {
   return a;
 }
 
-assertSame(this, f0.apply(), "1-0");
+assertTrue(this === f0.apply(), "1-0");
 
-assertSame(this, f0.apply(this), "2a");
-assertSame(this, f0.apply(this, new Array(1)), "2b");
-assertSame(this, f0.apply(this, new Array(2)), "2c");
-assertSame(this, f0.apply(this, new Array(4242)), "2d");
+assertTrue(this === f0.apply(this), "2a");
+assertTrue(this === f0.apply(this, new Array(1)), "2b");
+assertTrue(this === f0.apply(this, new Array(2)), "2c");
+assertTrue(this === f0.apply(this, new Array(4242)), "2d");
 
-assertSame(this, f0.apply(null), "3a");
-assertSame(this, f0.apply(null, new Array(1)), "3b");
-assertSame(this, f0.apply(null, new Array(2)), "3c");
-assertSame(this, f0.apply(this, new Array(4242)), "3d");
+assertTrue(this === f0.apply(null), "3a");
+assertTrue(this === f0.apply(null, new Array(1)), "3b");
+assertTrue(this === f0.apply(null, new Array(2)), "3c");
+assertTrue(this === f0.apply(this, new Array(4242)), "3d");
 
-assertSame(this, f0.apply(void 0), "4a");
-assertSame(this, f0.apply(void 0, new Array(1)), "4b");
-assertSame(this, f0.apply(void 0, new Array(2)), "4c");
+assertTrue(this === f0.apply(void 0), "4a");
+assertTrue(this === f0.apply(void 0, new Array(1)), "4b");
+assertTrue(this === f0.apply(void 0, new Array(2)), "4c");
 
-assertEquals(void 0, f1.apply(), "1-1");
+assertTrue(void 0 === f1.apply(), "1-1");
 
-assertEquals(void 0, f1.apply(this), "5a");
-assertEquals(void 0, f1.apply(this, new Array(1)), "5b");
-assertEquals(void 0, f1.apply(this, new Array(2)), "5c");
-assertEquals(void 0, f1.apply(this, new Array(4242)), "5d");
-assertEquals(42, f1.apply(this, new Array(42, 43)), "5e");
+assertTrue(void 0 === f1.apply(this), "5a");
+assertTrue(void 0 === f1.apply(this, new Array(1)), "5b");
+assertTrue(void 0 === f1.apply(this, new Array(2)), "5c");
+assertTrue(void 0 === f1.apply(this, new Array(4242)), "5d");
+assertTrue(42 === f1.apply(this, new Array(42, 43)), "5e");
 assertEquals("foo", f1.apply(this, new Array("foo", "bar", "baz", "bo")), "5f");
 
-assertEquals(void 0, f1.apply(null), "6a");
-assertEquals(void 0, f1.apply(null, new Array(1)), "6b");
-assertEquals(void 0, f1.apply(null, new Array(2)), "6c");
-assertEquals(void 0, f1.apply(null, new Array(4242)), "6d");
-assertEquals(42, f1.apply(null, new Array(42, 43)), "6e");
+assertTrue(void 0 === f1.apply(null), "6a");
+assertTrue(void 0 === f1.apply(null, new Array(1)), "6b");
+assertTrue(void 0 === f1.apply(null, new Array(2)), "6c");
+assertTrue(void 0 === f1.apply(null, new Array(4242)), "6d");
+assertTrue(42 === f1.apply(null, new Array(42, 43)), "6e");
 assertEquals("foo", f1.apply(null, new Array("foo", "bar", "baz", "bo")), "6f");
 
-assertEquals(void 0, f1.apply(void 0), "7a");
-assertEquals(void 0, f1.apply(void 0, new Array(1)), "7b");
-assertEquals(void 0, f1.apply(void 0, new Array(2)), "7c");
-assertEquals(void 0, f1.apply(void 0, new Array(4242)), "7d");
-assertEquals(42, f1.apply(void 0, new Array(42, 43)), "7e");
+assertTrue(void 0 === f1.apply(void 0), "7a");
+assertTrue(void 0 === f1.apply(void 0, new Array(1)), "7b");
+assertTrue(void 0 === f1.apply(void 0, new Array(2)), "7c");
+assertTrue(void 0 === f1.apply(void 0, new Array(4242)), "7d");
+assertTrue(42 === f1.apply(void 0, new Array(42, 43)), "7e");
 assertEquals("foo", f1.apply(void 0, new Array("foo", "bar", "ba", "b")), "7f");
 
 var arr = new Array(42, "foo", "fish", "horse");
@@ -108,7 +108,7 @@ function s() {
 assertEquals("bar42foofishhorse", s.apply("bar", arr), "apply to string");
 
 function al() {
-  assertEquals(Object(345), this);
+  assertEquals(345, this);
   return arguments.length + arguments[arguments.length - 1];
 }
 
@@ -186,7 +186,7 @@ primes[0] = "";
 primes[1] = holey;
 assertThrows("String.prototype.concat.apply.apply('foo', primes)");
 assertEquals("morseper",
-    String.prototype.concat.apply.apply(String.prototype.concat, primes),
+    String.prototype.concat.apply.apply(String.prototype.concat, primes), 
     "moreseper-prime");
 
 delete(Array.prototype["1"]);
diff --git a/test/mjsunit/arguments-apply.js b/test/mjsunit/arguments-apply.js
index 48c42349..5a912285 100644
--- a/test/mjsunit/arguments-apply.js
+++ b/test/mjsunit/arguments-apply.js
@@ -73,11 +73,11 @@ function NonObjectReceiver(receiver) {
   return ReturnReceiver.apply(receiver, arguments);
 }
 
-assertEquals(Object(42), NonObjectReceiver(42));
+assertEquals(42, NonObjectReceiver(42));
 assertEquals("object", typeof NonObjectReceiver(42));
-assertInstanceof(NonObjectReceiver(42), Number);
-assertSame(this, NonObjectReceiver(null));
-assertSame(this, NonObjectReceiver(void 0));
+assertTrue(NonObjectReceiver(42) instanceof Number);
+assertTrue(this === NonObjectReceiver(null));
+assertTrue(this === NonObjectReceiver(void 0));
 
 
 function FunctionReceiver() {
diff --git a/test/mjsunit/arguments-opt.js b/test/mjsunit/arguments-opt.js
index b8280b4b..c74fc75a 100644
--- a/test/mjsunit/arguments-opt.js
+++ b/test/mjsunit/arguments-opt.js
@@ -79,38 +79,36 @@ assertTrue(typeof(A(10000)) == 'undefined');
 assertTrue(typeof(A(10000, 0)) == 'undefined');
 
 // String access.
-assertEquals('0', A('0'));
-assertEquals('0', A('0',1));
+assertEquals(0, A('0'));
+assertEquals(0, A('0',1));
 assertEquals(2, A('1',2));
 assertEquals(2, A('1',2,3,4,5));
 assertEquals(5, A('4',2,3,4,5));
-assertEquals('undefined', typeof A('1'));
-assertEquals('undefined', typeof A('3',2,1));
+assertTrue(typeof A('1') == 'undefined');
+assertTrue(typeof A('3',2,1) == 'undefined');
 assertEquals(A, A('callee'));
 assertEquals(1, A('length'));
 assertEquals(2, A('length',2));
 assertEquals(5, A('length',2,3,4,5));
 assertEquals({}.toString, A('toString'));
 assertEquals({}.isPrototypeOf, A('isPrototypeOf'));
-assertEquals('undefined', typeof A('xxx'));
+assertTrue(typeof A('xxx') == 'undefined');
 
 // Object access.
 function O(key) {
   return { toString: function() { return key; } };
 }
 
-var O0 = O(0);
-assertSame(O0, A(O0));
-assertSame(O0, A(O0,1));
+assertEquals(0, A(O(0)));
+assertEquals(0, A(O(0),1));
 assertEquals(2, A(O(1),2));
 assertEquals(2, A(O(1),2,3,4,5));
 assertEquals(5, A(O(4),2,3,4,5));
 assertTrue(typeof A(O(1)) == 'undefined');
 assertTrue(typeof A(O(3),2,1) == 'undefined');
 
-O0 = O('0');
-assertSame(O0, A(O0));
-assertSame(O0, A(O0,1));
+assertEquals(0, A(O('0')));
+assertEquals(0, A(O('0'),1));
 assertEquals(2, A(O('1'),2));
 assertEquals(2, A(O('1'),2,3,4,5));
 assertEquals(5, A(O('4'),2,3,4,5));
diff --git a/test/mjsunit/array-length.js b/test/mjsunit/array-length.js
index 16867db7..967d7203 100644
--- a/test/mjsunit/array-length.js
+++ b/test/mjsunit/array-length.js
@@ -102,7 +102,7 @@ assertEquals('undefined', typeof a[Math.pow(2,32)-2], "top");
 
 
 var a = new Array();
-assertEquals(Object(12), a.length = new Number(12));
+assertEquals(12, a.length = new Number(12));
 assertEquals(12, a.length);
 
 
diff --git a/test/mjsunit/compiler/logical-and.js b/test/mjsunit/compiler/logical-and.js
index 783edb6a..1d31a0a5 100644
--- a/test/mjsunit/compiler/logical-and.js
+++ b/test/mjsunit/compiler/logical-and.js
@@ -46,8 +46,8 @@ assertFalse(AndBB(1, 0));
 assertFalse(AndBB(0, 1));
 assertFalse(AndBB(1, 1));
 
-assertEquals(0, AndBN(0, 0));
-assertEquals(1, AndBN(0, 1));
+assertFalse(AndBN(0, 0));
+assertTrue(AndBN(0, 1));
 assertFalse(AndBN(1, 0));
 assertEquals(1, AndBN(0, 1));
 assertEquals(2, AndBN(0, 2));
diff --git a/test/mjsunit/execScript-case-insensitive.js b/test/mjsunit/compiler/regress-1394.js
index 468d6574..b1ce1926 100644
--- a/test/mjsunit/execScript-case-insensitive.js
+++ b/test/mjsunit/compiler/regress-1394.js
@@ -1,4 +1,4 @@
-// Copyright 2008 the V8 project authors. All rights reserved.
+// 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:
@@ -25,10 +25,35 @@
 // (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  = 0;
-execScript('x = 1', 'javascript');
-assertEquals(1, x);
+// Flags: --allow-natives-syntax
 
-execScript('x = 2', 'JavaScript');
-assertEquals(2, x);
+function f(x) {
+  var ret = -1;
+  switch(x){
+    default:
+    case 0:
+      ret = 0;
+      break;
+    case 1:
+      ret = 1;
+      break;
+    case 2:
+      ret = 2;
+      break;
+    case 3:
+      ret = 3;
+      break;
+    case 4:
+      ret = 4;
+      break;
+  }
+  return ret;
+};
+
+for (var i = 0; i < 3; i++) assertEquals(i, f(i));
+
+%OptimizeFunctionOnNextCall(f);
+
+assertEquals(0, f(0));
+assertEquals(1, f(1));
 
diff --git a/test/mjsunit/const.js b/test/mjsunit/const.js
index adb0b7ae..a48e82de 100644
--- a/test/mjsunit/const.js
+++ b/test/mjsunit/const.js
@@ -50,20 +50,20 @@ f();
 var valueOfCount = 0;
 
 function g() {
-  const o = { valueOf: function() { valueOfCount++; return 42; } };
-  assertEquals(42, +o);
+  const o = { valueOf: function() { valueOfCount++; return 42; } }
+  assertEquals(42, o);
   assertEquals(1, valueOfCount);
   o++;
-  assertEquals(42, +o);
+  assertEquals(42, o);
   assertEquals(3, valueOfCount);
   ++o;
-  assertEquals(42, +o);
+  assertEquals(42, o);
   assertEquals(5, valueOfCount);
   o--;
-  assertEquals(42, +o);
+  assertEquals(42, o);
   assertEquals(7, valueOfCount);
   --o;
-  assertEquals(42, +o);
+  assertEquals(42, o);
   assertEquals(9, valueOfCount);
 }
 
diff --git a/test/mjsunit/cyrillic.js b/test/mjsunit/cyrillic.js
index 9b21c4f8..c5712e6f 100644
--- a/test/mjsunit/cyrillic.js
+++ b/test/mjsunit/cyrillic.js
@@ -187,9 +187,9 @@ for (var add_non_ascii_character_to_subject = 0;
       var ignore_case = (j == 0);
       var flag = ignore_case ? "i" : "";
       var re = new RegExp(mixed, flag);
-      var expected =
-          ignore_case || (full && !!add_non_ascii_character_to_subject);
-      assertEquals(expected, re.test("A" + suffix), 58 + flag + f);
+      assertEquals(ignore_case || (full && add_non_ascii_character_to_subject),
+                   re.test("A" + suffix),
+                   58 + flag + f);
       assertTrue(re.test("a" + suffix), 59 + flag + f);
       assertTrue(re.test("~" + suffix), 60 + flag + f);
       assertTrue(re.test(cyrillic.MIDDLE), 61 + flag + f);
diff --git a/test/mjsunit/debug-evaluate-with.js b/test/mjsunit/debug-evaluate-with.js
index c19a7074..9d95a9f5 100644
--- a/test/mjsunit/debug-evaluate-with.js
+++ b/test/mjsunit/debug-evaluate-with.js
@@ -42,13 +42,13 @@ function listener(event, exec_state, event_data, data) {
         // Break point in first with block.
         assertEquals(2, exec_state.frame(0).evaluate('a').value());
         assertEquals(2, exec_state.frame(0).evaluate('b').value());
-      } else if (breakPointCount == 2) {
+      } else {
         // Break point in second with block.
         assertEquals(3, exec_state.frame(0).evaluate('a').value());
         assertEquals(1, exec_state.frame(0).evaluate('b').value());
-      } else if (breakPointCount == 3) {
-        // Break point in eval with block.
-        assertEquals('local', exec_state.frame(0).evaluate('foo').value());
+
+        // Indicate that all was processed.
+        listenerComplete = true;
       }
     }
   } catch (e) {
@@ -72,10 +72,6 @@ function f() {
 };
 
 f();
-
-var foo = "global";
-eval("with({bar:'with'}) { (function g() { var foo = 'local'; debugger; })(); }");
-
 // Make sure that the debug event listener vas invoked.
-assertEquals(3, breakPointCount);
+assertTrue(listenerComplete);
 assertFalse(exception, "exception in listener")
diff --git a/test/mjsunit/debug-scopes.js b/test/mjsunit/debug-scopes.js
index 40adf5b2..674f2da0 100644
--- a/test/mjsunit/debug-scopes.js
+++ b/test/mjsunit/debug-scopes.js
@@ -31,9 +31,9 @@
 
 
 // Get the Debug object exposed from the debug context global object.
-Debug = debug.Debug;
+Debug = debug.Debug
 
-var test_name;
+var name;
 var listener_delegate;
 var listener_called;
 var exception;
@@ -48,7 +48,7 @@ function listener(event, exec_state, event_data, data) {
     if (event == Debug.DebugEvent.Break) {
       break_count++;
       listener_called = true;
-      listener_delegate(exec_state);
+      listener_delegate(exec_state)
     }
   } catch (e) {
     exception = e;
@@ -59,7 +59,7 @@ function listener(event, exec_state, event_data, data) {
 Debug.setListener(listener);
 
 
-// Initialize for a new test.
+// Initialize for a noew test.
 function BeginTest(name) {
   test_name = name;
   listener_delegate = null;
@@ -72,7 +72,7 @@ function BeginTest(name) {
 // Check result of a test.
 function EndTest() {
   assertTrue(listener_called, "listerner not called for " + test_name);
-  assertNull(exception, test_name);
+  assertNull(exception, test_name)
   end_test_count++;
 }
 
@@ -87,9 +87,7 @@ function CheckScopeChain(scopes, exec_state) {
 
     // Check the global object when hitting the global scope.
     if (scopes[i] == debug.ScopeType.Global) {
-      // Objects don't have same class (one is "global", other is "Object",
-      // so just check the properties directly.
-      assertPropertiesEqual(this, scope.scopeObject().value());
+      assertEquals(this, scope.scopeObject().value());
     }
   }
 
@@ -98,7 +96,7 @@ function CheckScopeChain(scopes, exec_state) {
 
   // Send a scopes request and check the result.
   var json;
-  var request_json = '{"seq":0,"type":"request","command":"scopes"}';
+  request_json = '{"seq":0,"type":"request","command":"scopes"}'
   var response_json = dcp.processDebugJSONRequest(request_json);
   var response = JSON.parse(response_json);
   assertEquals(scopes.length, response.body.scopes.length);
@@ -123,7 +121,7 @@ function CheckScopeChain(scopes, exec_state) {
 // Check that the content of the scope is as expected. For functions just check
 // that there is a function.
 function CheckScopeContent(content, number, exec_state) {
-  var scope = exec_state.frame().scope(number);
+  var scope = exec_state.frame().scope(number)
   var count = 0;
   for (var p in content) {
     var property_mirror = scope.scopeObject().property(p);
@@ -165,9 +163,9 @@ function CheckScopeContent(content, number, exec_state) {
 
   // Send a scope request for information on a single scope and check the
   // result.
-  var request_json = '{"seq":0,"type":"request","command":"scope","arguments":{"number":';
+  request_json = '{"seq":0,"type":"request","command":"scope","arguments":{"number":'
   request_json += scope.scopeIndex();
-  request_json += '}}';
+  request_json += '}}'
   var response_json = dcp.processDebugJSONRequest(request_json);
   var response = JSON.parse(response_json);
   assertEquals(scope.scopeType(), response.body.type);
@@ -197,8 +195,8 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
-};
-local_1();
+}
+local_1()
 EndTest();
 
 
@@ -213,8 +211,8 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1}, 0, exec_state);
-};
-local_2(1);
+}
+local_2(1)
 EndTest();
 
 
@@ -230,8 +228,8 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,x:3}, 0, exec_state);
-};
-local_3(1);
+}
+local_3(1)
 EndTest();
 
 
@@ -248,8 +246,8 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4}, 0, exec_state);
-};
-local_4(1, 2);
+}
+local_4(1, 2)
 EndTest();
 
 
@@ -265,8 +263,8 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
-};
-local_5();
+}
+local_5()
 EndTest();
 
 
@@ -282,8 +280,8 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({i:5}, 0, exec_state);
-};
-local_6();
+}
+local_6()
 EndTest();
 
 
@@ -303,8 +301,8 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6}, 0, exec_state);
-};
-local_7(1, 2);
+}
+local_7(1, 2)
 EndTest();
 
 
@@ -322,8 +320,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
-};
-with_1();
+}
+with_1()
 EndTest();
 
 
@@ -345,8 +343,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
   CheckScopeContent({}, 1, exec_state);
-};
-with_2();
+}
+with_2()
 EndTest();
 
 
@@ -364,8 +362,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2}, 0, exec_state);
-};
-with_3();
+}
+with_3()
 EndTest();
 
 
@@ -387,8 +385,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:2,b:1}, 0, exec_state);
   CheckScopeContent({a:1,b:2}, 1, exec_state);
-};
-with_4();
+}
+with_4()
 EndTest();
 
 
@@ -413,8 +411,8 @@ listener_delegate = function(exec_state) {
   CheckScopeContent(with_object, 1, exec_state);
   assertEquals(exec_state.frame().scope(0).scopeObject(), exec_state.frame().scope(1).scopeObject());
   assertEquals(with_object, exec_state.frame().scope(1).scopeObject().value());
-};
-with_5();
+}
+with_5()
 EndTest();
 
 
@@ -435,8 +433,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1}, 1, exec_state);
-};
-closure_1(1)();
+}
+closure_1(1)()
 EndTest();
 
 
@@ -460,8 +458,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,x:3}, 1, exec_state);
-};
-closure_2(1, 2)();
+}
+closure_2(1, 2)()
 EndTest();
 
 
@@ -486,8 +484,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4}, 1, exec_state);
-};
-closure_3(1, 2)();
+}
+closure_3(1, 2)()
 EndTest();
 
 
@@ -515,8 +513,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,f:function(){}}, 1, exec_state);
-};
-closure_4(1, 2)();
+}
+closure_4(1, 2)()
 EndTest();
 
 
@@ -543,8 +541,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,f:function(){}}, 1, exec_state);
-};
-closure_5(1, 2)();
+}
+closure_5(1, 2)()
 EndTest();
 
 
@@ -561,7 +559,7 @@ function closure_6(a, b) {
       debugger;
       some_global = a;
       return f;
-    };
+    }
   }
   return f(a, b);
 }
@@ -573,8 +571,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1}, 1, exec_state);
   CheckScopeContent({f:function(){}}, 2, exec_state);
-};
-closure_6(1, 2)();
+}
+closure_6(1, 2)()
 EndTest();
 
 
@@ -595,7 +593,7 @@ function closure_7(a, b) {
       debugger;
       some_global = a;
       return f;
-    };
+    }
   }
   return f(a, b);
 }
@@ -608,8 +606,8 @@ listener_delegate = function(exec_state) {
   CheckScopeContent({}, 0, exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6}, 1, exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6,f:function(){}}, 2, exec_state);
-};
-closure_7(1, 2)();
+}
+closure_7(1, 2)()
 EndTest();
 
 
@@ -625,7 +623,7 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({x: 2}, 0, exec_state);
-};
+}
 closure_8();
 EndTest();
 
@@ -635,7 +633,7 @@ function closure_9() {
   eval("var y = 1;");
   eval("var z = 1;");
   (function inner(x) {
-    y++;
+    y++; 
     z++;
     debugger;
   })(2);
@@ -645,7 +643,7 @@ listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
-};
+}
 closure_9();
 EndTest();
 
@@ -672,7 +670,7 @@ function the_full_monty(a, b) {
             return f;
           }
         }
-      };
+      }
     }
   }
   return f(a, b);
@@ -692,8 +690,8 @@ listener_delegate = function(exec_state) {
   CheckScopeContent({j:13}, 3, exec_state);
   CheckScopeContent({a:1,b:2,x:9,y:10,i:11,j:12}, 4, exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6,f:function(){}}, 5, exec_state);
-};
-the_full_monty(1, 2)();
+}
+the_full_monty(1, 2)()
 EndTest();
 
 
@@ -712,7 +710,7 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({x: 2}, 0, exec_state);
-};
+}
 closure_in_with_1();
 EndTest();
 
@@ -737,7 +735,7 @@ listener_delegate = function(exec_state) {
   CheckScopeContent({x: 3}, 0, exec_state);
   CheckScopeContent({x: 2}, 1, exec_state);
   CheckScopeContent({x: 1}, 2, exec_state);
-};
+}
 closure_in_with_2();
 EndTest();
 
@@ -752,7 +750,7 @@ function createClosure(a) {
          debugger;
        }
      })(2);
-   };
+   }
 }
 
 function closure_in_with_3() {
@@ -775,7 +773,7 @@ EndTest();
 BeginTest("Global");
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Global], exec_state);
-};
+}
 debugger;
 EndTest();
 
@@ -795,8 +793,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({e:'Exception'}, 0, exec_state);
-};
-catch_block_1();
+}
+catch_block_1()
 EndTest();
 
 
@@ -819,8 +817,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({n:10}, 0, exec_state);
   CheckScopeContent({e:'Exception'}, 1, exec_state);
-};
-catch_block_2();
+}
+catch_block_2()
 EndTest();
 
 
@@ -843,8 +841,8 @@ listener_delegate = function(exec_state) {
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({e:'Exception'}, 0, exec_state);
   CheckScopeContent({y:78}, 1, exec_state);
-};
-catch_block_3();
+}
+catch_block_3()
 EndTest();
 
 
@@ -870,12 +868,10 @@ listener_delegate = function(exec_state) {
   CheckScopeContent({n:10}, 0, exec_state);
   CheckScopeContent({e:'Exception'}, 1, exec_state);
   CheckScopeContent({y:98}, 2, exec_state);
-};
-catch_block_4();
+}
+catch_block_4()
 EndTest();
 
 
-assertEquals(begin_test_count, break_count,
-             'one or more tests did not enter the debugger');
-assertEquals(begin_test_count, end_test_count,
-             'one or more tests did not have its result checked');
+assertEquals(begin_test_count, break_count, 'one or more tests did not enter the debugger');
+assertEquals(begin_test_count, end_test_count, 'one or more tests did not have its result checked');
diff --git a/test/mjsunit/function-names.js b/test/mjsunit/function-names.js
index c083f18f..5ed0b794 100644
--- a/test/mjsunit/function-names.js
+++ b/test/mjsunit/function-names.js
@@ -128,6 +128,6 @@ var globalFunctions = [
     "encodeURI", "encodeURIComponent", "Error", "TypeError",
     "RangeError", "SyntaxError", "ReferenceError", "EvalError",
     "URIError", "isNaN", "isFinite", "parseInt", "parseFloat",
-    "eval", "execScript"];
+    "eval"];
 
 TestFunctionNames(this, globalFunctions);
diff --git a/test/mjsunit/compiler/inline-throw.js b/test/mjsunit/limit-locals.js
index e3aab39e..ad9ec436 100644
--- a/test/mjsunit/compiler/inline-throw.js
+++ b/test/mjsunit/limit-locals.js
@@ -25,45 +25,22 @@
 // (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 inlined functions contain throw.
-function doThrow() {
-  throw "uha";
-}
-
-function f(x) {
-  if (x == 42) throw doThrow();
-  if (x == 43) throw "wow";
-  return x == 0;
-}
-
-function g(x) {
-  return f(x);
-}
-
-for (var i = 0; i < 5; i++) g(0);
-%OptimizeFunctionOnNextCall(g);
-assertEquals(true, g(0));
-
-try {
-  g(42);
-} catch(e) {
-  assertEquals("uha", e);
-}
-
-// Test inlining in a test context.
-function h(x) {
-  return f(x) ? "yes" : "no";
+// Test that there is a limit of 32767 locals.
+
+function function_with_n_locals(n) {
+  test_prefix = "prefix ";
+  test_suffix = " suffix";
+  var src = "test_prefix + (function () {"
+  for (var i = 1; i <= n; i++) {
+    src += "var x" + i + ";";
+  }
+  src += "return " + n + ";})() + test_suffix";
+  return eval(src);
 }
 
-for (var i = 0; i < 5; i++) h(0);
-%OptimizeFunctionOnNextCall(h);
-assertEquals("yes", h(0));
-
-try {
-  h(43);
-} catch(e) {
-  assertEquals("wow", e);
-}
+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));
 
+assertThrows("function_with_n_locals(32768)");
+assertThrows("function_with_n_locals(100000)");
diff --git a/test/mjsunit/math-abs.js b/test/mjsunit/math-abs.js
index 33df6f4c..bec1a01c 100644
--- a/test/mjsunit/math-abs.js
+++ b/test/mjsunit/math-abs.js
@@ -35,13 +35,13 @@ function zero() {
 function test() {
   assertEquals(0, Math.abs(0));
   assertEquals(0, Math.abs(zero()));
-  assertEquals(0, Math.abs(-0));
+  assertEquals(1/0, 1/Math.abs(-0));  // 0 == -0, so we use reciprocals.
   assertEquals(Infinity, Math.abs(Infinity));
   assertEquals(Infinity, Math.abs(-Infinity));
-  assertEquals(NaN, Math.abs(NaN));
-  assertEquals(NaN, Math.abs(-NaN));
-  assertEquals('Infinity', Math.abs(Number('+Infinity')).toString());
-  assertEquals('Infinity', Math.abs(Number('-Infinity')).toString());
+  assertNaN(Math.abs(NaN));
+  assertNaN(Math.abs(-NaN));
+  assertEquals('Infinity', Math.abs(Number('+Infinity').toString()));
+  assertEquals('Infinity', Math.abs(Number('-Infinity').toString()));
   assertEquals('NaN', Math.abs(NaN).toString());
   assertEquals('NaN', Math.abs(-NaN).toString());
 
@@ -85,8 +85,8 @@ function test() {
   assertEquals(two_31 - 1, Math.abs(two_31 - 1));
   assertEquals(two_31 - 1, Math.abs(-two_31 + 1));
 
-  assertEquals(NaN, Math.abs("not a number"));
-  assertEquals(NaN, Math.abs([1, 2, 3]));
+  assertNaN(Math.abs("not a number"));
+  assertNaN(Math.abs([1, 2, 3]));
   assertEquals(42, Math.abs({valueOf: function() { return 42; } }));
   assertEquals(42, Math.abs({valueOf: function() { return -42; } }));
 }
diff --git a/test/mjsunit/math-floor.js b/test/mjsunit/math-floor.js
index 11f4cd78..0d1c0ac5 100644
--- a/test/mjsunit/math-floor.js
+++ b/test/mjsunit/math-floor.js
@@ -1,4 +1,4 @@
-// Copyright 2011 the V8 project authors. All rights reserved.
+// 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:
@@ -25,18 +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: --max-new-space-size=256 --allow-natives-syntax
-
-function testFloor(expect, input) {
-  function test(n) {
-    return Math.floor(n);
-  }
-  assertEquals(expect, test(input));
-  assertEquals(expect, test(input));
-  assertEquals(expect, test(input));
-  %OptimizeFunctionOnNextCall(test);
-  assertEquals(expect, test(input));
-}
+// Flags: --max-new-space-size=256
 
 function zero() {
   var x = 0.5;
@@ -44,84 +33,82 @@ function zero() {
 }
 
 function test() {
-  testFloor(0, 0);
-  testFloor(0, zero());
-  testFloor(-0, -0);
-  testFloor(Infinity, Infinity);
-  testFloor(-Infinity, -Infinity);
-  testFloor(NaN, NaN);
-
-  testFloor(0, 0.1);
-  testFloor(0, 0.49999999999999994);
-  testFloor(0, 0.5);
-  testFloor(0, 0.7);
-  testFloor(-1, -0.1);
-  testFloor(-1, -0.49999999999999994);
-  testFloor(-1, -0.5);
-  testFloor(-1, -0.7);
-  testFloor(1, 1);
-  testFloor(1, 1.1);
-  testFloor(1, 1.5);
-  testFloor(1, 1.7);
-  testFloor(-1, -1);
-  testFloor(-2, -1.1);
-  testFloor(-2, -1.5);
-  testFloor(-2, -1.7);
-
-  testFloor(0, Number.MIN_VALUE);
-  testFloor(-1, -Number.MIN_VALUE);
-  testFloor(Number.MAX_VALUE, Number.MAX_VALUE);
-  testFloor(-Number.MAX_VALUE, -Number.MAX_VALUE);
-  testFloor(Infinity, Infinity);
-  testFloor(-Infinity, -Infinity);
+  assertEquals(0, Math.floor(0));
+  assertEquals(0, Math.floor(zero()));
+  assertEquals(1/-0, 1/Math.floor(-0));  // 0 == -0, so we use reciprocals.
+  assertEquals(Infinity, Math.floor(Infinity));
+  assertEquals(-Infinity, Math.floor(-Infinity));
+  assertNaN(Math.floor(NaN));
+
+  assertEquals(0, Math.floor(0.1));
+  assertEquals(0, Math.floor(0.5));
+  assertEquals(0, Math.floor(0.7));
+  assertEquals(-1, Math.floor(-0.1));
+  assertEquals(-1, Math.floor(-0.5));
+  assertEquals(-1, Math.floor(-0.7));
+  assertEquals(1, Math.floor(1));
+  assertEquals(1, Math.floor(1.1));
+  assertEquals(1, Math.floor(1.5));
+  assertEquals(1, Math.floor(1.7));
+  assertEquals(-1, Math.floor(-1));
+  assertEquals(-2, Math.floor(-1.1));
+  assertEquals(-2, Math.floor(-1.5));
+  assertEquals(-2, Math.floor(-1.7));
+
+  assertEquals(0, Math.floor(Number.MIN_VALUE));
+  assertEquals(-1, Math.floor(-Number.MIN_VALUE));
+  assertEquals(Number.MAX_VALUE, Math.floor(Number.MAX_VALUE));
+  assertEquals(-Number.MAX_VALUE, Math.floor(-Number.MAX_VALUE));
+  assertEquals(Infinity, Math.floor(Infinity));
+  assertEquals(-Infinity, Math.floor(-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);
+  assertEquals(two_30, Math.floor(two_30));
+  assertEquals(two_30, Math.floor(two_30 + 0.1));
+  assertEquals(two_30, Math.floor(two_30 + 0.5));
+  assertEquals(two_30, Math.floor(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);
+  assertEquals(two_30 - 1, Math.floor(two_30 - 1));
+  assertEquals(two_30 - 1, Math.floor(two_30 - 1 + 0.1));
+  assertEquals(two_30 - 1, Math.floor(two_30 - 1 + 0.5));
+  assertEquals(two_30 - 1, Math.floor(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);
+  assertEquals(-two_30, Math.floor(-two_30));
+  assertEquals(-two_30, Math.floor(-two_30 + 0.1));
+  assertEquals(-two_30, Math.floor(-two_30 + 0.5));
+  assertEquals(-two_30, Math.floor(-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);
+  assertEquals(-two_30 + 1, Math.floor(-two_30 + 1));
+  assertEquals(-two_30 + 1, Math.floor(-two_30 + 1 + 0.1));
+  assertEquals(-two_30 + 1, Math.floor(-two_30 + 1 + 0.5));
+  assertEquals(-two_30 + 1, Math.floor(-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, Math.floor(two_52));
+  assertEquals(two_52, Math.floor(two_52 + 0.1));
   assertEquals(two_52, two_52 + 0.5);
-  testFloor(two_52, two_52 + 0.5);
+  assertEquals(two_52, Math.floor(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);
+  assertEquals(two_52 + 1, Math.floor(two_52 + 0.7));
+
+  assertEquals(two_52 - 1, Math.floor(two_52 - 1));
+  assertEquals(two_52 - 1, Math.floor(two_52 - 1 + 0.1));
+  assertEquals(two_52 - 1, Math.floor(two_52 - 1 + 0.5));
+  assertEquals(two_52 - 1, Math.floor(two_52 - 1 + 0.7));
+
+  assertEquals(-two_52, Math.floor(-two_52));
+  assertEquals(-two_52, Math.floor(-two_52 + 0.1));
+  assertEquals(-two_52, Math.floor(-two_52 + 0.5));
+  assertEquals(-two_52, Math.floor(-two_52 + 0.7));
+
+  assertEquals(-two_52 + 1, Math.floor(-two_52 + 1));
+  assertEquals(-two_52 + 1, Math.floor(-two_52 + 1 + 0.1));
+  assertEquals(-two_52 + 1, Math.floor(-two_52 + 1 + 0.5));
+  assertEquals(-two_52 + 1, Math.floor(-two_52 + 1 + 0.7));
 }
 
 
diff --git a/test/mjsunit/math-min-max.js b/test/mjsunit/math-min-max.js
index 0833c5c8..13d54a35 100644
--- a/test/mjsunit/math-min-max.js
+++ b/test/mjsunit/math-min-max.js
@@ -76,9 +76,9 @@ assertEquals(-1, Math.min(+0, -0, -1));
 assertEquals(-1, Math.min(-1, +0, -0));
 assertEquals(-1, Math.min(+0, -1, -0));
 assertEquals(-1, Math.min(-0, -1, +0));
-assertEquals(NaN, Math.min('oxen'));
-assertEquals(NaN, Math.min('oxen', 1));
-assertEquals(NaN, Math.min(1, 'oxen'));
+assertNaN(Math.min('oxen'));
+assertNaN(Math.min('oxen', 1));
+assertNaN(Math.min(1, 'oxen'));
 
 
 // Test Math.max().
@@ -109,9 +109,9 @@ assertEquals(1, Math.max(+0, -0, +1));
 assertEquals(1, Math.max(+1, +0, -0));
 assertEquals(1, Math.max(+0, +1, -0));
 assertEquals(1, Math.max(-0, +1, +0));
-assertEquals(NaN, Math.max('oxen'));
-assertEquals(NaN, Math.max('oxen', 1));
-assertEquals(NaN, Math.max(1, 'oxen'));
+assertNaN(Math.max('oxen'));
+assertNaN(Math.max('oxen', 1));
+assertNaN(Math.max(1, 'oxen'));
 
 assertEquals(Infinity, 1/Math.max(ZERO, -0));
 assertEquals(Infinity, 1/Math.max(-0, ZERO));
diff --git a/test/mjsunit/math-round.js b/test/mjsunit/math-round.js
index 1366557f..3b060885 100644
--- a/test/mjsunit/math-round.js
+++ b/test/mjsunit/math-round.js
@@ -25,133 +25,77 @@
 // (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 testRound(expect, input) {
-  function doRound(input) {
-    return Math.round(input);
-  }
-  assertEquals(expect, doRound(input));
-  assertEquals(expect, doRound(input));
-  assertEquals(expect, doRound(input));
-  %OptimizeFunctionOnNextCall(doRound);
-  assertEquals(expect, doRound(input));
-}
-
-testRound(0, 0);
-testRound(-0, -0);
-testRound(Infinity, Infinity);
-testRound(-Infinity, -Infinity);
-testRound(NaN, NaN);
-
-testRound(1, 0.5);
-testRound(1, 0.7);
-testRound(1, 1);
-testRound(1, 1.1);
-testRound(1, 1.49999);
-testRound(-0, -0.5);
-testRound(-1, -0.5000000000000001);
-testRound(-1, -0.7);
-testRound(-1, -1);
-testRound(-1, -1.1);
-testRound(-1, -1.49999);
-testRound(-1, -1.5);
-
-testRound(9007199254740990, 9007199254740990);
-testRound(9007199254740991, 9007199254740991);
-testRound(-9007199254740990, -9007199254740990);
-testRound(-9007199254740991, -9007199254740991);
-testRound(Number.MAX_VALUE, Number.MAX_VALUE);
-testRound(-Number.MAX_VALUE, -Number.MAX_VALUE);
-
-testRound(536870911, 536870910.5);
-testRound(536870911, 536870911);
-testRound(536870911, 536870911.4);
-testRound(536870912, 536870911.5);
-testRound(536870912, 536870912);
-testRound(536870912, 536870912.4);
-testRound(536870913, 536870912.5);
-testRound(536870913, 536870913);
-testRound(536870913, 536870913.4);
-testRound(1073741823, 1073741822.5);
-testRound(1073741823, 1073741823);
-testRound(1073741823, 1073741823.4);
-testRound(1073741824, 1073741823.5);
-testRound(1073741824, 1073741824);
-testRound(1073741824, 1073741824.4);
-testRound(1073741825, 1073741824.5);
-testRound(2147483647, 2147483646.5);
-testRound(2147483647, 2147483647);
-testRound(2147483647, 2147483647.4);
-testRound(2147483648, 2147483647.5);
-testRound(2147483648, 2147483648);
-testRound(2147483648, 2147483648.4);
-testRound(2147483649, 2147483648.5);
+assertEquals(0, Math.round(0));
+assertEquals(-0, Math.round(-0));
+assertEquals(Infinity, Math.round(Infinity));
+assertEquals(-Infinity, Math.round(-Infinity));
+assertNaN(Math.round(NaN));
+
+assertEquals(1, Math.round(0.5));
+assertEquals(1, Math.round(0.7));
+assertEquals(1, Math.round(1));
+assertEquals(1, Math.round(1.1));
+assertEquals(1, Math.round(1.49999));
+assertEquals(1/-0, 1/Math.round(-0.5));  // Test for -0 result.
+assertEquals(-1, Math.round(-0.5000000000000001));
+assertEquals(-1, Math.round(-0.7));
+assertEquals(-1, Math.round(-1));
+assertEquals(-1, Math.round(-1.1));
+assertEquals(-1, Math.round(-1.49999));
+assertEquals(-1, Math.round(-1.5));
+
+assertEquals(9007199254740990, Math.round(9007199254740990));
+assertEquals(9007199254740991, Math.round(9007199254740991));
+assertEquals(-9007199254740990, Math.round(-9007199254740990));
+assertEquals(-9007199254740991, Math.round(-9007199254740991));
+assertEquals(Number.MAX_VALUE, Math.round(Number.MAX_VALUE));
+assertEquals(-Number.MAX_VALUE, Math.round(-Number.MAX_VALUE));
+
+assertEquals(536870911, Math.round(536870910.5));
+assertEquals(536870911, Math.round(536870911));
+assertEquals(536870911, Math.round(536870911.4));
+assertEquals(536870912, Math.round(536870911.5));
+assertEquals(536870912, Math.round(536870912));
+assertEquals(536870912, Math.round(536870912.4));
+assertEquals(536870913, Math.round(536870912.5));
+assertEquals(536870913, Math.round(536870913));
+assertEquals(536870913, Math.round(536870913.4));
+assertEquals(1073741823, Math.round(1073741822.5));
+assertEquals(1073741823, Math.round(1073741823));
+assertEquals(1073741823, Math.round(1073741823.4));
+assertEquals(1073741824, Math.round(1073741823.5));
+assertEquals(1073741824, Math.round(1073741824));
+assertEquals(1073741824, Math.round(1073741824.4));
+assertEquals(1073741825, Math.round(1073741824.5));
+assertEquals(2147483647, Math.round(2147483646.5));
+assertEquals(2147483647, Math.round(2147483647));
+assertEquals(2147483647, Math.round(2147483647.4));
+assertEquals(2147483648, Math.round(2147483647.5));
+assertEquals(2147483648, Math.round(2147483648));
+assertEquals(2147483648, Math.round(2147483648.4));
+assertEquals(2147483649, Math.round(2147483648.5));
 
 // Tests based on WebKit LayoutTests
 
-testRound(0, 0.4);
-testRound(-0, -0.4);
-testRound(-0, -0.5);
-testRound(1, 0.6);
-testRound(-1, -0.6);
-testRound(2, 1.5);
-testRound(2, 1.6);
-testRound(-2, -1.6);
-testRound(8640000000000000, 8640000000000000);
-testRound(8640000000000001, 8640000000000001);
-testRound(8640000000000002, 8640000000000002);
-testRound(9007199254740990, 9007199254740990);
-testRound(9007199254740991, 9007199254740991);
-testRound(1.7976931348623157e+308, 1.7976931348623157e+308);
-testRound(-8640000000000000, -8640000000000000);
-testRound(-8640000000000001, -8640000000000001);
-testRound(-8640000000000002, -8640000000000002);
-testRound(-9007199254740990, -9007199254740990);
-testRound(-9007199254740991, -9007199254740991);
-testRound(-1.7976931348623157e+308, -1.7976931348623157e+308);
-testRound(Infinity, Infinity);
-testRound(-Infinity, -Infinity);
-
-  // Some special double number cases.
-var ulp = Math.pow(2, -1022 - 52);
-var max_denormal = (Math.pow(2, 52) - 1) * ulp;
-var min_normal = Math.pow(2, -1022);
-var max_fraction = Math.pow(2, 52) - 0.5;
-var min_nonfraction = Math.pow(2, 52);
-var max_non_infinite = Number.MAX_VALUE;
-
-var max_smi31 = Math.pow(2,30) - 1;
-var min_smi31 = -Math.pow(2,30);
-var max_smi32 = Math.pow(2,31) - 1;
-var min_smi32 = -Math.pow(2,31);
-
-testRound(0, ulp);
-testRound(0, max_denormal);
-testRound(0, min_normal);
-testRound(0, 0.49999999999999994);
-testRound(1, 0.5);
-testRound(Math.pow(2,52), max_fraction);
-testRound(min_nonfraction, min_nonfraction);
-testRound(max_non_infinite, max_non_infinite);
-
-testRound(max_smi31, max_smi31 - 0.5);
-testRound(max_smi31 + 1, max_smi31 + 0.5);
-testRound(max_smi32, max_smi32 - 0.5);
-testRound(max_smi32 + 1, max_smi32 + 0.5);
-
-testRound(-0, -ulp);
-testRound(-0, -max_denormal);
-testRound(-0, -min_normal);
-testRound(-0, -0.49999999999999994);
-testRound(-0, -0.5);
-testRound(-Math.pow(2,52)+1, -max_fraction);
-testRound(-min_nonfraction, -min_nonfraction);
-testRound(-max_non_infinite, -max_non_infinite);
-
-testRound(min_smi31, min_smi31 - 0.5);
-testRound(min_smi31 + 1, min_smi31 + 0.5);
-testRound(min_smi32, min_smi32 - 0.5);
-testRound(min_smi32 + 1, min_smi32 + 0.5);
-
-
+assertEquals(0, Math.round(0.4));
+assertEquals(-0, Math.round(-0.4));
+assertEquals(-0, Math.round(-0.5));
+assertEquals(1, Math.round(0.6));
+assertEquals(-1, Math.round(-0.6));
+assertEquals(2, Math.round(1.5));
+assertEquals(2, Math.round(1.6));
+assertEquals(-2, Math.round(-1.6));
+assertEquals(8640000000000000, Math.round(8640000000000000));
+assertEquals(8640000000000001, Math.round(8640000000000001));
+assertEquals(8640000000000002, Math.round(8640000000000002));
+assertEquals(9007199254740990, Math.round(9007199254740990));
+assertEquals(9007199254740991, Math.round(9007199254740991));
+assertEquals(1.7976931348623157e+308, Math.round(1.7976931348623157e+308));
+assertEquals(-8640000000000000, Math.round(-8640000000000000));
+assertEquals(-8640000000000001, Math.round(-8640000000000001));
+assertEquals(-8640000000000002, Math.round(-8640000000000002));
+assertEquals(-9007199254740990, Math.round(-9007199254740990));
+assertEquals(-9007199254740991, Math.round(-9007199254740991));
+assertEquals(-1.7976931348623157e+308, Math.round(-1.7976931348623157e+308));
+assertEquals(Infinity, Math.round(Infinity));
+assertEquals(-Infinity, Math.round(-Infinity));
diff --git a/test/mjsunit/mirror-number.js b/test/mjsunit/mirror-number.js
index fc71c123..2db5df43 100644
--- a/test/mjsunit/mirror-number.js
+++ b/test/mjsunit/mirror-number.js
@@ -50,10 +50,10 @@ function testNumberMirror(n) {
   // Parse JSON representation and check.
   var fromJSON = eval('(' + json + ')');
   assertEquals('number', fromJSON.type);
-  if (isFinite(n)) {
+  if (!isNaN(n)) {
     assertEquals(n, fromJSON.value);
   } else {
-    // NaN and Infinity values are encoded as strings.
+    // NaN values are encoded as strings.
     assertTrue(typeof fromJSON.value == 'string');
     if (n === Infinity) {
       assertEquals('Infinity', fromJSON.value);
diff --git a/test/mjsunit/mirror-object.js b/test/mjsunit/mirror-object.js
index d4d228cf..18885549 100644
--- a/test/mjsunit/mirror-object.js
+++ b/test/mjsunit/mirror-object.js
@@ -38,7 +38,7 @@ function MirrorRefCache(json_refs) {
 
 MirrorRefCache.prototype.lookup = function(handle) {
   return this.refs_[handle];
-};
+}
 
 function testObjectMirror(obj, cls_name, ctor_name, hasSpecialProperties) {
   // Create mirror and JSON representation.
@@ -66,7 +66,7 @@ function testObjectMirror(obj, cls_name, ctor_name, hasSpecialProperties) {
   assertFalse(mirror.hasIndexedInterceptor(), 'No indexed interceptor expected');
 
   var names = mirror.propertyNames();
-  var properties = mirror.properties();
+  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');
@@ -130,20 +130,15 @@ function testObjectMirror(obj, cls_name, ctor_name, hasSpecialProperties) {
           assertTrue(typeof(fromJSON.properties[i].attributes) === 'undefined', 'Unexpected serialized attributes');
         }
 
-        // Lookup the serialized object from the handle reference.
+        // Lookup the serialized object from the handle reference.        
         var o = refs.lookup(fromJSON.properties[i].ref);
         assertTrue(o != void 0, 'Referenced object is not serialized');
 
         assertEquals(properties[i].value().type(), o.type, 'Unexpected serialized property type for ' + name);
         if (properties[i].value().isPrimitive()) {
-          if (properties[i].value().type() == "null" ||
-              properties[i].value().type() == "undefined") {
-            // Null and undefined has no value property.
-            assertFalse("value" in o, 'Unexpected value property for ' + name);
-          } else if (properties[i].value().type() == "number" &&
-                     !isFinite(properties[i].value().value())) {
-            assertEquals(String(properties[i].value().value()), o.value,
-                         'Unexpected serialized property value for ' + name);
+          // Special check for NaN as NaN == NaN is false.
+          if (properties[i].value().isNumber() && isNaN(properties[i].value().value())) {
+            assertEquals('NaN', o.value, 'Unexpected serialized property value for ' + name);
           } else {
             assertEquals(properties[i].value().value(), o.value, 'Unexpected serialized property value for ' + name);
           }
diff --git a/test/mjsunit/mjsunit.js b/test/mjsunit/mjsunit.js
index faa5a438..436bdc81 100644
--- a/test/mjsunit/mjsunit.js
+++ b/test/mjsunit/mjsunit.js
@@ -31,325 +31,234 @@ function MjsUnitAssertionError(message) {
   this.stack = new Error("").stack;
 }
 
+MjsUnitAssertionError.prototype.toString = function () {
+  return this.message;
+}
+
 /*
  * This file is included in all mini jsunit test cases.  The test
  * framework expects lines that signal failed tests to start with
  * the f-word and ignore all other lines.
  */
 
-
-MjsUnitAssertionError.prototype.toString = function () {
-  return this.message;
-};
-
-
-// Expected and found values the same objects, or the same primitive
-// values.
-// For known primitive values, please use assertEquals.
-var assertSame;
-
-// Expected and found values are identical primitive values or functions
-// or similarly structured objects (checking internal properties
-// of, e.g., Number and Date objects, the elements of arrays
-// and the properties of non-Array objects).
-var assertEquals;
-
-// The found object is an Array with the same length and elements
-// as the expected object. The expected object doesn't need to be an Array,
-// as long as it's "array-ish".
-var assertArrayEquals;
-
-// The found object must have the same enumerable properties as the
-// expected object. The type of object isn't checked.
-var assertPropertiesEqual;
-
-// Assert that the string conversion of the found value is equal to
-// the expected string. Only kept for backwards compatability, please
-// check the real structure of the found value.
-var assertToStringEquals;
-
-// Checks that the found value is true. Use with boolean expressions
-// for tests that doesn't have their own assertXXX function.
-var assertTrue;
-
-// Checks that the found value is false.
-var assertFalse;
-
-// Checks that the found value is null. Kept for historical compatability,
-// please just use assertEquals(null, expected).
-var assertNull;
-
-// Checks that the found value is *not* null.
-var assertNotNull;
-
-// Assert that the passed function or eval code throws an exception.
-// The optional second argument is an exception constructor that the
-// thrown exception is checked against with "instanceof".
-// The optional third argument is a message type string that is compared
-// to the type property on the thrown exception.
-var assertThrows;
-
-// Assert that the passed function or eval code does not throw an exception.
-var assertDoesNotThrow;
-
-// Asserts that the found value is an instance of the constructor passed
-// as the second argument.
-var assertInstanceof;
-
-// Assert that this code is never executed (i.e., always fails if executed).
-var assertUnreachable;
-
-(function () {  // Scope for utility functions.
-
-  function classOf(object) {
-    // Argument must not be null or undefined.
-    var string = Object.prototype.toString.call(object);
-    // String has format [object <ClassName>].
-    return string.substring(8, string.length - 1);
-  }
-
-
-  function PrettyPrint(value) {
-    switch (typeof value) {
-      case "string":
-        return JSON.stringify(value);
-      case "number":
-        if (value === 0 && (1 / value) < 0) return "-0";
-        // FALLTHROUGH.
-      case "boolean":
-      case "undefined":
-      case "function":
-        return String(value);
-      case "object":
-        if (value === null) return "null";
-        var objectClass = classOf(value);
-        switch (objectClass) {
+function MjsUnitToString(value) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+      if (value === 0 && (1 / value) < 0) return "-0";
+    case "boolean":
+    case "null":
+    case "undefined":
+    case "function":
+      return String(value);
+    case "object":
+      if (value === null) return "null";
+      var clazz = Object.prototype.toString.call(value);
+      clazz = clazz.substring(8, clazz.length - 1);
+      switch (clazz) {
         case "Number":
         case "String":
         case "Boolean":
         case "Date":
-          return objectClass + "(" + PrettyPrint(value.valueOf()) + ")";
+          return clazz + "(" + MjsUnitToString(value.valueOf()) + ")";
         case "RegExp":
           return value.toString();
         case "Array":
-          return "[" + value.map(PrettyPrintArrayElement).join(",") + "]";
+          return "[" + value.map(MjsUnitArrayElementToString).join(",") + "]";
         case "Object":
           break;
         default:
-          return objectClass + "()";
-        }
-        // [[Class]] is "Object".
-        var name = value.constructor.name;
-        if (name) return name + "()";
-        return "Object()";
-      default:
-        return "-- unknown value --";
-    }
+          return clazz + "()";
+      }
+      // [[Class]] is "Object".
+      var constructor = value.constructor.name;
+      if (name) return name + "()";
+      return "Object()";
+    default:
+      return "-- unknown value --";
   }
+}
 
 
-  function PrettyPrintArrayElement(value, index, array) {
-    if (value === undefined && !(index in array)) return "";
-    return PrettyPrint(value);
-  }
-
+function MjsUnitArrayElementToString(value, index, array) {
+  if (value === undefined && !(index in array)) return "";
+  return MjsUnitToString(value);
+}
 
-  function fail(expectedText, found, name_opt) {
-    var message = "Fail" + "ure";
-    if (name_opt) {
-      // Fix this when we ditch the old test runner.
-      message += " (" + name_opt + ")";
-    }
 
-    message += ": expected <" + expectedText +
-        "> found <" + PrettyPrint(found) + ">";
-    throw new MjsUnitAssertionError(message);
+function fail(expected, found, name_opt) {
+  var message = "Fail" + "ure";
+  if (name_opt) {
+    // Fix this when we ditch the old test runner.
+    message += " (" + name_opt + ")";
   }
 
+  message += ": expected <" + MjsUnitToString(expected) +
+      "> found <" + MjsUnitToString(found) + ">";
+  throw new MjsUnitAssertionError(message);
+}
+
 
-  function deepObjectEquals(a, b) {
-    var aProps = Object.keys(a);
-    aProps.sort();
-    var bProps = Object.keys(b);
-    bProps.sort();
-    if (!deepEquals(aProps, bProps)) {
+function deepObjectEquals(a, b) {
+  var aProps = [];
+  for (var key in a)
+    aProps.push(key);
+  var bProps = [];
+  for (var key in b)
+    bProps.push(key);
+  aProps.sort();
+  bProps.sort();
+  if (!deepEquals(aProps, bProps))
+    return false;
+  for (var i = 0; i < aProps.length; i++) {
+    if (!deepEquals(a[aProps[i]], b[aProps[i]]))
       return false;
-    }
-    for (var i = 0; i < aProps.length; i++) {
-      if (!deepEquals(a[aProps[i]], b[aProps[i]])) {
-        return false;
-      }
-    }
-    return true;
   }
+  return true;
+}
 
 
-  function deepEquals(a, b) {
-    if (a === b) {
-      // Check for -0.
-      if (a === 0) return (1 / a) === (1 / b);
-      return true;
-    }
-    if (typeof a != typeof b) return false;
-    if (typeof a == "number") return isNaN(a) && isNaN(b);
-    if (typeof a !== "object" && typeof a !== "function") return false;
-    // Neither a nor b is primitive.
-    var objectClass = classOf(a);
-    if (objectClass !== classOf(b)) return false;
-    if (objectClass === "RegExp") {
-      // For RegExp, just compare pattern and flags using its toString.
-      return (a.toString() === b.toString());
-    }
-    // Functions are only identical to themselves.
-    if (objectClass === "Function") return false;
-    if (objectClass === "Array") {
-      var elementCount = 0;
-      if (a.length != b.length) {
+function deepEquals(a, b) {
+  if (a == b) {
+    // Check for -0.
+    if (a === 0 && b === 0) return (1 / a) === (1 / b);
+    return true;
+  }
+  if (typeof a == "number" && typeof b == "number" && isNaN(a) && isNaN(b)) {
+    return true;
+  }
+  if (a == null || b == null) return false;
+  if (a.constructor === RegExp || b.constructor === RegExp) {
+    return (a.constructor === b.constructor) && (a.toString() === b.toString());
+  }
+  if ((typeof a) !== 'object' || (typeof b) !== 'object' ||
+      (a === null) || (b === null))
+    return false;
+  if (a.constructor === Array) {
+    if (b.constructor !== Array)
+      return false;
+    if (a.length != b.length)
+      return false;
+    for (var i = 0; i < a.length; i++) {
+      if (i in a) {
+        if (!(i in b) || !(deepEquals(a[i], b[i])))
+          return false;
+      } else if (i in b) {
         return false;
       }
-      for (var i = 0; i < a.length; i++) {
-        if (!deepEquals(a[i], b[i])) return false;
-      }
-      return true;
-    }
-    if (objectClass == "String" || objectClass == "Number" ||
-      objectClass == "Boolean" || objectClass == "Date") {
-      if (a.valueOf() !== b.valueOf()) return false;
     }
+    return true;
+  } else {
     return deepObjectEquals(a, b);
   }
+}
 
 
-  assertSame = function assertSame(expected, found, name_opt) {
-    if (found === expected) {
-      if (expected !== 0 || (1 / expected) == (1 / found)) return;
-    } else if (isNaN(expected) && isNaN(found)) {
-      return;
-    }
-    fail(PrettyPrint(expected), found, name_opt);
-  };
-
-
-  assertEquals = function assertEquals(expected, found, name_opt) {
-    if (!deepEquals(found, expected)) {
-      fail(PrettyPrint(expected), found, name_opt);
-    }
-  };
+function assertSame(expected, found, name_opt) {
+  if (found !== expected) {
+    fail(expected, found, name_opt);
+  }
+}
 
 
-  assertArrayEquals = function assertArrayEquals(expected, found, name_opt) {
-    var start = "";
-    if (name_opt) {
-      start = name_opt + " - ";
-    }
-    assertEquals(expected.length, found.length, start + "array length");
-    if (expected.length == found.length) {
-      for (var i = 0; i < expected.length; ++i) {
-        assertEquals(expected[i], found[i],
-                     start + "array element at index " + i);
-      }
-    }
-  };
+function assertEquals(expected, found, name_opt) {
+  if (!deepEquals(found, expected)) {
+    fail(expected, found, name_opt);
+  }
+}
 
 
-  assertPropertiesEqual = function assertPropertiesEqual(expected, found,
-                                                         name_opt) {
-    // Check properties only.
-    if (!deepObjectEquals(expected, found)) {
-      fail(expected, found, name_opt);
+function assertArrayEquals(expected, found, name_opt) {
+  var start = "";
+  if (name_opt) {
+    start = name_opt + " - ";
+  }
+  assertEquals(expected.length, found.length, start + "array length");
+  if (expected.length == found.length) {
+    for (var i = 0; i < expected.length; ++i) {
+      assertEquals(expected[i], found[i], start + "array element at index " + i);
     }
-  };
+  }
+}
 
 
-  assertToStringEquals = function assertToStringEquals(expected, found,
-                                                       name_opt) {
-    if (expected != String(found)) {
-      fail(expected, found, name_opt);
-    }
-  };
+function assertTrue(value, name_opt) {
+  assertEquals(true, value, name_opt);
+}
 
 
-  assertTrue = function assertTrue(value, name_opt) {
-    assertEquals(true, value, name_opt);
-  };
+function assertFalse(value, name_opt) {
+  assertEquals(false, value, name_opt);
+}
 
 
-  assertFalse = function assertFalse(value, name_opt) {
-    assertEquals(false, value, name_opt);
-  };
+function assertNaN(value, name_opt) {
+  if (!isNaN(value)) {
+    fail("NaN", value, name_opt);
+  }
+}
 
 
-  assertNull = function assertNull(value, name_opt) {
-    if (value !== null) {
-      fail("null", value, name_opt);
-    }
-  };
+function assertNull(value, name_opt) {
+  if (value !== null) {
+    fail("null", value, name_opt);
+  }
+}
 
 
-  assertNotNull = function assertNotNull(value, name_opt) {
-    if (value === null) {
-      fail("not null", value, name_opt);
-    }
-  };
+function assertNotNull(value, name_opt) {
+  if (value === null) {
+    fail("not null", value, name_opt);
+  }
+}
 
 
-  assertThrows = function assertThrows(code, type_opt, cause_opt) {
-    var threwException = true;
-    try {
-      if (typeof code == 'function') {
-        code();
-      } else {
-        eval(code);
-      }
-      threwException = false;
-    } catch (e) {
-      if (typeof type_opt == 'function') {
-        assertInstanceof(e, type_opt);
-      }
-      if (arguments.length >= 3) {
-        assertEquals(e.type, cause_opt);
-      }
-      // Success.
-      return;
+function assertThrows(code, type_opt, cause_opt) {
+  var threwException = true;
+  try {
+    if (typeof code == 'function') {
+      code();
+    } else {
+      eval(code);
     }
-    throw new MjsUnitAssertionError("Did not throw exception");
-  };
-
+    threwException = false;
+  } catch (e) {
+    if (typeof type_opt == 'function')
+      assertInstanceof(e, type_opt);
+    if (arguments.length >= 3)
+      assertEquals(e.type, cause_opt);
+    // Do nothing.
+  }
+  if (!threwException) assertTrue(false, "did not throw exception");
+}
 
-  assertInstanceof = function assertInstanceof(obj, type) {
-    if (!(obj instanceof type)) {
-      var actualTypeName = null;
-      var actualConstructor = Object.prototypeOf(obj).constructor;
-      if (typeof actualConstructor == "function") {
-        actualTypeName = actualConstructor.name || String(actualConstructor);
-      }
-      fail("Object <" + PrettyPrint(obj) + "> is not an instance of <" +
-               (type.name || type) + ">" +
-               (actualTypeName ? " but of < " + actualTypeName + ">" : ""));
-    }
-  };
 
+function assertInstanceof(obj, type) {
+  if (!(obj instanceof type)) {
+    assertTrue(false, "Object <" + obj + "> is not an instance of <" + type + ">");
+  }
+}
 
-   assertDoesNotThrow = function assertDoesNotThrow(code, name_opt) {
-    try {
-      if (typeof code == 'function') {
-        code();
-      } else {
-        eval(code);
-      }
-    } catch (e) {
-      fail("threw an exception: ", e.message || e, name_opt);
-    }
-  };
 
-  assertUnreachable = function assertUnreachable(name_opt) {
-    // Fix this when we ditch the old test runner.
-    var message = "Fail" + "ure: unreachable";
-    if (name_opt) {
-      message += " - " + name_opt;
+function assertDoesNotThrow(code) {
+  try {
+    if (typeof code == 'function') {
+      code();
+    } else {
+      eval(code);
     }
-    throw new MjsUnitAssertionError(message);
-  };
+  } catch (e) {
+    assertTrue(false, "threw an exception: " + (e.message || e));
+  }
+}
 
-})();
 
+function assertUnreachable(name_opt) {
+  // Fix this when we ditch the old test runner.
+  var message = "Fail" + "ure: unreachable";
+  if (name_opt) {
+    message += " - " + name_opt;
+  }
+  throw new MjsUnitAssertionError(message);
+}
diff --git a/test/mjsunit/number-string-index-call.js b/test/mjsunit/number-string-index-call.js
index 4391917c..6f540c00 100644
--- a/test/mjsunit/number-string-index-call.js
+++ b/test/mjsunit/number-string-index-call.js
@@ -26,7 +26,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Flags: --call_regexp
-var callbacks = [ function() { return 'foo'; }, "nonobject", /abc/ ];
+var callbacks = [ function() {return 'foo'}, "nonobject", /abc/ ];
 assertEquals('foo', callbacks['0']());
 assertThrows("callbacks['1']()");
-assertEquals(['abc'], callbacks['2']("abcdefg"));
+assertEquals('abc', callbacks['2']("abcdefg"));
diff --git a/test/mjsunit/number-tostring.js b/test/mjsunit/number-tostring.js
index 35e77e2a..83120808 100644
--- a/test/mjsunit/number-tostring.js
+++ b/test/mjsunit/number-tostring.js
@@ -55,7 +55,7 @@ assertEquals("-90", (-90).toString());
 assertEquals("-90.12", (-90.12).toString());
 assertEquals("-0.1", (-0.1).toString());
 assertEquals("-0.01", (-0.01).toString());
-assertEquals("-0.0123", (-0.0123).toString());
+assertEquals("-0.0123", (-0.0123).toString())
 assertEquals("-111111111111111110000", (-111111111111111111111).toString());
 assertEquals("-1.1111111111111111e+21", (-1111111111111111111111).toString());
 assertEquals("-1.1111111111111111e+22", (-11111111111111111111111).toString());
@@ -219,7 +219,7 @@ assertEquals("0.12312312312312299889", (0.123123123123123).toFixed(20));
 // Test that we round up even when the last digit generated is even.
 // dtoa does not do this in its original form.
 assertEquals("1", 0.5.toFixed(0), "0.5.toFixed(0)");
-assertEquals("-1", (-0.5).toFixed(0), "(-0.5).toFixed(0)");
+assertEquals("-1", -0.5.toFixed(0), "-0.5.toFixed(0)");
 assertEquals("1.3", 1.25.toFixed(1), "1.25.toFixed(1)");
 // This is bizare, but Spidermonkey and KJS behave the same.
 assertEquals("234.2040", (234.20405).toFixed(4), "234.2040.toFixed(4)");
diff --git a/test/mjsunit/object-seal.js b/test/mjsunit/object-seal.js
index fb9bb921..3ce2367b 100644
--- a/test/mjsunit/object-seal.js
+++ b/test/mjsunit/object-seal.js
@@ -91,7 +91,7 @@ assertEquals("foobar", desc.value);
 // Since writable is not affected by seal we should still be able to
 // update the values.
 obj.x = "43";
-assertEquals("43", obj.x);
+assertEquals(43, obj.x);
 
 // Test on accessors.
 var obj2 = {};
@@ -142,7 +142,7 @@ assertFalse(Object.isSealed(arr));
 Object.seal(arr);
 assertTrue(Object.isSealed(arr));
 assertFalse(Object.isExtensible(arr));
-// Since the values in the array is still writable this object
+// Since the values in the array is still writable this object 
 // is not frozen.
 assertFalse(Object.isFrozen(arr));
 
@@ -186,5 +186,5 @@ Object.preventExtensions(obj4);
 assertFalse(Object.isSealed(obj4));
 
 // Make sure that Object.seal returns the sealed object.
-var obj4 = {};
-assertTrue(obj4 === Object.seal(obj4));
+var obj4 = {}
+assertTrue(obj4 === Object.seal(obj4))
diff --git a/test/mjsunit/override-eval-with-non-function.js b/test/mjsunit/override-eval-with-non-function.js
index edbcb19f..aa93b253 100644
--- a/test/mjsunit/override-eval-with-non-function.js
+++ b/test/mjsunit/override-eval-with-non-function.js
@@ -30,7 +30,7 @@
 
 function test() {
   eval = /foo/;
-  assertEquals(["foo"], eval("foobar"));
+  assertEquals("foo", eval("foobar"));
 }
 
 test();
diff --git a/test/mjsunit/regexp-capture.js b/test/mjsunit/regexp-capture.js
index 8aae7179..dc24491d 100755
--- a/test/mjsunit/regexp-capture.js
+++ b/test/mjsunit/regexp-capture.js
@@ -39,20 +39,19 @@ assertEquals(0, "y".search(/(x)?\1y/));
 assertEquals("z", "y".replace(/(x)?\1y/, "z"));
 assertEquals("", "y".replace(/(x)?y/, "$1"));
 assertEquals("undefined", "y".replace(/(x)?\1y/,
-    function($0, $1){
-        return String($1);
+    function($0, $1){ 
+        return String($1); 
     }));
-assertEquals("undefined", "y".replace(/(x)?y/,
-    function($0, $1){
-        return String($1);
+assertEquals("undefined", "y".replace(/(x)?y/, 
+    function($0, $1){ 
+        return String($1); 
     }));
-assertEquals("undefined", "y".replace(/(x)?y/,
-    function($0, $1){
-        return $1;
+assertEquals("undefined", "y".replace(/(x)?y/, 
+    function($0, $1){ 
+        return $1; 
     }));
 
 // See https://bugzilla.mozilla.org/show_bug.cgi?id=476146
-assertEquals(["bbc", "b"], /^(b+|a){1,2}?bc/.exec("bbc"));
-assertEquals(["bbaa", "a", "", "a"],
-             /((\3|b)\2(a)){2,}/.exec("bbaababbabaaaaabbaaaabba"));
+assertEquals("bbc,b", /^(b+|a){1,2}?bc/.exec("bbc"));
+assertEquals("bbaa,a,,a", /((\3|b)\2(a)){2,}/.exec("bbaababbabaaaaabbaaaabba"));
 
diff --git a/test/mjsunit/regexp-compile.js b/test/mjsunit/regexp-compile.js
index 6a24325e..6f8e7519 100644
--- a/test/mjsunit/regexp-compile.js
+++ b/test/mjsunit/regexp-compile.js
@@ -27,16 +27,16 @@
 
 // Test that we don't cache the result of a regexp match across a
 // compile event.
-var re = /x/;
+var re = /x/; 
 assertEquals("a.yb", "axyb".replace(re, "."));
 
-re.compile("y");
+re.compile("y")
 assertEquals("ax.b", "axyb".replace(re, "."));
 
 re.compile("(x)");
 
-assertEquals(["x", "x"], re.exec("axyb"));
+assertEquals("x,x", re.exec("axyb"));
 
 re.compile("(y)");
 
-assertEquals(["y", "y"], re.exec("axyb"));
+assertEquals("y,y", re.exec("axyb"));
diff --git a/test/mjsunit/regexp-static.js b/test/mjsunit/regexp-static.js
index 0f849687..9e73f3d6 100644
--- a/test/mjsunit/regexp-static.js
+++ b/test/mjsunit/regexp-static.js
@@ -134,8 +134,7 @@ function f() { return RegExp.$1; };
 assertEquals('abcd', 'abcd'.replace(re, f));
 
 // lastParen where the last parenthesis didn't match.
-assertEquals(["foo",undefined], /foo(?:a(x))?/.exec("foobx"),
-             "lastParen setup");
+assertEquals("foo,", /foo(?:a(x))?/.exec("foobx"), "lastParen setup");
 assertEquals("", RegExp.lastParen, "lastParen");
 
 // The same test for $1 to $9.
diff --git a/test/mjsunit/regexp-string-methods.js b/test/mjsunit/regexp-string-methods.js
index 56604a65..ef3bf6ea 100644
--- a/test/mjsunit/regexp-string-methods.js
+++ b/test/mjsunit/regexp-string-methods.js
@@ -28,18 +28,18 @@
 // Regexp shouldn't use String.prototype.slice()
 var s = new String("foo");
 assertEquals("f", s.slice(0,1));
-String.prototype.slice = function() { return "x"; };
+String.prototype.slice = function() { return "x"; }
 assertEquals("x", s.slice(0,1));
-assertEquals(["g"], /g/.exec("gg"));
+assertEquals("g", /g/.exec("gg"));
 
 // Regexp shouldn't use String.prototype.charAt()
 var f1 = new RegExp("f", "i");
-assertEquals(["F"], f1.exec("F"));
+assertEquals("F", f1.exec("F"));
 assertEquals("f", "foo".charAt(0));
 String.prototype.charAt = function(idx) { return 'g'; };
 assertEquals("g", "foo".charAt(0));
 var f2 = new RegExp("[g]", "i");
-assertEquals(["G"], f2.exec("G"));
+assertEquals("G", f2.exec("G"));
 assertTrue(f2.ignoreCase);
 
 // On the other hand test is defined in a semi-coherent way as a call to exec.
@@ -47,5 +47,5 @@ assertTrue(f2.ignoreCase);
 // We match other browsers in using the original value of RegExp.prototype.exec.
 // I.e., RegExp.prototype.test shouldn't use the current value of
 // RegExp.prototype.exec.
-RegExp.prototype.exec = function(string) { return 'x'; };
+RegExp.prototype.exec = function(string) { return 'x'; }
 assertFalse(/f/.test('x'));
diff --git a/test/mjsunit/regexp.js b/test/mjsunit/regexp.js
index 3c4f883b..24e1b21e 100644
--- a/test/mjsunit/regexp.js
+++ b/test/mjsunit/regexp.js
@@ -333,9 +333,9 @@ assertFalse(/f(o)$\1/.test('foo'), "backref detects at_end");
 
 // Check decimal escapes doesn't overflow.
 // (Note: \214 is interpreted as octal).
-assertArrayEquals(["\x8c7483648"],
-                  /\2147483648/.exec("\x8c7483648"),
-                  "Overflow decimal escape");
+assertEquals(/\2147483648/.exec("\x8c7483648"),
+             ["\x8c7483648"],
+             "Overflow decimal escape");
 
 
 // Check numbers in quantifiers doesn't overflow and doesn't throw on
@@ -435,8 +435,8 @@ assertEquals(0, re.lastIndex);
 re.lastIndex = 42;
 re.someOtherProperty = 42;
 re.someDeletableProperty = 42;
-re[37] = 37;
-re[42] = 42;
+re[37] = 37;  
+re[42] = 42;  
 
 re.compile("ra+", "i");
 assertEquals("ra+", re.source);
@@ -466,7 +466,7 @@ assertEquals(37, re.someOtherProperty);
 assertEquals(37, re[42]);
 
 // Test boundary-checks.
-function assertRegExpTest(re, input, test) {
+function assertRegExpTest(re, input, test) { 
   assertEquals(test, re.test(input), "test:" + re + ":" + input);
 }
 
@@ -525,7 +525,7 @@ for (var i = 0; i < 100; i++) {
   assertEquals(1, res.index);
   assertEquals("axyzb", res.input);
   assertEquals(undefined, res.foobar);
-
+  
   res.foobar = "Arglebargle";
   res[3] = "Glopglyf";
   assertEquals("Arglebargle", res.foobar);
@@ -534,18 +534,18 @@ for (var i = 0; i < 100; i++) {
 // Test that we perform the spec required conversions in the correct order.
 var log;
 var string = "the string";
-var fakeLastIndex = {
-      valueOf: function() {
+var fakeLastIndex = { 
+      valueOf: function() { 
         log.push("li");
         return 0;
-      }
+      } 
     };
-var fakeString = {
+var fakeString = { 
       toString: function() {
         log.push("ts");
         return string;
-      },
-      length: 0
+      }, 
+      length: 0 
     };
 
 var re = /str/;
diff --git a/test/mjsunit/regress/regress-1122.js b/test/mjsunit/regress/regress-1122.js
index 7dc9b248..815511d1 100644
--- a/test/mjsunit/regress/regress-1122.js
+++ b/test/mjsunit/regress/regress-1122.js
@@ -25,12 +25,14 @@
 // (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 can handle functions with up to 32766 arguments, and that
-// functions with more arguments throw an exception.
+// Test that we can handle function calls with up to 32766 arguments, and
+// that function calls with more arguments throw an exception.  Apply a
+// similar limit to the number of function parameters.
 
-// See http://code.google.com/p/v8/issues/detail?id=1122.
+// See http://code.google.com/p/v8/issues/detail?id=1122 and
+// http://code.google.com/p/v8/issues/detail?id=1413.
 
-function function_with_n_args(n) {
+function function_with_n_params_and_m_args(n, m) {
   test_prefix = 'prefix ';
   test_suffix = ' suffix';
   var source = 'test_prefix + (function f(';
@@ -39,7 +41,7 @@ function function_with_n_args(n) {
     source += 'arg' + arg;
   }
   source += ') { return arg' + (n - n % 2) / 2 + '; })(';
-  for (var arg = 0; arg < n ; arg++) {
+  for (var arg = 0; arg < m ; arg++) {
     if (arg != 0) source += ',';
     source += arg;
   }
@@ -47,9 +49,20 @@ function function_with_n_args(n) {
   return eval(source);
 }
 
-assertEquals('prefix 4000 suffix', function_with_n_args(8000));
-assertEquals('prefix 9000 suffix', function_with_n_args(18000));
-assertEquals('prefix 16000 suffix', function_with_n_args(32000));
+assertEquals('prefix 4000 suffix',
+             function_with_n_params_and_m_args(8000, 8000));
+assertEquals('prefix 3000 suffix',
+             function_with_n_params_and_m_args(6000, 8000));
+assertEquals('prefix 5000 suffix',
+             function_with_n_params_and_m_args(10000, 8000));
+assertEquals('prefix 9000 suffix',
+             function_with_n_params_and_m_args(18000, 18000));
+assertEquals('prefix 16000 suffix',
+             function_with_n_params_and_m_args(32000, 32000));
+assertEquals('prefix undefined suffix',
+             function_with_n_params_and_m_args(32000, 10000));
 
-assertThrows("function_with_n_args(35000)");
-assertThrows("function_with_n_args(100000)");
+assertThrows("function_with_n_params_and_m_args(35000, 35000)");
+assertThrows("function_with_n_params_and_m_args(100000, 100000)");
+assertThrows("function_with_n_params_and_m_args(35000, 30000)");
+assertThrows("function_with_n_params_and_m_args(30000, 35000)");
diff --git a/test/mjsunit/regress/regress-1199637.js b/test/mjsunit/regress/regress-1199637.js
index 9c560a95..d9116c1d 100644
--- a/test/mjsunit/regress/regress-1199637.js
+++ b/test/mjsunit/regress/regress-1199637.js
@@ -34,43 +34,43 @@ const NONE = 0;
 const READ_ONLY = 1;
 
 // Use DeclareGlobal...
-%SetProperty(this.__proto__, "a", 1234, NONE);
+%SetProperty(this.__proto__, "a", "1234", NONE);
 assertEquals(1234, a);
 eval("var a = 5678;");
 assertEquals(5678, a);
 
-%SetProperty(this.__proto__, "b", 1234, NONE);
+%SetProperty(this.__proto__, "b", "1234", NONE);
 assertEquals(1234, b);
 eval("const b = 5678;");
 assertEquals(5678, b);
 
-%SetProperty(this.__proto__, "c", 1234, READ_ONLY);
+%SetProperty(this.__proto__, "c", "1234", READ_ONLY);
 assertEquals(1234, c);
 eval("var c = 5678;");
 assertEquals(5678, c);
 
-%SetProperty(this.__proto__, "d", 1234, READ_ONLY);
+%SetProperty(this.__proto__, "d", "1234", READ_ONLY);
 assertEquals(1234, d);
 eval("const d = 5678;");
 assertEquals(5678, d);
 
 // Use DeclareContextSlot...
-%SetProperty(this.__proto__, "x", 1234, NONE);
+%SetProperty(this.__proto__, "x", "1234", NONE);
 assertEquals(1234, x);
 eval("with({}) { var x = 5678; }");
 assertEquals(5678, x);
 
-%SetProperty(this.__proto__, "y", 1234, NONE);
+%SetProperty(this.__proto__, "y", "1234", NONE);
 assertEquals(1234, y);
 eval("with({}) { const y = 5678; }");
 assertEquals(5678, y);
 
-%SetProperty(this.__proto__, "z", 1234, READ_ONLY);
+%SetProperty(this.__proto__, "z", "1234", READ_ONLY);
 assertEquals(1234, z);
 eval("with({}) { var z = 5678; }");
 assertEquals(5678, z);
 
-%SetProperty(this.__proto__, "w", 1234, READ_ONLY);
+%SetProperty(this.__proto__, "w", "1234", READ_ONLY);
 assertEquals(1234, w);
 eval("with({}) { const w = 5678; }");
 assertEquals(5678, w);
diff --git a/src/proxy.js b/test/mjsunit/regress/regress-1403.js
index 25169831..f2520ccb 100644
--- a/src/proxy.js
+++ b/test/mjsunit/regress/regress-1403.js
@@ -25,4 +25,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-global.Proxy = new $Object();
+// See: http://code.google.com/p/v8/issues/detail?id=1403
+
+a = [];
+Object.prototype.__proto__ = { __proto__: null };
+a.shift();
+
+a = [];
+Array.prototype.__proto__ = { __proto__: null };
+a.shift();
diff --git a/test/mjsunit/regress/regress-176.js b/test/mjsunit/regress/regress-176.js
index ef0c4f11..b2048124 100644
--- a/test/mjsunit/regress/regress-176.js
+++ b/test/mjsunit/regress/regress-176.js
@@ -27,24 +27,24 @@
 
 // See http://code.google.com/p/v8/issues/detail?id=176
 
-assertArrayEquals(["f", undefined],
-                  "foo".match(/(?:(?=(f)o))?f/),
-                  "zero length match in (?:) with capture in lookahead");
-assertArrayEquals(["f", undefined],
-                  "foo".match(/(?=(f)o)?f/),
-                  "zero length match in (?=) with capture in lookahead");
-assertArrayEquals(["fo", "f"],
-                  "foo".match(/(?:(?=(f)o)f)?o/),
-                  "non-zero length match with capture in lookahead");
-assertArrayEquals(["fo", "f"],
-                  "foo".match(/(?:(?=(f)o)f?)?o/),
-                  "non-zero length match with greedy ? in (?:)");
-assertArrayEquals(["fo", "f"],
-                  "foo".match(/(?:(?=(f)o)f??)?o/),
-                  "non-zero length match with non-greedy ? in (?:), o forces backtrack");
-assertArrayEquals(["fo", "f"],
-                  "foo".match(/(?:(?=(f)o)f??)?./),
-                  "non-zero length match with non-greedy ? in (?:), zero length match causes backtrack");
-assertArrayEquals(["f", undefined],
-                  "foo".match(/(?:(?=(f)o)fx)?./),
-                  "x causes backtrack inside (?:)");
+assertEquals("f,",
+             "foo".match(/(?:(?=(f)o))?f/).toString(),
+             "zero length match in (?:) with capture in lookahead");
+assertEquals("f,",
+             "foo".match(/(?=(f)o)?f/).toString(),
+             "zero length match in (?=) with capture in lookahead");
+assertEquals("fo,f",
+             "foo".match(/(?:(?=(f)o)f)?o/),
+             "non-zero length match with capture in lookahead");
+assertEquals("fo,f",
+             "foo".match(/(?:(?=(f)o)f?)?o/),
+             "non-zero length match with greedy ? in (?:)");
+assertEquals("fo,f",
+             "foo".match(/(?:(?=(f)o)f??)?o/),
+             "non-zero length match with non-greedy ? in (?:), o forces backtrack");
+assertEquals("fo,f",
+             "foo".match(/(?:(?=(f)o)f??)?./),
+             "non-zero length match with non-greedy ? in (?:), zero length match causes backtrack");
+assertEquals("f,",
+             "foo".match(/(?:(?=(f)o)fx)?./),
+             "x causes backtrack inside (?:)");
diff --git a/test/mjsunit/regress/regress-187.js b/test/mjsunit/regress/regress-187.js
index 2f8b0a15..44d8d7a5 100644
--- a/test/mjsunit/regress/regress-187.js
+++ b/test/mjsunit/regress/regress-187.js
@@ -27,4 +27,4 @@
 
 // See http://code.google.com/p/v8/issues/detail?id=187
 
-assertEquals(["f", undefined], "foo".match(/(?:(?=(f)o)fx|)./));
+assertEquals("f,", "foo".match(/(?:(?=(f)o)fx|)./));
diff --git a/test/mjsunit/regress/regress-399.js b/test/mjsunit/regress/regress-399.js
index 6c8eab54..2ee998ba 100644
--- a/test/mjsunit/regress/regress-399.js
+++ b/test/mjsunit/regress/regress-399.js
@@ -28,5 +28,5 @@
 // See http://code.google.com/p/v8/issues/detail?id=399
 
 var date = new Date(1.009804e12);
-var year = Number(String(date).match(/.*(200\d)/)[1]);
+var year = String(date).match(/.*(200\d)/)[1];
 assertEquals(year, date.getFullYear());
diff --git a/test/mjsunit/regress/regress-1341167.js b/test/mjsunit/regress/splice-missing-wb.js
index 194a7b88..5ff0d81e 100644
--- a/test/mjsunit/regress/regress-1341167.js
+++ b/test/mjsunit/regress/splice-missing-wb.js
@@ -1,4 +1,4 @@
-// Copyright 2008 the V8 project authors. All rights reserved.
+// 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:
@@ -25,9 +25,32 @@
 // (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 that 'this' is bound to the global object when using
-// execScript.
+// Flags: --expose-gc
 
-var result;
-execScript("result = this");
-assertTrue(result === this);
+// Create array large enough to span several page regions.
+var a = new Array(500);
+
+// Fill it with values.
+for (var i = 0; i < a.length; i++) a[i] = {idx:i};
+
+// Force it into oldspace.
+gc();
+gc();
+
+// Array should be in old space now. Store young object into array.
+// Region will be marked.
+a[0] = {idx:0};
+
+// Delete elements a[2] .. a[201]. Internally we will use
+// trimming of backing store. a[0] a[1] will be moved to
+// memory location previously occupied by a[200] a[201].
+a.splice(2, 200);
+
+// Force gc and heap verification.
+gc();
+
+// Try accessing a[0].idx. It will segfault if write-barrier was accidentally
+// omitted.
+assertEquals(0, a[0].idx);
+assertEquals(1, a[1].idx);
+assertEquals(202, a[2].idx);
diff --git a/test/mjsunit/string-fromcharcode.js b/test/mjsunit/string-fromcharcode.js
index 1986dda0..7a2db5f9 100644
--- a/test/mjsunit/string-fromcharcode.js
+++ b/test/mjsunit/string-fromcharcode.js
@@ -65,10 +65,8 @@ function test(num) {
   assertEquals("  ", fcc(0x20 + 0.5, 0x20));
 
   var receiver = (num < 5) ? String : (num < 9) ? "dummy" : 42;
-  fcc2 = (num < 5) ? fcc
-                   : (num < 9) ? constFun(Object("dummy"))
-                               : constFun(Object(42));
-  var expected = (num < 5) ? " " : (num < 9) ? Object("dummy") : Object(42);
+  fcc2 = (num < 5) ? fcc : (num < 9) ? constFun("dummy") : constFun(42);
+  var expected = (num < 5) ? " " : (num < 9) ? "dummy" : 42;
   assertEquals(expected, receiver.fromCharCode(0x20));
   assertEquals(expected, receiver.fromCharCode(0x20 - 0x10000));
   assertEquals(expected, receiver.fromCharCode(0x20 + 0.5));
diff --git a/test/mjsunit/string-index.js b/test/mjsunit/string-index.js
index 315708ca..1d6476ea 100644
--- a/test/mjsunit/string-index.js
+++ b/test/mjsunit/string-index.js
@@ -61,7 +61,7 @@ assertEquals("undefined", typeof(foo[3]), "out of range");
 assertEquals("undefined", typeof(foo[-2]), "negative index");
 
 var S = new String("foo");
-assertEquals(Object("foo"), S);
+assertEquals("foo", S);
 assertEquals("f", S[0], "string object");
 assertEquals("f", S["0"], "string object");
 S[0] = 'bente';
@@ -131,7 +131,7 @@ assertEquals(false, 3 in S);
 assertEquals(false, "3" in S);
 
 var N = new Number(43);
-assertEquals(Object(43), N);
+assertEquals(43, N);
 N[-2] = "Alpha";
 assertEquals("Alpha", N[-2]);
 N[0] = "Zappa";
diff --git a/test/mjsunit/testcfg.py b/test/mjsunit/testcfg.py
index f7b6d4da..3dd65817 100644
--- a/test/mjsunit/testcfg.py
+++ b/test/mjsunit/testcfg.py
@@ -107,7 +107,7 @@ class MjsunitTestCase(test.TestCase):
     return self_script
 
   def AfterRun(self, result):
-    if self.self_script and (not result or (not result.HasPreciousOutput())):
+    if self.self_script and (not result.HasPreciousOutput()):
       test.CheckedUnlink(self.self_script)
 
 class MjsunitTestConfiguration(test.TestConfiguration):
diff --git a/test/mjsunit/third_party/object-keys.js b/test/mjsunit/third_party/object-keys.js
index d09265c6..999ce704 100644
--- a/test/mjsunit/third_party/object-keys.js
+++ b/test/mjsunit/third_party/object-keys.js
@@ -54,7 +54,7 @@ assertEquals(Object.keys(function () {}), []);
 assertEquals('string', typeof(Object.keys([1])[0]));
 
 function argsTest(a, b, c) {
-  assertEquals(['0', '1', '2'], Object.keys(arguments));
+  assertEquals([0, 1, 2], Object.keys(arguments));
 }
 
 argsTest(1, 2, 3);
diff --git a/test/mjsunit/third_party/regexp-pcre.js b/test/mjsunit/third_party/regexp-pcre.js
index c049fb4d..dcb1b320 100644
--- a/test/mjsunit/third_party/regexp-pcre.js
+++ b/test/mjsunit/third_party/regexp-pcre.js
@@ -1643,135 +1643,135 @@ res[1563] = /[^a]/m;
 res[1564] = /[^\xaa]/m;
 res[1565] = /[^\xaa]/m;
 res[1566] = / End of testinput10 /;
-assertToStringEquals("abc", res[1].exec("abc"), 0);
-assertToStringEquals("abc", res[1].exec("defabc"), 1);
-assertToStringEquals("abc", res[1].exec("Aabc"), 2);
-assertNull(res[1].exec("*** Failers", 3));
-assertToStringEquals("abc", res[1].exec("Adefabc"), 4);
-assertToStringEquals("ABC", res[1].exec("ABC"), 5);
-assertToStringEquals("abc", res[2].exec("abc"), 6);
-assertNull(res[2].exec("Aabc", 7));
-assertNull(res[2].exec("*** Failers", 8));
-assertNull(res[2].exec("defabc", 9));
-assertNull(res[2].exec("Adefabc", 10));
-assertToStringEquals("abc", res[7].exec("abc"), 11);
-assertNull(res[7].exec("*** Failers", 12));
-assertNull(res[7].exec("def\nabc", 13));
+assertEquals("abc", res[1].exec("abc"), 0);
+assertEquals("abc", res[1].exec("defabc"), 1);
+assertEquals("abc", res[1].exec("Aabc"), 2);
+assertEquals(null, res[1].exec("*** Failers", 3));
+assertEquals("abc", res[1].exec("Adefabc"), 4);
+assertEquals("ABC", res[1].exec("ABC"), 5);
+assertEquals("abc", res[2].exec("abc"), 6);
+assertEquals(null, res[2].exec("Aabc", 7));
+assertEquals(null, res[2].exec("*** Failers", 8));
+assertEquals(null, res[2].exec("defabc", 9));
+assertEquals(null, res[2].exec("Adefabc", 10));
+assertEquals("abc", res[7].exec("abc"), 11);
+assertEquals(null, res[7].exec("*** Failers", 12));
+assertEquals(null, res[7].exec("def\nabc", 13));
 assertThrows("var re = /x{5,4}/;", 14);
 assertThrows("var re = /[abcd/;", 15);
 assertThrows("var re = /[z-a]/;", 16);
 assertThrows("var re = /^*/;", 17);
 assertThrows("var re = /(abc/;", 18);
 assertThrows("var re = /(?# abc/;", 19);
-assertToStringEquals("cat", res[11].exec("this sentence eventually mentions a cat"), 20);
-assertToStringEquals("elephant", res[11].exec("this sentences rambles on and on for a while and then reaches elephant"), 21);
-assertToStringEquals("cat", res[12].exec("this sentence eventually mentions a cat"), 22);
-assertToStringEquals("elephant", res[12].exec("this sentences rambles on and on for a while and then reaches elephant"), 23);
-assertToStringEquals("CAT", res[13].exec("this sentence eventually mentions a CAT cat"), 24);
-assertToStringEquals("elephant", res[13].exec("this sentences rambles on and on for a while to elephant ElePhant"), 25);
+assertEquals("cat", res[11].exec("this sentence eventually mentions a cat"), 20);
+assertEquals("elephant", res[11].exec("this sentences rambles on and on for a while and then reaches elephant"), 21);
+assertEquals("cat", res[12].exec("this sentence eventually mentions a cat"), 22);
+assertEquals("elephant", res[12].exec("this sentences rambles on and on for a while and then reaches elephant"), 23);
+assertEquals("CAT", res[13].exec("this sentence eventually mentions a CAT cat"), 24);
+assertEquals("elephant", res[13].exec("this sentences rambles on and on for a while to elephant ElePhant"), 25);
 assertThrows("var re = /{4,5}abc/;", 26);
-assertToStringEquals("abcb,a,b,c", res[18].exec("abcb"), 27);
-assertToStringEquals("abcb,a,b,c", res[18].exec("O0abcb"), 28);
-assertToStringEquals("abcb,a,b,c", res[18].exec("O3abcb"), 29);
-assertToStringEquals("abcb,a,b,c", res[18].exec("O6abcb"), 30);
-assertToStringEquals("abcb,a,b,c", res[18].exec("O9abcb"), 31);
-assertToStringEquals("abcb,a,b,c", res[18].exec("O12abcb"), 32);
-assertToStringEquals("abc,a,,", res[19].exec("abc"), 33);
-assertToStringEquals("abc,a,,", res[19].exec("O0abc"), 34);
-assertToStringEquals("abc,a,,", res[19].exec("O3abc"), 35);
-assertToStringEquals("abc,a,,", res[19].exec("O6abc"), 36);
-assertToStringEquals("aba,,a,b", res[19].exec("aba"), 37);
-assertToStringEquals("aba,,a,b", res[19].exec("O0aba"), 38);
-assertToStringEquals("aba,,a,b", res[19].exec("O3aba"), 39);
-assertToStringEquals("aba,,a,b", res[19].exec("O6aba"), 40);
-assertToStringEquals("aba,,a,b", res[19].exec("O9aba"), 41);
-assertToStringEquals("aba,,a,b", res[19].exec("O12aba"), 42);
-assertToStringEquals("abc", res[20].exec("abc"), 43);
-assertNull(res[20].exec("*** Failers", 44));
-assertNull(res[20].exec("abc\n", 45));
-assertNull(res[20].exec("abc\ndef", 46));
-assertToStringEquals("the quick brown fox", res[22].exec("the quick brown fox"), 47);
-assertToStringEquals("the quick brown fox", res[22].exec("this is a line with the quick brown fox"), 48);
-assertToStringEquals("abc", res[23].exec("abcdef"), 49);
-assertToStringEquals("abc", res[23].exec("abcdefB"), 50);
-assertToStringEquals("defabc,abc,abc,", res[24].exec("defabc"), 51);
-assertToStringEquals("Zdefabc,abc,abc,", res[24].exec("Zdefabc"), 52);
-assertToStringEquals("abc", res[25].exec("abc"), 53);
-assertNull(res[25].exec("*** Failers", 54));
-assertToStringEquals("abc", res[26].exec("abcdef"), 55);
-assertToStringEquals("abc", res[26].exec("abcdefB"), 56);
-assertToStringEquals("defabc,abc,abc,", res[27].exec("defabc"), 57);
-assertToStringEquals("Zdefabc,abc,abc,", res[27].exec("Zdefabc"), 58);
-assertToStringEquals("the quick brown fox", res[28].exec("the quick brown fox"), 59);
-assertNull(res[28].exec("*** Failers", 60));
-assertToStringEquals("The Quick Brown Fox", res[28].exec("The Quick Brown Fox"), 61);
-assertToStringEquals("the quick brown fox", res[29].exec("the quick brown fox"), 62);
-assertToStringEquals("The Quick Brown Fox", res[29].exec("The Quick Brown Fox"), 63);
-assertNull(res[30].exec("*** Failers", 64));
-assertNull(res[30].exec("abc\ndef", 65));
-assertToStringEquals("abc", res[31].exec("abc"), 66);
-assertNull(res[31].exec("abc\n", 67));
-assertToStringEquals("abc,abc", res[33].exec("abc"), 68);
+assertEquals("abcb,a,b,c", res[18].exec("abcb"), 27);
+assertEquals("abcb,a,b,c", res[18].exec("O0abcb"), 28);
+assertEquals("abcb,a,b,c", res[18].exec("O3abcb"), 29);
+assertEquals("abcb,a,b,c", res[18].exec("O6abcb"), 30);
+assertEquals("abcb,a,b,c", res[18].exec("O9abcb"), 31);
+assertEquals("abcb,a,b,c", res[18].exec("O12abcb"), 32);
+assertEquals("abc,a,,", res[19].exec("abc"), 33);
+assertEquals("abc,a,,", res[19].exec("O0abc"), 34);
+assertEquals("abc,a,,", res[19].exec("O3abc"), 35);
+assertEquals("abc,a,,", res[19].exec("O6abc"), 36);
+assertEquals("aba,,a,b", res[19].exec("aba"), 37);
+assertEquals("aba,,a,b", res[19].exec("O0aba"), 38);
+assertEquals("aba,,a,b", res[19].exec("O3aba"), 39);
+assertEquals("aba,,a,b", res[19].exec("O6aba"), 40);
+assertEquals("aba,,a,b", res[19].exec("O9aba"), 41);
+assertEquals("aba,,a,b", res[19].exec("O12aba"), 42);
+assertEquals("abc", res[20].exec("abc"), 43);
+assertEquals(null, res[20].exec("*** Failers", 44));
+assertEquals(null, res[20].exec("abc\n", 45));
+assertEquals(null, res[20].exec("abc\ndef", 46));
+assertEquals("the quick brown fox", res[22].exec("the quick brown fox"), 47);
+assertEquals("the quick brown fox", res[22].exec("this is a line with the quick brown fox"), 48);
+assertEquals("abc", res[23].exec("abcdef"), 49);
+assertEquals("abc", res[23].exec("abcdefB"), 50);
+assertEquals("defabc,abc,abc,", res[24].exec("defabc"), 51);
+assertEquals("Zdefabc,abc,abc,", res[24].exec("Zdefabc"), 52);
+assertEquals("abc", res[25].exec("abc"), 53);
+assertEquals(null, res[25].exec("*** Failers", 54));
+assertEquals("abc", res[26].exec("abcdef"), 55);
+assertEquals("abc", res[26].exec("abcdefB"), 56);
+assertEquals("defabc,abc,abc,", res[27].exec("defabc"), 57);
+assertEquals("Zdefabc,abc,abc,", res[27].exec("Zdefabc"), 58);
+assertEquals("the quick brown fox", res[28].exec("the quick brown fox"), 59);
+assertEquals(null, res[28].exec("*** Failers", 60));
+assertEquals("The Quick Brown Fox", res[28].exec("The Quick Brown Fox"), 61);
+assertEquals("the quick brown fox", res[29].exec("the quick brown fox"), 62);
+assertEquals("The Quick Brown Fox", res[29].exec("The Quick Brown Fox"), 63);
+assertEquals(null, res[30].exec("*** Failers", 64));
+assertEquals(null, res[30].exec("abc\ndef", 65));
+assertEquals("abc", res[31].exec("abc"), 66);
+assertEquals(null, res[31].exec("abc\n", 67));
+assertEquals("abc,abc", res[33].exec("abc"), 68);
 assertThrows("var re = /)/;", 69);
-assertToStringEquals("-pr", res[35].exec("co-processors, and for"), 70);
-assertToStringEquals("<def>ghi<klm>", res[36].exec("abc<def>ghi<klm>nop"), 71);
-assertToStringEquals("<def>", res[37].exec("abc<def>ghi<klm>nop"), 72);
-assertToStringEquals("<def>", res[37].exec("abc<def>ghi<klm>nop"), 73);
-assertNull(res[37].exec("abc========def", 74));
-assertNull(res[37].exec("foo", 75));
-assertNull(res[37].exec("catfoo", 76));
-assertNull(res[37].exec("*** Failers", 77));
-assertNull(res[37].exec("the barfoo", 78));
-assertNull(res[37].exec("and cattlefoo", 79));
-assertToStringEquals("a", res[40].exec("a"), 80);
-assertNull(res[40].exec("a\n", 81));
-assertNull(res[40].exec("*** Failers", 82));
-assertToStringEquals("a", res[40].exec("Za"), 83);
-assertNull(res[40].exec("Za\n", 84));
-assertToStringEquals("a", res[41].exec("a"), 85);
-assertToStringEquals("a", res[41].exec("a\n"), 86);
-assertToStringEquals("a", res[41].exec("Za\n"), 87);
-assertNull(res[41].exec("*** Failers", 88));
-assertToStringEquals("a", res[41].exec("Za"), 89);
-assertToStringEquals("b", res[44].exec("foo\nbarbar"), 90);
-assertToStringEquals("a", res[44].exec("***Failers"), 91);
-assertToStringEquals("b", res[44].exec("rhubarb"), 92);
-assertToStringEquals("b", res[44].exec("barbell"), 93);
-assertToStringEquals("a", res[44].exec("abc\nbarton"), 94);
-assertToStringEquals("b", res[44].exec("foo\nbarbar"), 95);
-assertToStringEquals("a", res[44].exec("***Failers"), 96);
-assertToStringEquals("b", res[44].exec("rhubarb"), 97);
-assertToStringEquals("b", res[44].exec("barbell"), 98);
-assertToStringEquals("a", res[44].exec("abc\nbarton"), 99);
-assertToStringEquals("a", res[44].exec("abc"), 100);
-assertToStringEquals("a", res[44].exec("def\nabc"), 101);
-assertToStringEquals("a", res[44].exec("*** Failers"), 102);
-assertToStringEquals("a", res[44].exec("defabc"), 103);
-assertNull(res[45].exec("the bullock-cart", 104));
-assertNull(res[45].exec("a donkey-cart race", 105));
-assertNull(res[45].exec("*** Failers", 106));
-assertNull(res[45].exec("cart", 107));
-assertNull(res[45].exec("horse-and-cart", 108));
-assertNull(res[45].exec("alphabetabcd", 109));
-assertNull(res[45].exec("endingxyz", 110));
-assertNull(res[45].exec("abxyZZ", 111));
-assertNull(res[45].exec("abXyZZ", 112));
-assertNull(res[45].exec("ZZZ", 113));
-assertNull(res[45].exec("zZZ", 114));
-assertNull(res[45].exec("bZZ", 115));
-assertNull(res[45].exec("BZZ", 116));
-assertNull(res[45].exec("*** Failers", 117));
-assertNull(res[45].exec("ZZ", 118));
-assertNull(res[45].exec("abXYZZ", 119));
-assertNull(res[45].exec("zzz", 120));
-assertNull(res[45].exec("bzz", 121));
-assertNull(res[45].exec("bar", 122));
-assertNull(res[45].exec("foobbar", 123));
-assertNull(res[45].exec("*** Failers", 124));
-assertNull(res[45].exec("fooabar", 125));
-assertNull(res[46].exec("*** Failers", 126));
-assertNull(res[46].exec("a", 127));
-assertNull(res[48].exec("aaaaaa", 128));
+assertEquals("-pr", res[35].exec("co-processors, and for"), 70);
+assertEquals("<def>ghi<klm>", res[36].exec("abc<def>ghi<klm>nop"), 71);
+assertEquals("<def>", res[37].exec("abc<def>ghi<klm>nop"), 72);
+assertEquals("<def>", res[37].exec("abc<def>ghi<klm>nop"), 73);
+assertEquals(null, res[37].exec("abc========def", 74));
+assertEquals(null, res[37].exec("foo", 75));
+assertEquals(null, res[37].exec("catfoo", 76));
+assertEquals(null, res[37].exec("*** Failers", 77));
+assertEquals(null, res[37].exec("the barfoo", 78));
+assertEquals(null, res[37].exec("and cattlefoo", 79));
+assertEquals("a", res[40].exec("a"), 80);
+assertEquals(null, res[40].exec("a\n", 81));
+assertEquals(null, res[40].exec("*** Failers", 82));
+assertEquals("a", res[40].exec("Za"), 83);
+assertEquals(null, res[40].exec("Za\n", 84));
+assertEquals("a", res[41].exec("a"), 85);
+assertEquals("a", res[41].exec("a\n"), 86);
+assertEquals("a", res[41].exec("Za\n"), 87);
+assertEquals(null, res[41].exec("*** Failers", 88));
+assertEquals("a", res[41].exec("Za"), 89);
+assertEquals("b", res[44].exec("foo\nbarbar"), 90);
+assertEquals("a", res[44].exec("***Failers"), 91);
+assertEquals("b", res[44].exec("rhubarb"), 92);
+assertEquals("b", res[44].exec("barbell"), 93);
+assertEquals("a", res[44].exec("abc\nbarton"), 94);
+assertEquals("b", res[44].exec("foo\nbarbar"), 95);
+assertEquals("a", res[44].exec("***Failers"), 96);
+assertEquals("b", res[44].exec("rhubarb"), 97);
+assertEquals("b", res[44].exec("barbell"), 98);
+assertEquals("a", res[44].exec("abc\nbarton"), 99);
+assertEquals("a", res[44].exec("abc"), 100);
+assertEquals("a", res[44].exec("def\nabc"), 101);
+assertEquals("a", res[44].exec("*** Failers"), 102);
+assertEquals("a", res[44].exec("defabc"), 103);
+assertEquals(null, res[45].exec("the bullock-cart", 104));
+assertEquals(null, res[45].exec("a donkey-cart race", 105));
+assertEquals(null, res[45].exec("*** Failers", 106));
+assertEquals(null, res[45].exec("cart", 107));
+assertEquals(null, res[45].exec("horse-and-cart", 108));
+assertEquals(null, res[45].exec("alphabetabcd", 109));
+assertEquals(null, res[45].exec("endingxyz", 110));
+assertEquals(null, res[45].exec("abxyZZ", 111));
+assertEquals(null, res[45].exec("abXyZZ", 112));
+assertEquals(null, res[45].exec("ZZZ", 113));
+assertEquals(null, res[45].exec("zZZ", 114));
+assertEquals(null, res[45].exec("bZZ", 115));
+assertEquals(null, res[45].exec("BZZ", 116));
+assertEquals(null, res[45].exec("*** Failers", 117));
+assertEquals(null, res[45].exec("ZZ", 118));
+assertEquals(null, res[45].exec("abXYZZ", 119));
+assertEquals(null, res[45].exec("zzz", 120));
+assertEquals(null, res[45].exec("bzz", 121));
+assertEquals(null, res[45].exec("bar", 122));
+assertEquals(null, res[45].exec("foobbar", 123));
+assertEquals(null, res[45].exec("*** Failers", 124));
+assertEquals(null, res[45].exec("fooabar", 125));
+assertEquals(null, res[46].exec("*** Failers", 126));
+assertEquals(null, res[46].exec("a", 127));
+assertEquals(null, res[48].exec("aaaaaa", 128));
 assertThrows("var re = /a[b-a]/;", 129);
 assertThrows("var re = /a[/;", 130);
 assertThrows("var re = /*a/;", 131);
@@ -1794,4810 +1794,4810 @@ assertThrows("var re = /a(?{\"{\"})b/;", 147);
 assertThrows("var re = /a(?{\"{\"}})b/;", 148);
 assertThrows("var re = /[a[:xyz:/;", 149);
 assertThrows("var re = /a{37,17}/;", 150);
-assertToStringEquals("abcd,a,d", res[58].exec("abcd"), 151);
-assertToStringEquals("abcd,a,d", res[58].exec("abcdC2"), 152);
-assertToStringEquals("abcd,a,d", res[58].exec("abcdC5"), 153);
-assertToStringEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyz"), 154);
-assertToStringEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzC1"), 155);
-assertToStringEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzG1"), 156);
-assertToStringEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyz"), 157);
-assertToStringEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyzC1G1"), 158);
-assertToStringEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyz"), 159);
-assertToStringEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyzC1G1L"), 160);
-assertToStringEquals("adef,a,,f", res[62].exec("adefG1G2G3G4L"), 161);
-assertToStringEquals("bcdef,bc,bc,f", res[62].exec("bcdefG1G2G3G4L"), 162);
-assertToStringEquals("adef,a,,f", res[62].exec("adefghijkC0"), 163);
-assertToStringEquals("abc\x00def", res[63].exec("abc\x00defLC0"), 164);
-assertToStringEquals("iss", res[69].exec("Mississippi"), 165);
-assertToStringEquals("iss", res[70].exec("Mississippi"), 166);
-assertToStringEquals("iss", res[71].exec("Mississippi"), 167);
-assertToStringEquals("iss", res[72].exec("Mississippi"), 168);
-assertToStringEquals("iss", res[73].exec("Mississippi"), 169);
-assertNull(res[73].exec("*** Failers", 170));
-assertToStringEquals("iss", res[73].exec("MississippiA"), 171);
-assertToStringEquals("iss", res[73].exec("Mississippi"), 172);
-assertNull(res[73].exec("Mississippi", 173));
-assertToStringEquals("iss", res[74].exec("ississippi"), 174);
-assertToStringEquals("abciss", res[75].exec("abciss\nxyzisspqr"), 175);
-assertToStringEquals("Mis", res[76].exec("Mississippi"), 176);
-assertToStringEquals("sis", res[76].exec("MississippiA"), 177);
-assertToStringEquals("ri ", res[76].exec("Missouri river"), 178);
-assertToStringEquals("riv", res[76].exec("Missouri riverA"), 179);
-assertToStringEquals("Mis", res[77].exec("Mississippi"), 180);
-assertToStringEquals("ab\n", res[78].exec("ab\nab\ncd"), 181);
-assertToStringEquals("ab\n", res[79].exec("ab\nab\ncd"), 182);
-assertToStringEquals("a", res[115].exec("a"), 183);
-assertToStringEquals("b", res[115].exec("b"), 184);
-assertToStringEquals("ab", res[115].exec("ab"), 185);
-assertToStringEquals("", res[115].exec("\\"), 186);
-assertToStringEquals("", res[115].exec("*** Failers"), 187);
-assertToStringEquals("", res[115].exec("N"), 188);
-assertToStringEquals("", res[116].exec("abcd"), 189);
-assertToStringEquals("", res[116].exec("-abc"), 190);
-assertToStringEquals("", res[116].exec("Nab-c"), 191);
-assertToStringEquals("", res[116].exec("*** Failers"), 192);
-assertToStringEquals("", res[116].exec("Nabc"), 193);
-assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzz"), 194);
-assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO0"), 195);
-assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO1"), 196);
-assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO2"), 197);
-assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO3"), 198);
-assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO4"), 199);
-assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO5"), 200);
-assertToStringEquals("(abcd", res[118].exec("(abcd)"), 201);
-assertToStringEquals("(abcd", res[118].exec("(abcd)xyz"), 202);
-assertNull(res[118].exec("xyz(abcd)", 203));
-assertNull(res[118].exec("(ab(xy)cd)pqr", 204));
-assertNull(res[118].exec("(ab(xycd)pqr", 205));
-assertNull(res[118].exec("() abc ()", 206));
-assertNull(res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 207));
-assertNull(res[118].exec("*** Failers", 208));
-assertToStringEquals("abcd", res[118].exec("abcd"), 209);
-assertToStringEquals("abcd", res[118].exec("abcd)"), 210);
-assertToStringEquals("(abcd", res[118].exec("(abcd"), 211);
-assertNull(res[118].exec("(ab(xy)cd)pqr", 212));
-assertNull(res[118].exec("1(abcd)(x(y)z)pqr", 213));
-assertToStringEquals("(abcd", res[118].exec("(abcd)"), 214);
-assertNull(res[118].exec("(ab(xy)cd)", 215));
-assertNull(res[118].exec("(a(b(c)d)e)", 216));
-assertNull(res[118].exec("((ab))", 217));
-assertNull(res[118].exec("*** Failers", 218));
-assertNull(res[118].exec("()", 219));
-assertNull(res[118].exec("()", 220));
-assertNull(res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 221));
-assertNull(res[118].exec("(ab(xy)cd)", 222));
-assertNull(res[118].exec("(ab(xy)cd)", 223));
-assertNull(res[118].exec("(ab(xy)cd)", 224));
-assertNull(res[118].exec("(123ab(xy)cd)", 225));
-assertNull(res[118].exec("(ab(xy)cd)", 226));
-assertNull(res[118].exec("(123ab(xy)cd)", 227));
-assertNull(res[118].exec("(ab(xy)cd)", 228));
-assertToStringEquals("(abcd", res[118].exec("(abcd(xyz<p>qrs)123)"), 229);
-assertNull(res[118].exec("(ab(cd)ef)", 230));
-assertNull(res[118].exec("(ab(cd(ef)gh)ij)", 231));
-assertNull(res[146].exec("A", 232));
-assertNull(res[146].exec("a", 233));
-assertNull(res[147].exec("A", 234));
-assertNull(res[147].exec("a", 235));
-assertNull(res[147].exec("ab", 236));
-assertNull(res[147].exec("aB", 237));
-assertNull(res[147].exec("*** Failers", 238));
-assertNull(res[147].exec("Ab", 239));
-assertNull(res[147].exec("AB", 240));
+assertEquals("abcd,a,d", res[58].exec("abcd"), 151);
+assertEquals("abcd,a,d", res[58].exec("abcdC2"), 152);
+assertEquals("abcd,a,d", res[58].exec("abcdC5"), 153);
+assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyz"), 154);
+assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzC1"), 155);
+assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzG1"), 156);
+assertEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyz"), 157);
+assertEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyzC1G1"), 158);
+assertEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyz"), 159);
+assertEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyzC1G1L"), 160);
+assertEquals("adef,a,,f", res[62].exec("adefG1G2G3G4L"), 161);
+assertEquals("bcdef,bc,bc,f", res[62].exec("bcdefG1G2G3G4L"), 162);
+assertEquals("adef,a,,f", res[62].exec("adefghijkC0"), 163);
+assertEquals("abc\x00def", res[63].exec("abc\x00defLC0"), 164);
+assertEquals("iss", res[69].exec("Mississippi"), 165);
+assertEquals("iss", res[70].exec("Mississippi"), 166);
+assertEquals("iss", res[71].exec("Mississippi"), 167);
+assertEquals("iss", res[72].exec("Mississippi"), 168);
+assertEquals("iss", res[73].exec("Mississippi"), 169);
+assertEquals(null, res[73].exec("*** Failers", 170));
+assertEquals("iss", res[73].exec("MississippiA"), 171);
+assertEquals("iss", res[73].exec("Mississippi"), 172);
+assertEquals(null, res[73].exec("Mississippi", 173));
+assertEquals("iss", res[74].exec("ississippi"), 174);
+assertEquals("abciss", res[75].exec("abciss\nxyzisspqr"), 175);
+assertEquals("Mis", res[76].exec("Mississippi"), 176);
+assertEquals("sis", res[76].exec("MississippiA"), 177);
+assertEquals("ri ", res[76].exec("Missouri river"), 178);
+assertEquals("riv", res[76].exec("Missouri riverA"), 179);
+assertEquals("Mis", res[77].exec("Mississippi"), 180);
+assertEquals("ab\n", res[78].exec("ab\nab\ncd"), 181);
+assertEquals("ab\n", res[79].exec("ab\nab\ncd"), 182);
+assertEquals("a", res[115].exec("a"), 183);
+assertEquals("b", res[115].exec("b"), 184);
+assertEquals("ab", res[115].exec("ab"), 185);
+assertEquals("", res[115].exec("\\"), 186);
+assertEquals("", res[115].exec("*** Failers"), 187);
+assertEquals("", res[115].exec("N"), 188);
+assertEquals("", res[116].exec("abcd"), 189);
+assertEquals("", res[116].exec("-abc"), 190);
+assertEquals("", res[116].exec("Nab-c"), 191);
+assertEquals("", res[116].exec("*** Failers"), 192);
+assertEquals("", res[116].exec("Nabc"), 193);
+assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzz"), 194);
+assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO0"), 195);
+assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO1"), 196);
+assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO2"), 197);
+assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO3"), 198);
+assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO4"), 199);
+assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO5"), 200);
+assertEquals("(abcd", res[118].exec("(abcd)"), 201);
+assertEquals("(abcd", res[118].exec("(abcd)xyz"), 202);
+assertEquals(null, res[118].exec("xyz(abcd)", 203));
+assertEquals(null, res[118].exec("(ab(xy)cd)pqr", 204));
+assertEquals(null, res[118].exec("(ab(xycd)pqr", 205));
+assertEquals(null, res[118].exec("() abc ()", 206));
+assertEquals(null, res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 207));
+assertEquals(null, res[118].exec("*** Failers", 208));
+assertEquals("abcd", res[118].exec("abcd"), 209);
+assertEquals("abcd", res[118].exec("abcd)"), 210);
+assertEquals("(abcd", res[118].exec("(abcd"), 211);
+assertEquals(null, res[118].exec("(ab(xy)cd)pqr", 212));
+assertEquals(null, res[118].exec("1(abcd)(x(y)z)pqr", 213));
+assertEquals("(abcd", res[118].exec("(abcd)"), 214);
+assertEquals(null, res[118].exec("(ab(xy)cd)", 215));
+assertEquals(null, res[118].exec("(a(b(c)d)e)", 216));
+assertEquals(null, res[118].exec("((ab))", 217));
+assertEquals(null, res[118].exec("*** Failers", 218));
+assertEquals(null, res[118].exec("()", 219));
+assertEquals(null, res[118].exec("()", 220));
+assertEquals(null, res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 221));
+assertEquals(null, res[118].exec("(ab(xy)cd)", 222));
+assertEquals(null, res[118].exec("(ab(xy)cd)", 223));
+assertEquals(null, res[118].exec("(ab(xy)cd)", 224));
+assertEquals(null, res[118].exec("(123ab(xy)cd)", 225));
+assertEquals(null, res[118].exec("(ab(xy)cd)", 226));
+assertEquals(null, res[118].exec("(123ab(xy)cd)", 227));
+assertEquals(null, res[118].exec("(ab(xy)cd)", 228));
+assertEquals("(abcd", res[118].exec("(abcd(xyz<p>qrs)123)"), 229);
+assertEquals(null, res[118].exec("(ab(cd)ef)", 230));
+assertEquals(null, res[118].exec("(ab(cd(ef)gh)ij)", 231));
+assertEquals(null, res[146].exec("A", 232));
+assertEquals(null, res[146].exec("a", 233));
+assertEquals(null, res[147].exec("A", 234));
+assertEquals(null, res[147].exec("a", 235));
+assertEquals(null, res[147].exec("ab", 236));
+assertEquals(null, res[147].exec("aB", 237));
+assertEquals(null, res[147].exec("*** Failers", 238));
+assertEquals(null, res[147].exec("Ab", 239));
+assertEquals(null, res[147].exec("AB", 240));
 assertThrows("var re = /[\\200-\\110]/;", 241);
-assertToStringEquals("1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 ,32 ,33 ,34 ,35 ,36 ,37 ,38 ,39 ,40 ,41 ,42 ,43 ,44 ,45 ,46 ,47 ,48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 ,58 ,59 ,60 ,61 ,62 ,63 ,64 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 ,73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 ,83 ,84 ,85 ,86 ,87 ,88 ,89 ,90 ,91 ,92 ,93 ,94 ,95 ,96 ,97 ,98 ,99 ,100 ,101 ,102 ,103 ,104 ,105 ,106 ,107 ,108 ,109 ,110 ,111 ,112 ,113 ,114 ,115 ,116 ,117 ,118 ,119 ,120 ,121 ,122 ,123 ,124 ,125 ,126 ,127 ,128 ,129 ,130 ,131 ,132 ,133 ,134 ,135 ,136 ,137 ,138 ,139 ,140 ,141 ,142 ,143 ,144 ,145 ,146 ,147 ,148 ,149 ,150 ,151 ,152 ,153 ,154 ,155 ,156 ,157 ,158 ,159 ,160 ,161 ,162 ,163 ,164 ,165 ,166 ,167 ,168 ,169 ,170 ,171 ,172 ,173 ,174 ,175 ,176 ,177 ,178 ,179 ,180 ,181 ,182 ,183 ,184 ,185 ,186 ,187 ,188 ,189 ,190 ,191 ,192 ,193 ,194 ,195 ,196 ,197 ,198 ,199 ,200 ,201 ,202 ,203 ,204 ,205 ,206 ,207 ,208 ,209 ,210 ,211 ,212 ,213 ,214 ,215 ,216 ,217 ,218 ,219 ,220 ,221 ,222 ,223 ,224 ,225 ,226 ,227 ,228 ,229 ,230 ,231 ,232 ,233 ,234 ,235 ,236 ,237 ,238 ,239 ,240 ,241 ,242 ,243 ,244 ,245 ,246 ,247 ,248 ,249 ,250 ,251 ,252 ,253 ,254 ,255 ,256 ,257 ,258 ,259 ,260 ,261 ,262 ,263 ,264 ,265 ,266 ,267 ,268 ,269 ,ABC,ABC", res[149].exec("O900 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC"), 242);
-assertToStringEquals("mainmain,main,", res[151].exec("mainmain"), 243);
-assertToStringEquals("mainOmain,main,", res[151].exec("mainOmain"), 244);
-assertToStringEquals("aba,a,", res[153].exec("aba"), 245);
-assertToStringEquals("aabbaa,aa,", res[154].exec("aabbaa"), 246);
-assertToStringEquals("aabbaa,aa,", res[155].exec("aabbaa"), 247);
-assertToStringEquals("aabbaa,aa,", res[156].exec("aabbaa"), 248);
-assertToStringEquals("aabbaa,", res[157].exec("aabbaa"), 249);
-assertToStringEquals("aabbaa,aa,,", res[158].exec("aabbaa"), 250);
-assertToStringEquals("aabbaa,,", res[159].exec("aabbaa"), 251);
-assertToStringEquals("aabbaa,", res[160].exec("aabbaa"), 252);
-assertToStringEquals("aabbbaa,", res[161].exec("aabbbaa"), 253);
-assertToStringEquals("aabbbaa,", res[162].exec("aabbbaa"), 254);
-assertToStringEquals("aabbaa,", res[163].exec("aabbaa"), 255);
-assertToStringEquals("aabbbaa,", res[164].exec("aabbbaa"), 256);
-assertToStringEquals("aabbbaa,aa,,", res[165].exec("aabbbaa"), 257);
-assertToStringEquals("aabbbbaa,aa,,", res[166].exec("aabbbbaa"), 258);
+assertEquals("1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 ,32 ,33 ,34 ,35 ,36 ,37 ,38 ,39 ,40 ,41 ,42 ,43 ,44 ,45 ,46 ,47 ,48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 ,58 ,59 ,60 ,61 ,62 ,63 ,64 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 ,73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 ,83 ,84 ,85 ,86 ,87 ,88 ,89 ,90 ,91 ,92 ,93 ,94 ,95 ,96 ,97 ,98 ,99 ,100 ,101 ,102 ,103 ,104 ,105 ,106 ,107 ,108 ,109 ,110 ,111 ,112 ,113 ,114 ,115 ,116 ,117 ,118 ,119 ,120 ,121 ,122 ,123 ,124 ,125 ,126 ,127 ,128 ,129 ,130 ,131 ,132 ,133 ,134 ,135 ,136 ,137 ,138 ,139 ,140 ,141 ,142 ,143 ,144 ,145 ,146 ,147 ,148 ,149 ,150 ,151 ,152 ,153 ,154 ,155 ,156 ,157 ,158 ,159 ,160 ,161 ,162 ,163 ,164 ,165 ,166 ,167 ,168 ,169 ,170 ,171 ,172 ,173 ,174 ,175 ,176 ,177 ,178 ,179 ,180 ,181 ,182 ,183 ,184 ,185 ,186 ,187 ,188 ,189 ,190 ,191 ,192 ,193 ,194 ,195 ,196 ,197 ,198 ,199 ,200 ,201 ,202 ,203 ,204 ,205 ,206 ,207 ,208 ,209 ,210 ,211 ,212 ,213 ,214 ,215 ,216 ,217 ,218 ,219 ,220 ,221 ,222 ,223 ,224 ,225 ,226 ,227 ,228 ,229 ,230 ,231 ,232 ,233 ,234 ,235 ,236 ,237 ,238 ,239 ,240 ,241 ,242 ,243 ,244 ,245 ,246 ,247 ,248 ,249 ,250 ,251 ,252 ,253 ,254 ,255 ,256 ,257 ,258 ,259 ,260 ,261 ,262 ,263 ,264 ,265 ,266 ,267 ,268 ,269 ,ABC,ABC", res[149].exec("O900 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC"), 242);
+assertEquals("mainmain,main,", res[151].exec("mainmain"), 243);
+assertEquals("mainOmain,main,", res[151].exec("mainOmain"), 244);
+assertEquals("aba,a,", res[153].exec("aba"), 245);
+assertEquals("aabbaa,aa,", res[154].exec("aabbaa"), 246);
+assertEquals("aabbaa,aa,", res[155].exec("aabbaa"), 247);
+assertEquals("aabbaa,aa,", res[156].exec("aabbaa"), 248);
+assertEquals("aabbaa,", res[157].exec("aabbaa"), 249);
+assertEquals("aabbaa,aa,,", res[158].exec("aabbaa"), 250);
+assertEquals("aabbaa,,", res[159].exec("aabbaa"), 251);
+assertEquals("aabbaa,", res[160].exec("aabbaa"), 252);
+assertEquals("aabbbaa,", res[161].exec("aabbbaa"), 253);
+assertEquals("aabbbaa,", res[162].exec("aabbbaa"), 254);
+assertEquals("aabbaa,", res[163].exec("aabbaa"), 255);
+assertEquals("aabbbaa,", res[164].exec("aabbbaa"), 256);
+assertEquals("aabbbaa,aa,,", res[165].exec("aabbbaa"), 257);
+assertEquals("aabbbbaa,aa,,", res[166].exec("aabbbbaa"), 258);
 assertThrows("var re = //;", 259);
-assertToStringEquals("a", res[169].exec("ab"), 260);
-assertToStringEquals("a", res[169].exec("aB"), 261);
-assertToStringEquals("*", res[169].exec("*** Failers"), 262);
-assertToStringEquals("A", res[169].exec("AB"), 263);
-assertToStringEquals("a", res[169].exec("ab"), 264);
-assertToStringEquals("a", res[169].exec("aB"), 265);
-assertToStringEquals("*", res[169].exec("*** Failers"), 266);
-assertToStringEquals("A", res[169].exec("AB"), 267);
-assertNull(res[172].exec("\\", 268));
-assertNull(res[177].exec("*** Failers", 269));
-assertNull(res[177].exec("xxxxx", 270));
-assertNull(res[177].exec("now is the time for all good men to come to the aid of the party", 271));
-assertNull(res[177].exec("*** Failers", 272));
-assertNull(res[177].exec("this is not a line with only words and spaces!", 273));
-assertNull(res[177].exec("12345a", 274));
-assertNull(res[177].exec("*** Failers", 275));
-assertNull(res[177].exec("12345+", 276));
-assertNull(res[177].exec("aaab", 277));
-assertNull(res[177].exec("aaab", 278));
-assertNull(res[177].exec("aaab", 279));
-assertNull(res[177].exec("((abc(ade)ufh()()x", 280));
-assertNull(res[177].exec("(abc)", 281));
-assertNull(res[177].exec("(abc(def)xyz)", 282));
-assertNull(res[177].exec("*** Failers", 283));
-assertNull(res[177].exec("((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 284));
-assertNull(res[177].exec("xaaaab", 285));
-assertNull(res[177].exec("xaaaab", 286));
+assertEquals("a", res[169].exec("ab"), 260);
+assertEquals("a", res[169].exec("aB"), 261);
+assertEquals("*", res[169].exec("*** Failers"), 262);
+assertEquals("A", res[169].exec("AB"), 263);
+assertEquals("a", res[169].exec("ab"), 264);
+assertEquals("a", res[169].exec("aB"), 265);
+assertEquals("*", res[169].exec("*** Failers"), 266);
+assertEquals("A", res[169].exec("AB"), 267);
+assertEquals(null, res[172].exec("\\", 268));
+assertEquals(null, res[177].exec("*** Failers", 269));
+assertEquals(null, res[177].exec("xxxxx", 270));
+assertEquals(null, res[177].exec("now is the time for all good men to come to the aid of the party", 271));
+assertEquals(null, res[177].exec("*** Failers", 272));
+assertEquals(null, res[177].exec("this is not a line with only words and spaces!", 273));
+assertEquals(null, res[177].exec("12345a", 274));
+assertEquals(null, res[177].exec("*** Failers", 275));
+assertEquals(null, res[177].exec("12345+", 276));
+assertEquals(null, res[177].exec("aaab", 277));
+assertEquals(null, res[177].exec("aaab", 278));
+assertEquals(null, res[177].exec("aaab", 279));
+assertEquals(null, res[177].exec("((abc(ade)ufh()()x", 280));
+assertEquals(null, res[177].exec("(abc)", 281));
+assertEquals(null, res[177].exec("(abc(def)xyz)", 282));
+assertEquals(null, res[177].exec("*** Failers", 283));
+assertEquals(null, res[177].exec("((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 284));
+assertEquals(null, res[177].exec("xaaaab", 285));
+assertEquals(null, res[177].exec("xaaaab", 286));
 assertThrows("var re = /[/;", 287);
 assertThrows("var re = /[a-/;", 288);
-assertNull(res[189].exec("<>", 289));
-assertNull(res[189].exec("<abcd>", 290));
-assertNull(res[189].exec("<abc <123> hij>", 291));
-assertNull(res[189].exec("<abc <def> hij>", 292));
-assertNull(res[189].exec("<abc<>def>", 293));
-assertNull(res[189].exec("<abc<>", 294));
-assertNull(res[189].exec("*** Failers", 295));
-assertNull(res[189].exec("<abc", 296));
-assertToStringEquals("bc123bc,bc,bc", res[195].exec("abc123bc"), 297);
-assertToStringEquals("abc", res[215].exec("abcdef"), 298);
-assertToStringEquals("abc", res[215].exec("1234abcdef"), 299);
-assertNull(res[215].exec("*** Failers", 300));
-assertToStringEquals("abc", res[215].exec("abcxyz"), 301);
-assertToStringEquals("abc", res[215].exec("abcxyzf"), 302);
-assertToStringEquals("abc", res[215].exec("123abcdef"), 303);
-assertToStringEquals("abc", res[215].exec("1234abcdef"), 304);
-assertNull(res[215].exec("*** Failers", 305));
-assertToStringEquals("abc", res[215].exec("abcdef"), 306);
-assertNull(res[215].exec("*** Failers", 307));
-assertToStringEquals("abc", res[215].exec("\x83x0abcdef"), 308);
-assertToStringEquals("abc", res[215].exec("123abcdef"), 309);
-assertToStringEquals("abc", res[215].exec("123abcdefC+"), 310);
-assertToStringEquals("abc", res[215].exec("123abcdefC-"), 311);
-assertNull(res[215].exec("*** Failers", 312));
-assertToStringEquals("abc", res[215].exec("123abcdefC!1"), 313);
-assertToStringEquals("abc", res[215].exec("abcabcabc"), 314);
-assertToStringEquals("abc", res[215].exec("abcabcC!1!3"), 315);
-assertNull(res[215].exec("*** Failers", 316));
-assertToStringEquals("abc", res[215].exec("abcabcabcC!1!3"), 317);
-assertToStringEquals("C", res[215].exec("123C+"), 318);
-assertToStringEquals("C", res[215].exec("123456C+"), 319);
-assertToStringEquals("C", res[215].exec("123456789C+"), 320);
-assertToStringEquals("abc", res[215].exec("xyzabcC+"), 321);
-assertToStringEquals("abc", res[215].exec("XxyzabcC+"), 322);
-assertToStringEquals("abc", res[215].exec("abcdefC+"), 323);
-assertToStringEquals("abc", res[215].exec("abcxyzC+"), 324);
-assertToStringEquals("c", res[215].exec("abbbbbcccC*1"), 325);
-assertToStringEquals("c", res[215].exec("abbbbbcccC*1"), 326);
-assertNull(res[215].exec("xab", 327));
-assertToStringEquals("c", res[215].exec("xbc"), 328);
-assertNull(res[215].exec("xde", 329));
-assertNull(res[215].exec("xxab", 330));
-assertNull(res[215].exec("xxxab", 331));
-assertNull(res[215].exec("*** Failers", 332));
-assertNull(res[215].exec("xyab", 333));
-assertToStringEquals("abc", res[215].exec("abc"), 334);
-assertToStringEquals("c", res[215].exec("a(b)c"), 335);
-assertToStringEquals("c", res[215].exec("a(b(c))d"), 336);
-assertNull(res[215].exec("*** Failers)", 337));
-assertToStringEquals("c", res[215].exec("a(b(c)d"), 338);
-assertNull(res[215].exec("1221", 339));
-assertToStringEquals("c", res[215].exec("Satan, oscillate my metallic sonatas!"), 340);
-assertToStringEquals("c", res[215].exec("A man, a plan, a canal: Panama!"), 341);
-assertNull(res[215].exec("Able was I ere I saw Elba.", 342));
-assertNull(res[215].exec("*** Failers", 343));
-assertToStringEquals("c", res[215].exec("The quick brown fox"), 344);
-assertNull(res[215].exec("12", 345));
-assertNull(res[215].exec("(((2+2)*-3)-7)", 346));
-assertNull(res[215].exec("-12", 347));
-assertNull(res[215].exec("*** Failers", 348));
-assertNull(res[215].exec("((2+2)*-3)-7)", 349));
-assertNull(res[215].exec("xyz", 350));
-assertNull(res[215].exec("xxyzxyzz", 351));
-assertNull(res[215].exec("*** Failers", 352));
-assertNull(res[215].exec("xxyzz", 353));
-assertNull(res[215].exec("xxyzxyzxyzz", 354));
-assertNull(res[215].exec("<>", 355));
-assertToStringEquals("abc", res[215].exec("<abcd>"), 356);
-assertToStringEquals("abc", res[215].exec("<abc <123> hij>"), 357);
-assertToStringEquals("abc", res[215].exec("<abc <def> hij>"), 358);
-assertToStringEquals("abc", res[215].exec("<abc<>def>"), 359);
-assertToStringEquals("abc", res[215].exec("<abc<>"), 360);
-assertNull(res[215].exec("*** Failers", 361));
-assertToStringEquals("abc", res[215].exec("<abc"), 362);
-assertToStringEquals("abc", res[215].exec("abcdefabc"), 363);
-assertNull(res[215].exec("a=a", 364));
-assertNull(res[215].exec("a=b", 365));
-assertToStringEquals("c", res[215].exec("a=bc"), 366);
-assertNull(res[215].exec("a=a", 367));
-assertNull(res[215].exec("a=b", 368));
-assertToStringEquals("c", res[215].exec("a=bc"), 369);
-assertNull(res[215].exec("abde", 370));
-assertToStringEquals("c", res[215].exec("acde"), 371);
-assertNull(res[215].exec("1221", 372));
-assertToStringEquals("c", res[215].exec("Satan, oscillate my metallic sonatas!"), 373);
-assertToStringEquals("c", res[215].exec("A man, a plan, a canal: Panama!"), 374);
-assertNull(res[215].exec("Able was I ere I saw Elba.", 375));
-assertNull(res[215].exec("*** Failers", 376));
-assertToStringEquals("c", res[215].exec("The quick brown fox"), 377);
-assertNull(res[228].exec("abcdefgh", 378));
-assertNull(res[228].exec("abcdefghC1Gtwo", 379));
-assertNull(res[228].exec("abcdefghConeCtwo", 380));
-assertNull(res[228].exec("abcdefghCthree", 381));
-assertToStringEquals("zz,", res[228].exec("zzaaCZ"), 382);
-assertToStringEquals("zz,", res[228].exec("zzaaCA"), 383);
-assertNull(res[228].exec("[10,20,30,5,5,4,4,2,43,23,4234]", 384));
-assertNull(res[228].exec("*** Failers", 385));
-assertNull(res[228].exec("[]", 386));
-assertNull(res[228].exec("[10,20,30,5,5,4,4,2,43,23,4234]", 387));
-assertNull(res[228].exec("[]", 388));
-assertToStringEquals(" Baby Bjorn Active Carrier - With free SHIPPING!!, Baby Bjorn Active Carrier - With free SHIPPING!!,,", res[229].exec(" Baby Bjorn Active Carrier - With free SHIPPING!!"), 389);
-assertToStringEquals(" Baby Bjorn Active Carrier - With free SHIPPING!!, Baby Bjorn Active Carrier - With free SHIPPING!!,,", res[230].exec(" Baby Bjorn Active Carrier - With free SHIPPING!!"), 390);
-assertNull(res[238].exec("Note: that { does NOT introduce a quantifier", 391));
-assertToStringEquals("aacaacaacaacaac123,aac", res[239].exec("aacaacaacaacaac123"), 392);
-assertNull(res[243].exec("abP", 393));
-assertNull(res[243].exec("abcP", 394));
-assertNull(res[243].exec("abcdP", 395));
-assertToStringEquals("abcde", res[243].exec("abcdeP"), 396);
-assertNull(res[243].exec("the quick brown abcP", 397));
-assertNull(res[243].exec("** FailersP", 398));
-assertNull(res[243].exec("the quick brown abxyz foxP", 399));
-assertNull(res[243].exec("13/05/04P", 400));
-assertNull(res[243].exec("13/5/2004P", 401));
-assertNull(res[243].exec("02/05/09P", 402));
-assertNull(res[243].exec("1P", 403));
-assertNull(res[243].exec("1/2P", 404));
-assertNull(res[243].exec("1/2/0P", 405));
-assertNull(res[243].exec("1/2/04P", 406));
-assertNull(res[243].exec("0P", 407));
-assertNull(res[243].exec("02/P", 408));
-assertNull(res[243].exec("02/0P", 409));
-assertNull(res[243].exec("02/1P", 410));
-assertNull(res[243].exec("** FailersP", 411));
-assertNull(res[243].exec("P", 412));
-assertNull(res[243].exec("123P", 413));
-assertNull(res[243].exec("33/4/04P", 414));
-assertNull(res[243].exec("3/13/04P", 415));
-assertNull(res[243].exec("0/1/2003P", 416));
-assertNull(res[243].exec("0/P", 417));
-assertNull(res[243].exec("02/0/P", 418));
-assertNull(res[243].exec("02/13P", 419));
-assertToStringEquals("123", res[248].exec("123P"), 420);
-assertNull(res[248].exec("aP", 421));
-assertNull(res[248].exec("bP", 422));
-assertNull(res[248].exec("cP", 423));
-assertNull(res[248].exec("c12P", 424));
-assertToStringEquals("c123", res[248].exec("c123P"), 425);
-assertNull(res[249].exec("1P", 426));
-assertNull(res[249].exec("123P", 427));
-assertToStringEquals("123X", res[249].exec("123X"), 428);
-assertNull(res[249].exec("1234P", 429));
-assertToStringEquals("1234X", res[249].exec("1234X"), 430);
-assertNull(res[249].exec("12345P", 431));
-assertToStringEquals("12345X", res[249].exec("12345X"), 432);
-assertNull(res[249].exec("*** Failers", 433));
-assertNull(res[249].exec("1X", 434));
-assertNull(res[249].exec("123456P", 435));
-assertNull(res[249].exec("abc", 436));
-assertNull(res[249].exec("** Failers", 437));
-assertNull(res[249].exec("bca", 438));
-assertNull(res[249].exec("abc", 439));
-assertNull(res[249].exec("** Failers", 440));
-assertNull(res[249].exec("bca", 441));
-assertNull(res[249].exec("abc", 442));
-assertNull(res[249].exec("** Failers", 443));
-assertNull(res[249].exec("def", 444));
-assertNull(res[249].exec("abc", 445));
-assertNull(res[249].exec("** Failers", 446));
-assertNull(res[249].exec("def", 447));
-assertNull(res[249].exec("<!DOCTYPE seite SYSTEM \"http://www.lco.lineas.de/xmlCms.dtd\">\n<seite>\n<dokumenteninformation>\n<seitentitel>Partner der LCO</seitentitel>\n<sprache>de</sprache>\n<seitenbeschreibung>Partner der LINEAS Consulting\nGmbH</seitenbeschreibung>\n<schluesselworte>LINEAS Consulting GmbH Hamburg\nPartnerfirmen</schluesselworte>\n<revisit>30 days</revisit>\n<robots>index,follow</robots>\n<menueinformation>\n<aktiv>ja</aktiv>\n<menueposition>3</menueposition>\n<menuetext>Partner</menuetext>\n</menueinformation>\n<lastedited>\n<autor>LCO</autor>\n<firma>LINEAS Consulting</firma>\n<datum>15.10.2003</datum>\n</lastedited>\n</dokumenteninformation>\n<inhalt>\n\n<absatzueberschrift>Die Partnerfirmen der LINEAS Consulting\nGmbH</absatzueberschrift>\n\n<absatz><link ziel=\"http://www.ca.com/\" zielfenster=\"_blank\">\n<bild name=\"logo_ca.gif\" rahmen=\"no\"/></link> <link\nziel=\"http://www.ey.com/\" zielfenster=\"_blank\"><bild\nname=\"logo_euy.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><link ziel=\"http://www.cisco.de/\" zielfenster=\"_blank\">\n<bild name=\"logo_cisco.gif\" rahmen=\"ja\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.atelion.de/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_atelion.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><link ziel=\"http://www.line-information.de/\"\nzielfenster=\"_blank\">\n<bild name=\"logo_line_information.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><bild name=\"logo_aw.gif\" rahmen=\"no\"/></absatz>\n\n<absatz><link ziel=\"http://www.incognis.de/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_incognis.gif\" rahmen=\"no\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.addcraft.com/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_addcraft.gif\" rahmen=\"no\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.comendo.com/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_comendo.gif\" rahmen=\"no\"/></link></absatz>\n\n</inhalt>\n</seite>", 448));
-assertToStringEquals("line\nbreak", res[251].exec("this is a line\nbreak"), 449);
-assertToStringEquals("line\nbreak", res[251].exec("line one\nthis is a line\nbreak in the second line"), 450);
-assertToStringEquals("line\nbreak", res[252].exec("this is a line\nbreak"), 451);
-assertNull(res[252].exec("** Failers", 452));
-assertToStringEquals("line\nbreak", res[252].exec("line one\nthis is a line\nbreak in the second line"), 453);
-assertToStringEquals("line\nbreak", res[253].exec("this is a line\nbreak"), 454);
-assertNull(res[253].exec("** Failers", 455));
-assertToStringEquals("line\nbreak", res[253].exec("line one\nthis is a line\nbreak in the second line"), 456);
-assertToStringEquals("ab-cd", res[254].exec("ab-cd"), 457);
-assertToStringEquals("ab=cd", res[254].exec("ab=cd"), 458);
-assertNull(res[254].exec("** Failers", 459));
-assertNull(res[254].exec("ab\ncd", 460));
-assertToStringEquals("ab-cd", res[255].exec("ab-cd"), 461);
-assertToStringEquals("ab=cd", res[255].exec("ab=cd"), 462);
-assertNull(res[255].exec("ab\ncd", 463));
-assertNull(res[255].exec("AbCd", 464));
-assertNull(res[255].exec("** Failers", 465));
-assertNull(res[255].exec("abcd", 466));
+assertEquals(null, res[189].exec("<>", 289));
+assertEquals(null, res[189].exec("<abcd>", 290));
+assertEquals(null, res[189].exec("<abc <123> hij>", 291));
+assertEquals(null, res[189].exec("<abc <def> hij>", 292));
+assertEquals(null, res[189].exec("<abc<>def>", 293));
+assertEquals(null, res[189].exec("<abc<>", 294));
+assertEquals(null, res[189].exec("*** Failers", 295));
+assertEquals(null, res[189].exec("<abc", 296));
+assertEquals("bc123bc,bc,bc", res[195].exec("abc123bc"), 297);
+assertEquals("abc", res[215].exec("abcdef"), 298);
+assertEquals("abc", res[215].exec("1234abcdef"), 299);
+assertEquals(null, res[215].exec("*** Failers", 300));
+assertEquals("abc", res[215].exec("abcxyz"), 301);
+assertEquals("abc", res[215].exec("abcxyzf"), 302);
+assertEquals("abc", res[215].exec("123abcdef"), 303);
+assertEquals("abc", res[215].exec("1234abcdef"), 304);
+assertEquals(null, res[215].exec("*** Failers", 305));
+assertEquals("abc", res[215].exec("abcdef"), 306);
+assertEquals(null, res[215].exec("*** Failers", 307));
+assertEquals("abc", res[215].exec("\x83x0abcdef"), 308);
+assertEquals("abc", res[215].exec("123abcdef"), 309);
+assertEquals("abc", res[215].exec("123abcdefC+"), 310);
+assertEquals("abc", res[215].exec("123abcdefC-"), 311);
+assertEquals(null, res[215].exec("*** Failers", 312));
+assertEquals("abc", res[215].exec("123abcdefC!1"), 313);
+assertEquals("abc", res[215].exec("abcabcabc"), 314);
+assertEquals("abc", res[215].exec("abcabcC!1!3"), 315);
+assertEquals(null, res[215].exec("*** Failers", 316));
+assertEquals("abc", res[215].exec("abcabcabcC!1!3"), 317);
+assertEquals("C", res[215].exec("123C+"), 318);
+assertEquals("C", res[215].exec("123456C+"), 319);
+assertEquals("C", res[215].exec("123456789C+"), 320);
+assertEquals("abc", res[215].exec("xyzabcC+"), 321);
+assertEquals("abc", res[215].exec("XxyzabcC+"), 322);
+assertEquals("abc", res[215].exec("abcdefC+"), 323);
+assertEquals("abc", res[215].exec("abcxyzC+"), 324);
+assertEquals("c", res[215].exec("abbbbbcccC*1"), 325);
+assertEquals("c", res[215].exec("abbbbbcccC*1"), 326);
+assertEquals(null, res[215].exec("xab", 327));
+assertEquals("c", res[215].exec("xbc"), 328);
+assertEquals(null, res[215].exec("xde", 329));
+assertEquals(null, res[215].exec("xxab", 330));
+assertEquals(null, res[215].exec("xxxab", 331));
+assertEquals(null, res[215].exec("*** Failers", 332));
+assertEquals(null, res[215].exec("xyab", 333));
+assertEquals("abc", res[215].exec("abc"), 334);
+assertEquals("c", res[215].exec("a(b)c"), 335);
+assertEquals("c", res[215].exec("a(b(c))d"), 336);
+assertEquals(null, res[215].exec("*** Failers)", 337));
+assertEquals("c", res[215].exec("a(b(c)d"), 338);
+assertEquals(null, res[215].exec("1221", 339));
+assertEquals("c", res[215].exec("Satan, oscillate my metallic sonatas!"), 340);
+assertEquals("c", res[215].exec("A man, a plan, a canal: Panama!"), 341);
+assertEquals(null, res[215].exec("Able was I ere I saw Elba.", 342));
+assertEquals(null, res[215].exec("*** Failers", 343));
+assertEquals("c", res[215].exec("The quick brown fox"), 344);
+assertEquals(null, res[215].exec("12", 345));
+assertEquals(null, res[215].exec("(((2+2)*-3)-7)", 346));
+assertEquals(null, res[215].exec("-12", 347));
+assertEquals(null, res[215].exec("*** Failers", 348));
+assertEquals(null, res[215].exec("((2+2)*-3)-7)", 349));
+assertEquals(null, res[215].exec("xyz", 350));
+assertEquals(null, res[215].exec("xxyzxyzz", 351));
+assertEquals(null, res[215].exec("*** Failers", 352));
+assertEquals(null, res[215].exec("xxyzz", 353));
+assertEquals(null, res[215].exec("xxyzxyzxyzz", 354));
+assertEquals(null, res[215].exec("<>", 355));
+assertEquals("abc", res[215].exec("<abcd>"), 356);
+assertEquals("abc", res[215].exec("<abc <123> hij>"), 357);
+assertEquals("abc", res[215].exec("<abc <def> hij>"), 358);
+assertEquals("abc", res[215].exec("<abc<>def>"), 359);
+assertEquals("abc", res[215].exec("<abc<>"), 360);
+assertEquals(null, res[215].exec("*** Failers", 361));
+assertEquals("abc", res[215].exec("<abc"), 362);
+assertEquals("abc", res[215].exec("abcdefabc"), 363);
+assertEquals(null, res[215].exec("a=a", 364));
+assertEquals(null, res[215].exec("a=b", 365));
+assertEquals("c", res[215].exec("a=bc"), 366);
+assertEquals(null, res[215].exec("a=a", 367));
+assertEquals(null, res[215].exec("a=b", 368));
+assertEquals("c", res[215].exec("a=bc"), 369);
+assertEquals(null, res[215].exec("abde", 370));
+assertEquals("c", res[215].exec("acde"), 371);
+assertEquals(null, res[215].exec("1221", 372));
+assertEquals("c", res[215].exec("Satan, oscillate my metallic sonatas!"), 373);
+assertEquals("c", res[215].exec("A man, a plan, a canal: Panama!"), 374);
+assertEquals(null, res[215].exec("Able was I ere I saw Elba.", 375));
+assertEquals(null, res[215].exec("*** Failers", 376));
+assertEquals("c", res[215].exec("The quick brown fox"), 377);
+assertEquals(null, res[228].exec("abcdefgh", 378));
+assertEquals(null, res[228].exec("abcdefghC1Gtwo", 379));
+assertEquals(null, res[228].exec("abcdefghConeCtwo", 380));
+assertEquals(null, res[228].exec("abcdefghCthree", 381));
+assertEquals("zz,", res[228].exec("zzaaCZ"), 382);
+assertEquals("zz,", res[228].exec("zzaaCA"), 383);
+assertEquals(null, res[228].exec("[10,20,30,5,5,4,4,2,43,23,4234]", 384));
+assertEquals(null, res[228].exec("*** Failers", 385));
+assertEquals(null, res[228].exec("[]", 386));
+assertEquals(null, res[228].exec("[10,20,30,5,5,4,4,2,43,23,4234]", 387));
+assertEquals(null, res[228].exec("[]", 388));
+assertEquals(" Baby Bjorn Active Carrier - With free SHIPPING!!, Baby Bjorn Active Carrier - With free SHIPPING!!,,", res[229].exec(" Baby Bjorn Active Carrier - With free SHIPPING!!"), 389);
+assertEquals(" Baby Bjorn Active Carrier - With free SHIPPING!!, Baby Bjorn Active Carrier - With free SHIPPING!!,,", res[230].exec(" Baby Bjorn Active Carrier - With free SHIPPING!!"), 390);
+assertEquals(null, res[238].exec("Note: that { does NOT introduce a quantifier", 391));
+assertEquals("aacaacaacaacaac123,aac", res[239].exec("aacaacaacaacaac123"), 392);
+assertEquals(null, res[243].exec("abP", 393));
+assertEquals(null, res[243].exec("abcP", 394));
+assertEquals(null, res[243].exec("abcdP", 395));
+assertEquals("abcde", res[243].exec("abcdeP"), 396);
+assertEquals(null, res[243].exec("the quick brown abcP", 397));
+assertEquals(null, res[243].exec("** FailersP", 398));
+assertEquals(null, res[243].exec("the quick brown abxyz foxP", 399));
+assertEquals(null, res[243].exec("13/05/04P", 400));
+assertEquals(null, res[243].exec("13/5/2004P", 401));
+assertEquals(null, res[243].exec("02/05/09P", 402));
+assertEquals(null, res[243].exec("1P", 403));
+assertEquals(null, res[243].exec("1/2P", 404));
+assertEquals(null, res[243].exec("1/2/0P", 405));
+assertEquals(null, res[243].exec("1/2/04P", 406));
+assertEquals(null, res[243].exec("0P", 407));
+assertEquals(null, res[243].exec("02/P", 408));
+assertEquals(null, res[243].exec("02/0P", 409));
+assertEquals(null, res[243].exec("02/1P", 410));
+assertEquals(null, res[243].exec("** FailersP", 411));
+assertEquals(null, res[243].exec("P", 412));
+assertEquals(null, res[243].exec("123P", 413));
+assertEquals(null, res[243].exec("33/4/04P", 414));
+assertEquals(null, res[243].exec("3/13/04P", 415));
+assertEquals(null, res[243].exec("0/1/2003P", 416));
+assertEquals(null, res[243].exec("0/P", 417));
+assertEquals(null, res[243].exec("02/0/P", 418));
+assertEquals(null, res[243].exec("02/13P", 419));
+assertEquals("123", res[248].exec("123P"), 420);
+assertEquals(null, res[248].exec("aP", 421));
+assertEquals(null, res[248].exec("bP", 422));
+assertEquals(null, res[248].exec("cP", 423));
+assertEquals(null, res[248].exec("c12P", 424));
+assertEquals("c123", res[248].exec("c123P"), 425);
+assertEquals(null, res[249].exec("1P", 426));
+assertEquals(null, res[249].exec("123P", 427));
+assertEquals("123X", res[249].exec("123X"), 428);
+assertEquals(null, res[249].exec("1234P", 429));
+assertEquals("1234X", res[249].exec("1234X"), 430);
+assertEquals(null, res[249].exec("12345P", 431));
+assertEquals("12345X", res[249].exec("12345X"), 432);
+assertEquals(null, res[249].exec("*** Failers", 433));
+assertEquals(null, res[249].exec("1X", 434));
+assertEquals(null, res[249].exec("123456P", 435));
+assertEquals(null, res[249].exec("abc", 436));
+assertEquals(null, res[249].exec("** Failers", 437));
+assertEquals(null, res[249].exec("bca", 438));
+assertEquals(null, res[249].exec("abc", 439));
+assertEquals(null, res[249].exec("** Failers", 440));
+assertEquals(null, res[249].exec("bca", 441));
+assertEquals(null, res[249].exec("abc", 442));
+assertEquals(null, res[249].exec("** Failers", 443));
+assertEquals(null, res[249].exec("def", 444));
+assertEquals(null, res[249].exec("abc", 445));
+assertEquals(null, res[249].exec("** Failers", 446));
+assertEquals(null, res[249].exec("def", 447));
+assertEquals(null, res[249].exec("<!DOCTYPE seite SYSTEM \"http://www.lco.lineas.de/xmlCms.dtd\">\n<seite>\n<dokumenteninformation>\n<seitentitel>Partner der LCO</seitentitel>\n<sprache>de</sprache>\n<seitenbeschreibung>Partner der LINEAS Consulting\nGmbH</seitenbeschreibung>\n<schluesselworte>LINEAS Consulting GmbH Hamburg\nPartnerfirmen</schluesselworte>\n<revisit>30 days</revisit>\n<robots>index,follow</robots>\n<menueinformation>\n<aktiv>ja</aktiv>\n<menueposition>3</menueposition>\n<menuetext>Partner</menuetext>\n</menueinformation>\n<lastedited>\n<autor>LCO</autor>\n<firma>LINEAS Consulting</firma>\n<datum>15.10.2003</datum>\n</lastedited>\n</dokumenteninformation>\n<inhalt>\n\n<absatzueberschrift>Die Partnerfirmen der LINEAS Consulting\nGmbH</absatzueberschrift>\n\n<absatz><link ziel=\"http://www.ca.com/\" zielfenster=\"_blank\">\n<bild name=\"logo_ca.gif\" rahmen=\"no\"/></link> <link\nziel=\"http://www.ey.com/\" zielfenster=\"_blank\"><bild\nname=\"logo_euy.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><link ziel=\"http://www.cisco.de/\" zielfenster=\"_blank\">\n<bild name=\"logo_cisco.gif\" rahmen=\"ja\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.atelion.de/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_atelion.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><link ziel=\"http://www.line-information.de/\"\nzielfenster=\"_blank\">\n<bild name=\"logo_line_information.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><bild name=\"logo_aw.gif\" rahmen=\"no\"/></absatz>\n\n<absatz><link ziel=\"http://www.incognis.de/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_incognis.gif\" rahmen=\"no\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.addcraft.com/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_addcraft.gif\" rahmen=\"no\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.comendo.com/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_comendo.gif\" rahmen=\"no\"/></link></absatz>\n\n</inhalt>\n</seite>", 448));
+assertEquals("line\nbreak", res[251].exec("this is a line\nbreak"), 449);
+assertEquals("line\nbreak", res[251].exec("line one\nthis is a line\nbreak in the second line"), 450);
+assertEquals("line\nbreak", res[252].exec("this is a line\nbreak"), 451);
+assertEquals(null, res[252].exec("** Failers", 452));
+assertEquals("line\nbreak", res[252].exec("line one\nthis is a line\nbreak in the second line"), 453);
+assertEquals("line\nbreak", res[253].exec("this is a line\nbreak"), 454);
+assertEquals(null, res[253].exec("** Failers", 455));
+assertEquals("line\nbreak", res[253].exec("line one\nthis is a line\nbreak in the second line"), 456);
+assertEquals("ab-cd", res[254].exec("ab-cd"), 457);
+assertEquals("ab=cd", res[254].exec("ab=cd"), 458);
+assertEquals(null, res[254].exec("** Failers", 459));
+assertEquals(null, res[254].exec("ab\ncd", 460));
+assertEquals("ab-cd", res[255].exec("ab-cd"), 461);
+assertEquals("ab=cd", res[255].exec("ab=cd"), 462);
+assertEquals(null, res[255].exec("ab\ncd", 463));
+assertEquals(null, res[255].exec("AbCd", 464));
+assertEquals(null, res[255].exec("** Failers", 465));
+assertEquals(null, res[255].exec("abcd", 466));
 // We are compatible with JSC, and don't throw an exception in this case.
 // assertThrows("var re = /(){2,4294967295}/;", 467);
-assertNull(res[255].exec("abcdefghijklAkB", 468));
-assertNull(res[255].exec("abcdefghijklAkB", 469));
-assertNull(res[255].exec("abcdefghijklAkB", 470));
-assertNull(res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 471));
-assertNull(res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 472));
-assertNull(res[255].exec("(this(and)that", 473));
-assertNull(res[255].exec("(this(and)that)", 474));
-assertNull(res[255].exec("(this(and)that)stuff", 475));
-assertNull(res[255].exec("(this(and)that", 476));
-assertNull(res[255].exec("(this(and)that)", 477));
-assertNull(res[255].exec("(this(and)that", 478));
-assertNull(res[255].exec("(this(and)that)", 479));
-assertNull(res[255].exec("(this(and)that", 480));
-assertNull(res[255].exec("(this(and)that)", 481));
-assertNull(res[255].exec("((this))", 482));
-assertNull(res[255].exec("(this(and)that", 483));
-assertNull(res[255].exec("(this(and)that)", 484));
-assertNull(res[255].exec("(this)", 485));
-assertNull(res[255].exec("((this))", 486));
-assertToStringEquals("abc,b", res[256].exec("abc"), 487);
-assertToStringEquals("abc,b", res[256].exec("abc"), 488);
-assertNull(res[256].exec("a1bCA", 489));
-assertNull(res[256].exec("a2bCA", 490));
-assertNull(res[257].exec("a bc dCACBCC", 491));
-assertNull(res[257].exec("aabc", 492));
-assertNull(res[257].exec("bc", 493));
-assertNull(res[257].exec("** Failers", 494));
-assertNull(res[257].exec("abc", 495));
-assertNull(res[257].exec("bXaX", 496));
-assertNull(res[257].exec("bbXaaX", 497));
-assertNull(res[257].exec("(b)\\Xa\\X", 498));
-assertNull(res[257].exec("bXXaYYaY", 499));
-assertNull(res[257].exec("bXYaXXaX", 500));
-assertNull(res[257].exec("bXXaYYaY", 501));
-assertToStringEquals("\x0b,\x0b", res[259].exec("\x0b,\x0b"), 502);
-assertToStringEquals("\x0c,\x0d", res[259].exec("\x0c,\x0d"), 503);
-assertToStringEquals("abc", res[260].exec("xyz\nabc"), 504);
-assertToStringEquals("abc", res[260].exec("xyz\nabc<lf>"), 505);
-assertToStringEquals("abc", res[260].exec("xyz\x0d\nabc<lf>"), 506);
-assertToStringEquals("abc", res[260].exec("xyz\x0dabc<cr>"), 507);
-assertToStringEquals("abc", res[260].exec("xyz\x0d\nabc<crlf>"), 508);
-assertNull(res[260].exec("** Failers", 509));
-assertToStringEquals("abc", res[260].exec("xyz\nabc<cr>"), 510);
-assertToStringEquals("abc", res[260].exec("xyz\x0d\nabc<cr>"), 511);
-assertToStringEquals("abc", res[260].exec("xyz\nabc<crlf>"), 512);
-assertToStringEquals("abc", res[260].exec("xyz\x0dabc<crlf>"), 513);
-assertToStringEquals("abc", res[260].exec("xyz\x0dabc<lf>"), 514);
-assertToStringEquals("abc", res[261].exec("xyzabc"), 515);
-assertToStringEquals("abc", res[261].exec("xyzabc\n"), 516);
-assertToStringEquals("abc", res[261].exec("xyzabc\npqr"), 517);
-assertToStringEquals("abc", res[261].exec("xyzabc\x0d<cr>"), 518);
-assertToStringEquals("abc", res[261].exec("xyzabc\x0dpqr<cr>"), 519);
-assertToStringEquals("abc", res[261].exec("xyzabc\x0d\n<crlf>"), 520);
-assertToStringEquals("abc", res[261].exec("xyzabc\x0d\npqr<crlf>"), 521);
-assertNull(res[261].exec("** Failers", 522));
-assertToStringEquals("abc", res[261].exec("xyzabc\x0d"), 523);
-assertToStringEquals("abc", res[261].exec("xyzabc\x0dpqr"), 524);
-assertToStringEquals("abc", res[261].exec("xyzabc\x0d\n"), 525);
-assertToStringEquals("abc", res[261].exec("xyzabc\x0d\npqr"), 526);
-assertToStringEquals("abc", res[262].exec("xyz\x0dabcdef"), 527);
-assertToStringEquals("abc", res[262].exec("xyz\nabcdef<lf>"), 528);
-assertNull(res[262].exec("** Failers", 529));
-assertToStringEquals("abc", res[262].exec("xyz\nabcdef"), 530);
-assertToStringEquals("abc", res[263].exec("xyz\nabcdef"), 531);
-assertToStringEquals("abc", res[263].exec("xyz\x0dabcdef<cr>"), 532);
-assertNull(res[263].exec("** Failers", 533));
-assertToStringEquals("abc", res[263].exec("xyz\x0dabcdef"), 534);
-assertToStringEquals("abc", res[264].exec("xyz\x0d\nabcdef"), 535);
-assertToStringEquals("abc", res[264].exec("xyz\x0dabcdef<cr>"), 536);
-assertNull(res[264].exec("** Failers", 537));
-assertToStringEquals("abc", res[264].exec("xyz\x0dabcdef"), 538);
-assertToStringEquals("abc", res[266].exec("xyz\x0dabc<bad>"), 539);
-assertToStringEquals("abc", res[266].exec("abc"), 540);
-assertToStringEquals("abc", res[267].exec("abc\ndef"), 541);
-assertToStringEquals("abc", res[267].exec("abc\x0ddef"), 542);
-assertToStringEquals("abc", res[267].exec("abc\x0d\ndef"), 543);
-assertToStringEquals("<cr>abc", res[267].exec("<cr>abc\ndef"), 544);
-assertToStringEquals("<cr>abc", res[267].exec("<cr>abc\x0ddef"), 545);
-assertToStringEquals("<cr>abc", res[267].exec("<cr>abc\x0d\ndef"), 546);
-assertToStringEquals("<crlf>abc", res[267].exec("<crlf>abc\ndef"), 547);
-assertToStringEquals("<crlf>abc", res[267].exec("<crlf>abc\x0ddef"), 548);
-assertToStringEquals("<crlf>abc", res[267].exec("<crlf>abc\x0d\ndef"), 549);
-assertNull(res[268].exec("abc\ndef", 550));
-assertNull(res[268].exec("abc\x0ddef", 551));
-assertNull(res[268].exec("abc\x0d\ndef", 552));
-assertToStringEquals("XY,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,XY,Y", res[269].exec("XYO400"), 553);
-assertToStringEquals("aaaA5", res[278].exec("aaaA5"), 554);
-assertNull(res[278].exec("** Failers", 555));
-assertNull(res[278].exec("aaaa5", 556));
-assertToStringEquals("aaaA5", res[279].exec("aaaA5"), 557);
-assertToStringEquals("aaaa5", res[279].exec("aaaa5"), 558);
-assertToStringEquals("x", res[350].exec("xyCabcCxyz"), 559);
-assertToStringEquals("x", res[350].exec("xyCabcCxyz"), 560);
-assertToStringEquals("b", res[350].exec("bXaX"), 561);
-assertToStringEquals("b", res[350].exec("bXbX"), 562);
-assertToStringEquals("*", res[350].exec("** Failers"), 563);
-assertToStringEquals("aX", res[350].exec("aXaX"), 564);
-assertToStringEquals("aX", res[350].exec("aXbX"), 565);
-assertToStringEquals("x", res[350].exec("xx"), 566);
-assertToStringEquals("x", res[350].exec("xy"), 567);
-assertToStringEquals("y", res[350].exec("yy"), 568);
-assertToStringEquals("y", res[350].exec("yx"), 569);
-assertToStringEquals("x", res[350].exec("xx"), 570);
-assertToStringEquals("x", res[350].exec("xy"), 571);
-assertToStringEquals("y", res[350].exec("yy"), 572);
-assertToStringEquals("y", res[350].exec("yx"), 573);
-assertToStringEquals("b", res[350].exec("bxay"), 574);
-assertToStringEquals("b", res[350].exec("bxby"), 575);
-assertToStringEquals("*", res[350].exec("** Failers"), 576);
-assertToStringEquals("ax", res[350].exec("axby"), 577);
-assertToStringEquals("X", res[350].exec("XxXxxx"), 578);
-assertToStringEquals("X", res[350].exec("XxXyyx"), 579);
-assertToStringEquals("X", res[350].exec("XxXyxx"), 580);
-assertToStringEquals("*", res[350].exec("** Failers"), 581);
-assertToStringEquals("x", res[350].exec("x"), 582);
-assertToStringEquals("ab", res[350].exec("abcabc"), 583);
-assertToStringEquals("Xaaa,a", res[351].exec("Xaaa"), 584);
-assertToStringEquals("Xaba,a", res[351].exec("Xaba"), 585);
+assertEquals(null, res[255].exec("abcdefghijklAkB", 468));
+assertEquals(null, res[255].exec("abcdefghijklAkB", 469));
+assertEquals(null, res[255].exec("abcdefghijklAkB", 470));
+assertEquals(null, res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 471));
+assertEquals(null, res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 472));
+assertEquals(null, res[255].exec("(this(and)that", 473));
+assertEquals(null, res[255].exec("(this(and)that)", 474));
+assertEquals(null, res[255].exec("(this(and)that)stuff", 475));
+assertEquals(null, res[255].exec("(this(and)that", 476));
+assertEquals(null, res[255].exec("(this(and)that)", 477));
+assertEquals(null, res[255].exec("(this(and)that", 478));
+assertEquals(null, res[255].exec("(this(and)that)", 479));
+assertEquals(null, res[255].exec("(this(and)that", 480));
+assertEquals(null, res[255].exec("(this(and)that)", 481));
+assertEquals(null, res[255].exec("((this))", 482));
+assertEquals(null, res[255].exec("(this(and)that", 483));
+assertEquals(null, res[255].exec("(this(and)that)", 484));
+assertEquals(null, res[255].exec("(this)", 485));
+assertEquals(null, res[255].exec("((this))", 486));
+assertEquals("abc,b", res[256].exec("abc"), 487);
+assertEquals("abc,b", res[256].exec("abc"), 488);
+assertEquals(null, res[256].exec("a1bCA", 489));
+assertEquals(null, res[256].exec("a2bCA", 490));
+assertEquals(null, res[257].exec("a bc dCACBCC", 491));
+assertEquals(null, res[257].exec("aabc", 492));
+assertEquals(null, res[257].exec("bc", 493));
+assertEquals(null, res[257].exec("** Failers", 494));
+assertEquals(null, res[257].exec("abc", 495));
+assertEquals(null, res[257].exec("bXaX", 496));
+assertEquals(null, res[257].exec("bbXaaX", 497));
+assertEquals(null, res[257].exec("(b)\\Xa\\X", 498));
+assertEquals(null, res[257].exec("bXXaYYaY", 499));
+assertEquals(null, res[257].exec("bXYaXXaX", 500));
+assertEquals(null, res[257].exec("bXXaYYaY", 501));
+assertEquals("\x0b,\x0b", res[259].exec("\x0b,\x0b"), 502);
+assertEquals("\x0c,\x0d", res[259].exec("\x0c,\x0d"), 503);
+assertEquals("abc", res[260].exec("xyz\nabc"), 504);
+assertEquals("abc", res[260].exec("xyz\nabc<lf>"), 505);
+assertEquals("abc", res[260].exec("xyz\x0d\nabc<lf>"), 506);
+assertEquals("abc", res[260].exec("xyz\x0dabc<cr>"), 507);
+assertEquals("abc", res[260].exec("xyz\x0d\nabc<crlf>"), 508);
+assertEquals(null, res[260].exec("** Failers", 509));
+assertEquals("abc", res[260].exec("xyz\nabc<cr>"), 510);
+assertEquals("abc", res[260].exec("xyz\x0d\nabc<cr>"), 511);
+assertEquals("abc", res[260].exec("xyz\nabc<crlf>"), 512);
+assertEquals("abc", res[260].exec("xyz\x0dabc<crlf>"), 513);
+assertEquals("abc", res[260].exec("xyz\x0dabc<lf>"), 514);
+assertEquals("abc", res[261].exec("xyzabc"), 515);
+assertEquals("abc", res[261].exec("xyzabc\n"), 516);
+assertEquals("abc", res[261].exec("xyzabc\npqr"), 517);
+assertEquals("abc", res[261].exec("xyzabc\x0d<cr>"), 518);
+assertEquals("abc", res[261].exec("xyzabc\x0dpqr<cr>"), 519);
+assertEquals("abc", res[261].exec("xyzabc\x0d\n<crlf>"), 520);
+assertEquals("abc", res[261].exec("xyzabc\x0d\npqr<crlf>"), 521);
+assertEquals(null, res[261].exec("** Failers", 522));
+assertEquals("abc", res[261].exec("xyzabc\x0d"), 523);
+assertEquals("abc", res[261].exec("xyzabc\x0dpqr"), 524);
+assertEquals("abc", res[261].exec("xyzabc\x0d\n"), 525);
+assertEquals("abc", res[261].exec("xyzabc\x0d\npqr"), 526);
+assertEquals("abc", res[262].exec("xyz\x0dabcdef"), 527);
+assertEquals("abc", res[262].exec("xyz\nabcdef<lf>"), 528);
+assertEquals(null, res[262].exec("** Failers", 529));
+assertEquals("abc", res[262].exec("xyz\nabcdef"), 530);
+assertEquals("abc", res[263].exec("xyz\nabcdef"), 531);
+assertEquals("abc", res[263].exec("xyz\x0dabcdef<cr>"), 532);
+assertEquals(null, res[263].exec("** Failers", 533));
+assertEquals("abc", res[263].exec("xyz\x0dabcdef"), 534);
+assertEquals("abc", res[264].exec("xyz\x0d\nabcdef"), 535);
+assertEquals("abc", res[264].exec("xyz\x0dabcdef<cr>"), 536);
+assertEquals(null, res[264].exec("** Failers", 537));
+assertEquals("abc", res[264].exec("xyz\x0dabcdef"), 538);
+assertEquals("abc", res[266].exec("xyz\x0dabc<bad>"), 539);
+assertEquals("abc", res[266].exec("abc"), 540);
+assertEquals("abc", res[267].exec("abc\ndef"), 541);
+assertEquals("abc", res[267].exec("abc\x0ddef"), 542);
+assertEquals("abc", res[267].exec("abc\x0d\ndef"), 543);
+assertEquals("<cr>abc", res[267].exec("<cr>abc\ndef"), 544);
+assertEquals("<cr>abc", res[267].exec("<cr>abc\x0ddef"), 545);
+assertEquals("<cr>abc", res[267].exec("<cr>abc\x0d\ndef"), 546);
+assertEquals("<crlf>abc", res[267].exec("<crlf>abc\ndef"), 547);
+assertEquals("<crlf>abc", res[267].exec("<crlf>abc\x0ddef"), 548);
+assertEquals("<crlf>abc", res[267].exec("<crlf>abc\x0d\ndef"), 549);
+assertEquals(null, res[268].exec("abc\ndef", 550));
+assertEquals(null, res[268].exec("abc\x0ddef", 551));
+assertEquals(null, res[268].exec("abc\x0d\ndef", 552));
+assertEquals("XY,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,XY,Y", res[269].exec("XYO400"), 553);
+assertEquals("aaaA5", res[278].exec("aaaA5"), 554);
+assertEquals(null, res[278].exec("** Failers", 555));
+assertEquals(null, res[278].exec("aaaa5", 556));
+assertEquals("aaaA5", res[279].exec("aaaA5"), 557);
+assertEquals("aaaa5", res[279].exec("aaaa5"), 558);
+assertEquals("x", res[350].exec("xyCabcCxyz"), 559);
+assertEquals("x", res[350].exec("xyCabcCxyz"), 560);
+assertEquals("b", res[350].exec("bXaX"), 561);
+assertEquals("b", res[350].exec("bXbX"), 562);
+assertEquals("*", res[350].exec("** Failers"), 563);
+assertEquals("aX", res[350].exec("aXaX"), 564);
+assertEquals("aX", res[350].exec("aXbX"), 565);
+assertEquals("x", res[350].exec("xx"), 566);
+assertEquals("x", res[350].exec("xy"), 567);
+assertEquals("y", res[350].exec("yy"), 568);
+assertEquals("y", res[350].exec("yx"), 569);
+assertEquals("x", res[350].exec("xx"), 570);
+assertEquals("x", res[350].exec("xy"), 571);
+assertEquals("y", res[350].exec("yy"), 572);
+assertEquals("y", res[350].exec("yx"), 573);
+assertEquals("b", res[350].exec("bxay"), 574);
+assertEquals("b", res[350].exec("bxby"), 575);
+assertEquals("*", res[350].exec("** Failers"), 576);
+assertEquals("ax", res[350].exec("axby"), 577);
+assertEquals("X", res[350].exec("XxXxxx"), 578);
+assertEquals("X", res[350].exec("XxXyyx"), 579);
+assertEquals("X", res[350].exec("XxXyxx"), 580);
+assertEquals("*", res[350].exec("** Failers"), 581);
+assertEquals("x", res[350].exec("x"), 582);
+assertEquals("ab", res[350].exec("abcabc"), 583);
+assertEquals("Xaaa,a", res[351].exec("Xaaa"), 584);
+assertEquals("Xaba,a", res[351].exec("Xaba"), 585);
 assertThrows("var re = /^[a-\\Q\\E]/;", 586);
-assertNull(res[353].exec("(xy)x", 587));
-assertNull(res[353].exec("1221", 588));
-assertNull(res[353].exec("Satan, oscillate my metallic sonatas!", 589));
-assertNull(res[353].exec("A man, a plan, a canal: Panama!", 590));
-assertNull(res[353].exec("Able was I ere I saw Elba.", 591));
-assertNull(res[353].exec("*** Failers", 592));
-assertNull(res[353].exec("The quick brown fox", 593));
-assertToStringEquals("abcd:,abcd", res[354].exec("abcd:"), 594);
-assertToStringEquals("abcd:,abcd", res[354].exec("abcd:"), 595);
-assertToStringEquals("a:,a", res[354].exec("a:aaxyz"), 596);
-assertToStringEquals("ab:,ab", res[354].exec("ab:ababxyz"), 597);
-assertNull(res[354].exec("** Failers", 598));
-assertToStringEquals("a:,a", res[354].exec("a:axyz"), 599);
-assertToStringEquals("ab:,ab", res[354].exec("ab:abxyz"), 600);
-assertNull(res[354].exec("abd", 601));
-assertNull(res[354].exec("ce", 602));
-assertNull(res[354].exec("abcabc1Xabc2XabcXabcabc", 603));
-assertNull(res[354].exec("abcabc1Xabc2XabcXabcabc", 604));
-assertNull(res[354].exec("abcabc1Xabc2XabcXabcabc", 605));
-assertNull(res[354].exec("abcd", 606));
-assertNull(res[354].exec("metcalfe 33", 607));
-assertNull(res[356].exec("a\x0db", 608));
-assertNull(res[356].exec("a\nb<cr>", 609));
-assertToStringEquals("a\x85b", res[356].exec("a\x85b<anycrlf> "), 610);
-assertNull(res[356].exec("** Failers", 611));
-assertNull(res[356].exec("a\nb", 612));
-assertNull(res[356].exec("a\nb<any>", 613));
-assertNull(res[356].exec("a\x0db<cr>", 614));
-assertNull(res[356].exec("a\x0db<any>", 615));
-assertToStringEquals("a\x85b", res[356].exec("a\x85b<any> "), 616);
-assertNull(res[356].exec("a\x0db<anycrlf>", 617));
-assertToStringEquals("abc1", res[357].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 618);
-assertToStringEquals("abc1", res[358].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc7 abc9"), 619);
-assertNull(res[361].exec("a\nb", 620));
-assertNull(res[361].exec("a\x0db", 621));
-assertNull(res[361].exec("a\x0d\nb", 622));
-assertNull(res[361].exec("a\x0bb", 623));
-assertNull(res[361].exec("a\x0cb", 624));
-assertNull(res[361].exec("a\x85b", 625));
-assertNull(res[361].exec("** Failers", 626));
-assertNull(res[361].exec("a\n\x0db", 627));
-assertToStringEquals("ab", res[362].exec("ab"), 628);
-assertNull(res[362].exec("a\nb", 629));
-assertNull(res[362].exec("a\x0db", 630));
-assertNull(res[362].exec("a\x0d\nb", 631));
-assertNull(res[362].exec("a\x0bb", 632));
-assertNull(res[362].exec("a\x0cb", 633));
-assertNull(res[362].exec("a\x85b", 634));
-assertNull(res[362].exec("a\n\x0db", 635));
-assertNull(res[362].exec("a\n\x0d\x85\x0cb", 636));
-assertNull(res[363].exec("a\nb", 637));
-assertNull(res[363].exec("a\x0db", 638));
-assertNull(res[363].exec("a\x0d\nb", 639));
-assertNull(res[363].exec("a\x0bb", 640));
-assertNull(res[363].exec("a\x0cb", 641));
-assertNull(res[363].exec("a\x85b", 642));
-assertNull(res[363].exec("a\n\x0db", 643));
-assertNull(res[363].exec("a\n\x0d\x85\x0cb", 644));
-assertNull(res[363].exec("** Failers", 645));
-assertNull(res[363].exec("ab", 646));
-assertNull(res[364].exec("a\nb", 647));
-assertNull(res[364].exec("a\n\x0db", 648));
-assertNull(res[364].exec("a\n\x0d\x85b", 649));
-assertNull(res[364].exec("a\x0d\n\x0d\nb", 650));
-assertNull(res[364].exec("a\x0d\n\x0d\n\x0d\nb", 651));
-assertNull(res[364].exec("a\n\x0d\n\x0db", 652));
-assertNull(res[364].exec("a\n\n\x0d\nb", 653));
-assertNull(res[364].exec("** Failers", 654));
-assertNull(res[364].exec("a\n\n\n\x0db", 655));
-assertNull(res[364].exec("a\x0d", 656));
-assertToStringEquals("aRb", res[365].exec("aRb"), 657);
-assertNull(res[365].exec("** Failers", 658));
-assertNull(res[365].exec("a\nb", 659));
-assertNull(res[365].exec("abcPXP123", 660));
-assertNull(res[365].exec("abcPXP123", 661));
-assertNull(res[365].exec("1.2.3.4", 662));
-assertNull(res[365].exec("131.111.10.206", 663));
-assertNull(res[365].exec("10.0.0.0", 664));
-assertNull(res[365].exec("** Failers", 665));
-assertNull(res[365].exec("10.6", 666));
-assertNull(res[365].exec("455.3.4.5", 667));
-assertNull(res[365].exec("1.2.3.4", 668));
-assertNull(res[365].exec("131.111.10.206", 669));
-assertNull(res[365].exec("10.0.0.0", 670));
-assertNull(res[365].exec("** Failers", 671));
-assertNull(res[365].exec("10.6", 672));
-assertNull(res[365].exec("455.3.4.5", 673));
-assertNull(res[365].exec("123axbaxbaxbx456", 674));
-assertNull(res[365].exec("123axbaxbaxb456", 675));
-assertNull(res[365].exec("123axbaxbaxbx456", 676));
-assertNull(res[365].exec("123axbaxbaxbx456", 677));
-assertNull(res[365].exec("123axbaxbaxbx456", 678));
-assertNull(res[366].exec("ababababbbabZXXXX", 679));
-assertNull(res[372].exec("a\x0db", 680));
-assertNull(res[372].exec("*** Failers", 681));
-assertNull(res[372].exec("a\nb", 682));
-assertToStringEquals("afoo", res[373].exec("afoo"), 683);
-assertNull(res[373].exec("** Failers", 684));
-assertNull(res[373].exec("\x0d\nfoo", 685));
-assertNull(res[373].exec("\nfoo", 686));
-assertToStringEquals("afoo", res[374].exec("afoo"), 687);
-assertNull(res[374].exec("\nfoo", 688));
-assertNull(res[374].exec("** Failers", 689));
-assertNull(res[374].exec("\x0d\nfoo", 690));
-assertToStringEquals("afoo", res[375].exec("afoo"), 691);
-assertNull(res[375].exec("** Failers", 692));
-assertNull(res[375].exec("\nfoo", 693));
-assertNull(res[375].exec("\x0d\nfoo", 694));
-assertToStringEquals("afoo", res[376].exec("afoo"), 695);
-assertNull(res[376].exec("\x0d\nfoo", 696));
-assertNull(res[376].exec("\nfoo", 697));
-assertToStringEquals("", res[377].exec("abc\x0d\x0dxyz"), 698);
-assertToStringEquals("", res[377].exec("abc\n\x0dxyz  "), 699);
-assertNull(res[377].exec("** Failers ", 700));
-assertToStringEquals("", res[377].exec("abc\x0d\nxyz"), 701);
-assertToStringEquals("", res[377].exec("abc\x0d\n\x0d\n"), 702);
-assertToStringEquals("", res[377].exec("abc\x0d\n\x0d\n"), 703);
-assertToStringEquals("", res[377].exec("abc\x0d\n\x0d\n"), 704);
-assertToStringEquals("abc1", res[378].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 705);
-assertToStringEquals("X", res[379].exec("XABC"), 706);
-assertNull(res[379].exec("** Failers ", 707));
-assertToStringEquals("X", res[379].exec("XABCB"), 708);
+assertEquals(null, res[353].exec("(xy)x", 587));
+assertEquals(null, res[353].exec("1221", 588));
+assertEquals(null, res[353].exec("Satan, oscillate my metallic sonatas!", 589));
+assertEquals(null, res[353].exec("A man, a plan, a canal: Panama!", 590));
+assertEquals(null, res[353].exec("Able was I ere I saw Elba.", 591));
+assertEquals(null, res[353].exec("*** Failers", 592));
+assertEquals(null, res[353].exec("The quick brown fox", 593));
+assertEquals("abcd:,abcd", res[354].exec("abcd:"), 594);
+assertEquals("abcd:,abcd", res[354].exec("abcd:"), 595);
+assertEquals("a:,a", res[354].exec("a:aaxyz"), 596);
+assertEquals("ab:,ab", res[354].exec("ab:ababxyz"), 597);
+assertEquals(null, res[354].exec("** Failers", 598));
+assertEquals("a:,a", res[354].exec("a:axyz"), 599);
+assertEquals("ab:,ab", res[354].exec("ab:abxyz"), 600);
+assertEquals(null, res[354].exec("abd", 601));
+assertEquals(null, res[354].exec("ce", 602));
+assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 603));
+assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 604));
+assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 605));
+assertEquals(null, res[354].exec("abcd", 606));
+assertEquals(null, res[354].exec("metcalfe 33", 607));
+assertEquals(null, res[356].exec("a\x0db", 608));
+assertEquals(null, res[356].exec("a\nb<cr>", 609));
+assertEquals("a\x85b", res[356].exec("a\x85b<anycrlf> "), 610);
+assertEquals(null, res[356].exec("** Failers", 611));
+assertEquals(null, res[356].exec("a\nb", 612));
+assertEquals(null, res[356].exec("a\nb<any>", 613));
+assertEquals(null, res[356].exec("a\x0db<cr>", 614));
+assertEquals(null, res[356].exec("a\x0db<any>", 615));
+assertEquals("a\x85b", res[356].exec("a\x85b<any> "), 616);
+assertEquals(null, res[356].exec("a\x0db<anycrlf>", 617));
+assertEquals("abc1", res[357].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 618);
+assertEquals("abc1", res[358].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc7 abc9"), 619);
+assertEquals(null, res[361].exec("a\nb", 620));
+assertEquals(null, res[361].exec("a\x0db", 621));
+assertEquals(null, res[361].exec("a\x0d\nb", 622));
+assertEquals(null, res[361].exec("a\x0bb", 623));
+assertEquals(null, res[361].exec("a\x0cb", 624));
+assertEquals(null, res[361].exec("a\x85b", 625));
+assertEquals(null, res[361].exec("** Failers", 626));
+assertEquals(null, res[361].exec("a\n\x0db", 627));
+assertEquals("ab", res[362].exec("ab"), 628);
+assertEquals(null, res[362].exec("a\nb", 629));
+assertEquals(null, res[362].exec("a\x0db", 630));
+assertEquals(null, res[362].exec("a\x0d\nb", 631));
+assertEquals(null, res[362].exec("a\x0bb", 632));
+assertEquals(null, res[362].exec("a\x0cb", 633));
+assertEquals(null, res[362].exec("a\x85b", 634));
+assertEquals(null, res[362].exec("a\n\x0db", 635));
+assertEquals(null, res[362].exec("a\n\x0d\x85\x0cb", 636));
+assertEquals(null, res[363].exec("a\nb", 637));
+assertEquals(null, res[363].exec("a\x0db", 638));
+assertEquals(null, res[363].exec("a\x0d\nb", 639));
+assertEquals(null, res[363].exec("a\x0bb", 640));
+assertEquals(null, res[363].exec("a\x0cb", 641));
+assertEquals(null, res[363].exec("a\x85b", 642));
+assertEquals(null, res[363].exec("a\n\x0db", 643));
+assertEquals(null, res[363].exec("a\n\x0d\x85\x0cb", 644));
+assertEquals(null, res[363].exec("** Failers", 645));
+assertEquals(null, res[363].exec("ab", 646));
+assertEquals(null, res[364].exec("a\nb", 647));
+assertEquals(null, res[364].exec("a\n\x0db", 648));
+assertEquals(null, res[364].exec("a\n\x0d\x85b", 649));
+assertEquals(null, res[364].exec("a\x0d\n\x0d\nb", 650));
+assertEquals(null, res[364].exec("a\x0d\n\x0d\n\x0d\nb", 651));
+assertEquals(null, res[364].exec("a\n\x0d\n\x0db", 652));
+assertEquals(null, res[364].exec("a\n\n\x0d\nb", 653));
+assertEquals(null, res[364].exec("** Failers", 654));
+assertEquals(null, res[364].exec("a\n\n\n\x0db", 655));
+assertEquals(null, res[364].exec("a\x0d", 656));
+assertEquals("aRb", res[365].exec("aRb"), 657);
+assertEquals(null, res[365].exec("** Failers", 658));
+assertEquals(null, res[365].exec("a\nb", 659));
+assertEquals(null, res[365].exec("abcPXP123", 660));
+assertEquals(null, res[365].exec("abcPXP123", 661));
+assertEquals(null, res[365].exec("1.2.3.4", 662));
+assertEquals(null, res[365].exec("131.111.10.206", 663));
+assertEquals(null, res[365].exec("10.0.0.0", 664));
+assertEquals(null, res[365].exec("** Failers", 665));
+assertEquals(null, res[365].exec("10.6", 666));
+assertEquals(null, res[365].exec("455.3.4.5", 667));
+assertEquals(null, res[365].exec("1.2.3.4", 668));
+assertEquals(null, res[365].exec("131.111.10.206", 669));
+assertEquals(null, res[365].exec("10.0.0.0", 670));
+assertEquals(null, res[365].exec("** Failers", 671));
+assertEquals(null, res[365].exec("10.6", 672));
+assertEquals(null, res[365].exec("455.3.4.5", 673));
+assertEquals(null, res[365].exec("123axbaxbaxbx456", 674));
+assertEquals(null, res[365].exec("123axbaxbaxb456", 675));
+assertEquals(null, res[365].exec("123axbaxbaxbx456", 676));
+assertEquals(null, res[365].exec("123axbaxbaxbx456", 677));
+assertEquals(null, res[365].exec("123axbaxbaxbx456", 678));
+assertEquals(null, res[366].exec("ababababbbabZXXXX", 679));
+assertEquals(null, res[372].exec("a\x0db", 680));
+assertEquals(null, res[372].exec("*** Failers", 681));
+assertEquals(null, res[372].exec("a\nb", 682));
+assertEquals("afoo", res[373].exec("afoo"), 683);
+assertEquals(null, res[373].exec("** Failers", 684));
+assertEquals(null, res[373].exec("\x0d\nfoo", 685));
+assertEquals(null, res[373].exec("\nfoo", 686));
+assertEquals("afoo", res[374].exec("afoo"), 687);
+assertEquals(null, res[374].exec("\nfoo", 688));
+assertEquals(null, res[374].exec("** Failers", 689));
+assertEquals(null, res[374].exec("\x0d\nfoo", 690));
+assertEquals("afoo", res[375].exec("afoo"), 691);
+assertEquals(null, res[375].exec("** Failers", 692));
+assertEquals(null, res[375].exec("\nfoo", 693));
+assertEquals(null, res[375].exec("\x0d\nfoo", 694));
+assertEquals("afoo", res[376].exec("afoo"), 695);
+assertEquals(null, res[376].exec("\x0d\nfoo", 696));
+assertEquals(null, res[376].exec("\nfoo", 697));
+assertEquals("", res[377].exec("abc\x0d\x0dxyz"), 698);
+assertEquals("", res[377].exec("abc\n\x0dxyz  "), 699);
+assertEquals(null, res[377].exec("** Failers ", 700));
+assertEquals("", res[377].exec("abc\x0d\nxyz"), 701);
+assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 702);
+assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 703);
+assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 704);
+assertEquals("abc1", res[378].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 705);
+assertEquals("X", res[379].exec("XABC"), 706);
+assertEquals(null, res[379].exec("** Failers ", 707));
+assertEquals("X", res[379].exec("XABCB"), 708);
 assertThrows("var re = /(ab|c)(?-1)/;", 709);
-assertNull(res[379].exec("abc", 710));
-assertNull(res[379].exec("xyabcabc", 711));
-assertNull(res[379].exec("** Failers", 712));
-assertNull(res[379].exec("xyabc  ", 713));
+assertEquals(null, res[379].exec("abc", 710));
+assertEquals(null, res[379].exec("xyabcabc", 711));
+assertEquals(null, res[379].exec("** Failers", 712));
+assertEquals(null, res[379].exec("xyabc  ", 713));
 assertThrows("var re = /x(?-0)y/;", 714);
 assertThrows("var re = /x(?-1)y/;", 715);
-assertNull(res[379].exec("abcX", 716));
-assertNull(res[379].exec("Y", 717));
-assertNull(res[379].exec("** Failers", 718));
-assertNull(res[379].exec("abcY   ", 719));
-assertNull(res[379].exec("YabcXabc", 720));
-assertNull(res[379].exec("YabcXabcXabc", 721));
-assertNull(res[379].exec("** Failers", 722));
-assertToStringEquals("X", res[379].exec("XabcXabc  "), 723);
-assertNull(res[379].exec("Y!", 724));
-assertNull(res[380].exec("foobar", 725));
-assertNull(res[381].exec("foobar", 726));
-assertToStringEquals("foobaz,foo,baz", res[381].exec("foobaz "), 727);
-assertNull(res[382].exec("foobarbaz", 728));
-assertNull(res[382].exec("tom-tom", 729));
-assertNull(res[382].exec("bon-bon ", 730));
-assertNull(res[382].exec("** Failers", 731));
-assertNull(res[382].exec("tom-bon  ", 732));
-assertNull(res[382].exec("tom-tom", 733));
-assertNull(res[382].exec("bon-bon ", 734));
+assertEquals(null, res[379].exec("abcX", 716));
+assertEquals(null, res[379].exec("Y", 717));
+assertEquals(null, res[379].exec("** Failers", 718));
+assertEquals(null, res[379].exec("abcY   ", 719));
+assertEquals(null, res[379].exec("YabcXabc", 720));
+assertEquals(null, res[379].exec("YabcXabcXabc", 721));
+assertEquals(null, res[379].exec("** Failers", 722));
+assertEquals("X", res[379].exec("XabcXabc  "), 723);
+assertEquals(null, res[379].exec("Y!", 724));
+assertEquals(null, res[380].exec("foobar", 725));
+assertEquals(null, res[381].exec("foobar", 726));
+assertEquals("foobaz,foo,baz", res[381].exec("foobaz "), 727);
+assertEquals(null, res[382].exec("foobarbaz", 728));
+assertEquals(null, res[382].exec("tom-tom", 729));
+assertEquals(null, res[382].exec("bon-bon ", 730));
+assertEquals(null, res[382].exec("** Failers", 731));
+assertEquals(null, res[382].exec("tom-bon  ", 732));
+assertEquals(null, res[382].exec("tom-tom", 733));
+assertEquals(null, res[382].exec("bon-bon ", 734));
 assertThrows("var re = /(?|(abc)|(xyz))/;", 735);
 assertThrows("var re = /(x)(?|(abc)|(xyz))(x)/;", 736);
-assertNull(res[383].exec("xabcx", 737));
-assertNull(res[383].exec("xxyzx ", 738));
+assertEquals(null, res[383].exec("xabcx", 737));
+assertEquals(null, res[383].exec("xxyzx ", 738));
 assertThrows("var re = /(x)(?|(abc)(pqr)|(xyz))(x)/;", 739);
-assertNull(res[383].exec("xabcpqrx", 740));
-assertNull(res[383].exec("xxyzx ", 741));
+assertEquals(null, res[383].exec("xabcpqrx", 740));
+assertEquals(null, res[383].exec("xxyzx ", 741));
 assertThrows("var re = /(?|(abc)|(xyz))\\1/;", 742);
-assertNull(res[383].exec("abcabc", 743));
-assertNull(res[383].exec("xyzxyz ", 744));
-assertNull(res[383].exec("** Failers", 745));
-assertNull(res[383].exec("abcxyz", 746));
-assertNull(res[383].exec("xyzabc   ", 747));
-assertNull(res[383].exec("abcabc", 748));
-assertNull(res[383].exec("xyzabc ", 749));
-assertNull(res[383].exec("** Failers ", 750));
-assertNull(res[383].exec("xyzxyz ", 751));
-assertNull(res[384].exec("X X\n", 752));
-assertNull(res[384].exec("X\x09X\x0b", 753));
-assertNull(res[384].exec("** Failers", 754));
-assertNull(res[384].exec("\xa0 X\n   ", 755));
-assertNull(res[385].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 756));
-assertNull(res[385].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 757));
-assertNull(res[385].exec("\x09 \xa0\n\x0b\x0c", 758));
-assertNull(res[385].exec("** Failers ", 759));
-assertNull(res[385].exec("\x09 \xa0\n\x0b", 760));
-assertNull(res[385].exec(" ", 761));
-assertNull(res[386].exec("XY  ABCDE", 762));
-assertNull(res[386].exec("XY  PQR ST ", 763));
-assertNull(res[387].exec("XY  AB    PQRS", 764));
-assertNull(res[388].exec(">XNNNYZ", 765));
-assertNull(res[388].exec(">  X NYQZ", 766));
-assertNull(res[388].exec("** Failers", 767));
-assertNull(res[388].exec(">XYZ   ", 768));
-assertNull(res[388].exec(">  X NY Z", 769));
-assertNull(res[389].exec(">XY\nZ\nA\x0bNN\x0c", 770));
-assertNull(res[389].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 771));
-assertNull(res[390].exec(">\x09<", 772));
-assertNull(res[391].exec(">\x09 \xa0<", 773));
-assertNull(res[396].exec("** Failers", 774));
-assertNull(res[396].exec("XXXX", 775));
-assertNull(res[397].exec("XXXX Y ", 776));
-assertNull(res[419].exec("aaaaaa", 777));
-assertNull(res[419].exec("aaabccc", 778));
-assertNull(res[419].exec("aaabccc", 779));
-assertNull(res[419].exec("aaabccc", 780));
-assertNull(res[419].exec("aaabcccaaabccc", 781));
-assertNull(res[419].exec("aaaxxxxxx", 782));
-assertNull(res[419].exec("aaa++++++ ", 783));
-assertNull(res[419].exec("bbbxxxxx", 784));
-assertNull(res[419].exec("bbb+++++ ", 785));
-assertNull(res[419].exec("cccxxxx", 786));
-assertNull(res[419].exec("ccc++++ ", 787));
-assertNull(res[419].exec("dddddddd   ", 788));
-assertNull(res[419].exec("aaaxxxxxx", 789));
-assertNull(res[419].exec("aaa++++++ ", 790));
-assertNull(res[419].exec("bbbxxxxx", 791));
-assertNull(res[419].exec("bbb+++++ ", 792));
-assertNull(res[419].exec("cccxxxx", 793));
-assertNull(res[419].exec("ccc++++ ", 794));
-assertNull(res[419].exec("dddddddd   ", 795));
-assertNull(res[419].exec("aaabccc", 796));
-assertNull(res[419].exec("ABX", 797));
-assertNull(res[419].exec("AADE", 798));
-assertNull(res[419].exec("ACDE", 799));
-assertNull(res[419].exec("** Failers", 800));
-assertNull(res[419].exec("AD ", 801));
-assertNull(res[419].exec("    ", 802));
-assertNull(res[419].exec("aaaaaa", 803));
-assertNull(res[419].exec("aaabccc", 804));
-assertNull(res[419].exec("aaabccc", 805));
-assertNull(res[419].exec("aaabccc", 806));
-assertNull(res[419].exec("aaabcccaaabccc", 807));
-assertNull(res[419].exec("aaabccc", 808));
-assertNull(res[422].exec("\x0d\nA", 809));
-assertToStringEquals("\nA", res[423].exec("\x0d\nA "), 810);
-assertToStringEquals("\nA", res[424].exec("\x0d\nA "), 811);
-assertToStringEquals("\nA,\n", res[425].exec("\x0d\nA "), 812);
-assertNull(res[425].exec("a\nb", 813));
-assertNull(res[425].exec("** Failers", 814));
-assertNull(res[425].exec("a\x0db  ", 815));
-assertNull(res[425].exec("a\nb", 816));
-assertNull(res[425].exec("** Failers", 817));
-assertNull(res[425].exec("a\x0db  ", 818));
-assertNull(res[425].exec("a\x0db", 819));
-assertNull(res[425].exec("** Failers", 820));
-assertNull(res[425].exec("a\nb  ", 821));
-assertNull(res[425].exec("a\x0db", 822));
-assertNull(res[425].exec("a\nb  ", 823));
-assertNull(res[425].exec("** Failers", 824));
-assertNull(res[425].exec("a\x0d\nb  ", 825));
-assertNull(res[425].exec("** Failers", 826));
-assertNull(res[425].exec("a\x0db", 827));
-assertNull(res[425].exec("a\nb  ", 828));
-assertNull(res[425].exec("a\x0d\nb  ", 829));
-assertNull(res[425].exec("** Failers", 830));
-assertNull(res[425].exec("a\x0db", 831));
-assertNull(res[425].exec("a\nb  ", 832));
-assertNull(res[425].exec("a\x0d\nb  ", 833));
-assertNull(res[425].exec("a\x85b ", 834));
-assertNull(res[426].exec("a\x0db", 835));
-assertNull(res[426].exec("a\nb", 836));
-assertNull(res[426].exec("a\x0d\nb", 837));
-assertNull(res[426].exec("** Failers", 838));
-assertNull(res[426].exec("a\x85b", 839));
-assertNull(res[426].exec("a\x0bb     ", 840));
-assertNull(res[427].exec("a\x0db", 841));
-assertNull(res[427].exec("a\nb", 842));
-assertNull(res[427].exec("a\x0d\nb", 843));
-assertNull(res[427].exec("a\x85b", 844));
-assertNull(res[427].exec("a\x0bb     ", 845));
-assertNull(res[427].exec("** Failers ", 846));
-assertNull(res[427].exec("a\x85b<bsr_anycrlf>", 847));
-assertNull(res[427].exec("a\x0bb<bsr_anycrlf>", 848));
-assertNull(res[428].exec("a\x0db", 849));
-assertNull(res[428].exec("a\nb", 850));
-assertNull(res[428].exec("a\x0d\nb", 851));
-assertNull(res[428].exec("** Failers", 852));
-assertNull(res[428].exec("a\x85b", 853));
-assertNull(res[428].exec("a\x0bb     ", 854));
-assertNull(res[429].exec("a\x0db", 855));
-assertNull(res[429].exec("a\nb", 856));
-assertNull(res[429].exec("a\x0d\nb", 857));
-assertNull(res[429].exec("a\x85b", 858));
-assertNull(res[429].exec("a\x0bb     ", 859));
-assertNull(res[429].exec("** Failers ", 860));
-assertNull(res[429].exec("a\x85b<bsr_anycrlf>", 861));
-assertNull(res[429].exec("a\x0bb<bsr_anycrlf>", 862));
-assertNull(res[430].exec("a\x0d\n\nb", 863));
-assertNull(res[430].exec("a\n\x0d\x0db", 864));
-assertNull(res[430].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 865));
-assertNull(res[430].exec("** Failers", 866));
-assertNull(res[430].exec("a\x8585b", 867));
-assertNull(res[430].exec("a\x0b\x00bb     ", 868));
-assertNull(res[431].exec("a\x0d\x0db", 869));
-assertNull(res[431].exec("a\n\n\nb", 870));
-assertNull(res[431].exec("a\x0d\n\n\x0d\x0db", 871));
-assertNull(res[431].exec("a\x8585b", 872));
-assertNull(res[431].exec("a\x0b\x00bb     ", 873));
-assertNull(res[431].exec("** Failers ", 874));
-assertNull(res[431].exec("a\x0d\x0d\x0d\x0d\x0db ", 875));
-assertNull(res[431].exec("a\x8585b<bsr_anycrlf>", 876));
-assertNull(res[431].exec("a\x0b\x00bb<bsr_anycrlf>", 877));
-assertNull(res[431].exec("a\nb", 878));
-assertNull(res[431].exec("a\x0db ", 879));
-assertNull(res[431].exec("a\x85b", 880));
-assertNull(res[431].exec("a\nb", 881));
-assertNull(res[431].exec("a\x0db ", 882));
-assertNull(res[431].exec("a\x85b", 883));
+assertEquals(null, res[383].exec("abcabc", 743));
+assertEquals(null, res[383].exec("xyzxyz ", 744));
+assertEquals(null, res[383].exec("** Failers", 745));
+assertEquals(null, res[383].exec("abcxyz", 746));
+assertEquals(null, res[383].exec("xyzabc   ", 747));
+assertEquals(null, res[383].exec("abcabc", 748));
+assertEquals(null, res[383].exec("xyzabc ", 749));
+assertEquals(null, res[383].exec("** Failers ", 750));
+assertEquals(null, res[383].exec("xyzxyz ", 751));
+assertEquals(null, res[384].exec("X X\n", 752));
+assertEquals(null, res[384].exec("X\x09X\x0b", 753));
+assertEquals(null, res[384].exec("** Failers", 754));
+assertEquals(null, res[384].exec("\xa0 X\n   ", 755));
+assertEquals(null, res[385].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 756));
+assertEquals(null, res[385].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 757));
+assertEquals(null, res[385].exec("\x09 \xa0\n\x0b\x0c", 758));
+assertEquals(null, res[385].exec("** Failers ", 759));
+assertEquals(null, res[385].exec("\x09 \xa0\n\x0b", 760));
+assertEquals(null, res[385].exec(" ", 761));
+assertEquals(null, res[386].exec("XY  ABCDE", 762));
+assertEquals(null, res[386].exec("XY  PQR ST ", 763));
+assertEquals(null, res[387].exec("XY  AB    PQRS", 764));
+assertEquals(null, res[388].exec(">XNNNYZ", 765));
+assertEquals(null, res[388].exec(">  X NYQZ", 766));
+assertEquals(null, res[388].exec("** Failers", 767));
+assertEquals(null, res[388].exec(">XYZ   ", 768));
+assertEquals(null, res[388].exec(">  X NY Z", 769));
+assertEquals(null, res[389].exec(">XY\nZ\nA\x0bNN\x0c", 770));
+assertEquals(null, res[389].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 771));
+assertEquals(null, res[390].exec(">\x09<", 772));
+assertEquals(null, res[391].exec(">\x09 \xa0<", 773));
+assertEquals(null, res[396].exec("** Failers", 774));
+assertEquals(null, res[396].exec("XXXX", 775));
+assertEquals(null, res[397].exec("XXXX Y ", 776));
+assertEquals(null, res[419].exec("aaaaaa", 777));
+assertEquals(null, res[419].exec("aaabccc", 778));
+assertEquals(null, res[419].exec("aaabccc", 779));
+assertEquals(null, res[419].exec("aaabccc", 780));
+assertEquals(null, res[419].exec("aaabcccaaabccc", 781));
+assertEquals(null, res[419].exec("aaaxxxxxx", 782));
+assertEquals(null, res[419].exec("aaa++++++ ", 783));
+assertEquals(null, res[419].exec("bbbxxxxx", 784));
+assertEquals(null, res[419].exec("bbb+++++ ", 785));
+assertEquals(null, res[419].exec("cccxxxx", 786));
+assertEquals(null, res[419].exec("ccc++++ ", 787));
+assertEquals(null, res[419].exec("dddddddd   ", 788));
+assertEquals(null, res[419].exec("aaaxxxxxx", 789));
+assertEquals(null, res[419].exec("aaa++++++ ", 790));
+assertEquals(null, res[419].exec("bbbxxxxx", 791));
+assertEquals(null, res[419].exec("bbb+++++ ", 792));
+assertEquals(null, res[419].exec("cccxxxx", 793));
+assertEquals(null, res[419].exec("ccc++++ ", 794));
+assertEquals(null, res[419].exec("dddddddd   ", 795));
+assertEquals(null, res[419].exec("aaabccc", 796));
+assertEquals(null, res[419].exec("ABX", 797));
+assertEquals(null, res[419].exec("AADE", 798));
+assertEquals(null, res[419].exec("ACDE", 799));
+assertEquals(null, res[419].exec("** Failers", 800));
+assertEquals(null, res[419].exec("AD ", 801));
+assertEquals(null, res[419].exec("    ", 802));
+assertEquals(null, res[419].exec("aaaaaa", 803));
+assertEquals(null, res[419].exec("aaabccc", 804));
+assertEquals(null, res[419].exec("aaabccc", 805));
+assertEquals(null, res[419].exec("aaabccc", 806));
+assertEquals(null, res[419].exec("aaabcccaaabccc", 807));
+assertEquals(null, res[419].exec("aaabccc", 808));
+assertEquals(null, res[422].exec("\x0d\nA", 809));
+assertEquals("\nA", res[423].exec("\x0d\nA "), 810);
+assertEquals("\nA", res[424].exec("\x0d\nA "), 811);
+assertEquals("\nA,\n", res[425].exec("\x0d\nA "), 812);
+assertEquals(null, res[425].exec("a\nb", 813));
+assertEquals(null, res[425].exec("** Failers", 814));
+assertEquals(null, res[425].exec("a\x0db  ", 815));
+assertEquals(null, res[425].exec("a\nb", 816));
+assertEquals(null, res[425].exec("** Failers", 817));
+assertEquals(null, res[425].exec("a\x0db  ", 818));
+assertEquals(null, res[425].exec("a\x0db", 819));
+assertEquals(null, res[425].exec("** Failers", 820));
+assertEquals(null, res[425].exec("a\nb  ", 821));
+assertEquals(null, res[425].exec("a\x0db", 822));
+assertEquals(null, res[425].exec("a\nb  ", 823));
+assertEquals(null, res[425].exec("** Failers", 824));
+assertEquals(null, res[425].exec("a\x0d\nb  ", 825));
+assertEquals(null, res[425].exec("** Failers", 826));
+assertEquals(null, res[425].exec("a\x0db", 827));
+assertEquals(null, res[425].exec("a\nb  ", 828));
+assertEquals(null, res[425].exec("a\x0d\nb  ", 829));
+assertEquals(null, res[425].exec("** Failers", 830));
+assertEquals(null, res[425].exec("a\x0db", 831));
+assertEquals(null, res[425].exec("a\nb  ", 832));
+assertEquals(null, res[425].exec("a\x0d\nb  ", 833));
+assertEquals(null, res[425].exec("a\x85b ", 834));
+assertEquals(null, res[426].exec("a\x0db", 835));
+assertEquals(null, res[426].exec("a\nb", 836));
+assertEquals(null, res[426].exec("a\x0d\nb", 837));
+assertEquals(null, res[426].exec("** Failers", 838));
+assertEquals(null, res[426].exec("a\x85b", 839));
+assertEquals(null, res[426].exec("a\x0bb     ", 840));
+assertEquals(null, res[427].exec("a\x0db", 841));
+assertEquals(null, res[427].exec("a\nb", 842));
+assertEquals(null, res[427].exec("a\x0d\nb", 843));
+assertEquals(null, res[427].exec("a\x85b", 844));
+assertEquals(null, res[427].exec("a\x0bb     ", 845));
+assertEquals(null, res[427].exec("** Failers ", 846));
+assertEquals(null, res[427].exec("a\x85b<bsr_anycrlf>", 847));
+assertEquals(null, res[427].exec("a\x0bb<bsr_anycrlf>", 848));
+assertEquals(null, res[428].exec("a\x0db", 849));
+assertEquals(null, res[428].exec("a\nb", 850));
+assertEquals(null, res[428].exec("a\x0d\nb", 851));
+assertEquals(null, res[428].exec("** Failers", 852));
+assertEquals(null, res[428].exec("a\x85b", 853));
+assertEquals(null, res[428].exec("a\x0bb     ", 854));
+assertEquals(null, res[429].exec("a\x0db", 855));
+assertEquals(null, res[429].exec("a\nb", 856));
+assertEquals(null, res[429].exec("a\x0d\nb", 857));
+assertEquals(null, res[429].exec("a\x85b", 858));
+assertEquals(null, res[429].exec("a\x0bb     ", 859));
+assertEquals(null, res[429].exec("** Failers ", 860));
+assertEquals(null, res[429].exec("a\x85b<bsr_anycrlf>", 861));
+assertEquals(null, res[429].exec("a\x0bb<bsr_anycrlf>", 862));
+assertEquals(null, res[430].exec("a\x0d\n\nb", 863));
+assertEquals(null, res[430].exec("a\n\x0d\x0db", 864));
+assertEquals(null, res[430].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 865));
+assertEquals(null, res[430].exec("** Failers", 866));
+assertEquals(null, res[430].exec("a\x8585b", 867));
+assertEquals(null, res[430].exec("a\x0b\x00bb     ", 868));
+assertEquals(null, res[431].exec("a\x0d\x0db", 869));
+assertEquals(null, res[431].exec("a\n\n\nb", 870));
+assertEquals(null, res[431].exec("a\x0d\n\n\x0d\x0db", 871));
+assertEquals(null, res[431].exec("a\x8585b", 872));
+assertEquals(null, res[431].exec("a\x0b\x00bb     ", 873));
+assertEquals(null, res[431].exec("** Failers ", 874));
+assertEquals(null, res[431].exec("a\x0d\x0d\x0d\x0d\x0db ", 875));
+assertEquals(null, res[431].exec("a\x8585b<bsr_anycrlf>", 876));
+assertEquals(null, res[431].exec("a\x0b\x00bb<bsr_anycrlf>", 877));
+assertEquals(null, res[431].exec("a\nb", 878));
+assertEquals(null, res[431].exec("a\x0db ", 879));
+assertEquals(null, res[431].exec("a\x85b", 880));
+assertEquals(null, res[431].exec("a\nb", 881));
+assertEquals(null, res[431].exec("a\x0db ", 882));
+assertEquals(null, res[431].exec("a\x85b", 883));
 assertThrows("var re = /(?-+a)/;", 884);
-assertNull(res[443].exec("aaaa", 885));
-assertNull(res[443].exec("bacxxx", 886));
-assertNull(res[443].exec("bbaccxxx ", 887));
-assertNull(res[443].exec("bbbacccxx", 888));
-assertNull(res[443].exec("aaaa", 889));
-assertNull(res[443].exec("bacxxx", 890));
-assertNull(res[443].exec("bbaccxxx ", 891));
-assertNull(res[443].exec("bbbacccxx", 892));
-assertToStringEquals("a,a", res[444].exec("aaaa"), 893);
-assertNull(res[444].exec("bacxxx", 894));
-assertNull(res[444].exec("bbaccxxx ", 895));
-assertNull(res[444].exec("bbbacccxx", 896));
-assertToStringEquals("a,a", res[445].exec("aaaa"), 897);
-assertNull(res[445].exec("bacxxx", 898));
-assertNull(res[445].exec("bbaccxxx ", 899));
-assertNull(res[445].exec("bbbacccxx", 900));
-assertToStringEquals("a,a", res[446].exec("aaaa"), 901);
-assertNull(res[446].exec("bacxxx", 902));
-assertNull(res[446].exec("bbaccxxx ", 903));
-assertNull(res[446].exec("bbbacccxx", 904));
-assertToStringEquals("a,a,a", res[447].exec("aaaa"), 905);
-assertNull(res[447].exec("bacxxx", 906));
-assertNull(res[447].exec("bbaccxxx ", 907));
-assertNull(res[447].exec("bbbacccxx", 908));
-assertNull(res[449].exec("bacxxx", 909));
-assertNull(res[449].exec("XaaX", 910));
-assertNull(res[449].exec("XAAX ", 911));
-assertNull(res[449].exec("XaaX", 912));
-assertNull(res[449].exec("** Failers ", 913));
-assertNull(res[449].exec("XAAX ", 914));
-assertNull(res[449].exec("XaaX", 915));
-assertNull(res[449].exec("XAAX ", 916));
-assertNull(res[449].exec("xzxx", 917));
-assertNull(res[449].exec("yzyy ", 918));
-assertNull(res[449].exec("** Failers", 919));
-assertNull(res[449].exec("xxz  ", 920));
-assertToStringEquals("a,,,a", res[450].exec("cat"), 921);
-assertToStringEquals("a,,,a", res[451].exec("cat"), 922);
-assertToStringEquals("TA]", res[452].exec("The ACTA] comes "), 923);
-assertToStringEquals("TA]", res[453].exec("The ACTA] comes "), 924);
-assertNull(res[453].exec("abcbabc", 925));
-assertNull(res[453].exec("abcbabc", 926));
-assertNull(res[453].exec("abcbabc", 927));
-assertNull(res[453].exec("** Failers ", 928));
-assertNull(res[453].exec("abcXabc", 929));
-assertNull(res[453].exec("abcXabc", 930));
-assertNull(res[453].exec("** Failers ", 931));
-assertNull(res[453].exec("abcbabc", 932));
-assertNull(res[453].exec("xyzbabcxyz", 933));
-assertNull(res[456].exec("** Failers", 934));
-assertNull(res[456].exec("ab", 935));
-assertNull(res[457].exec("** Failers", 936));
-assertNull(res[457].exec("ab ", 937));
-assertNull(res[457].exec("** Failers", 938));
-assertNull(res[457].exec("ab ", 939));
-assertToStringEquals("aXb", res[458].exec("aXb"), 940);
-assertToStringEquals("a\nb", res[458].exec("a\nb "), 941);
-assertNull(res[458].exec("** Failers", 942));
-assertNull(res[458].exec("ab  ", 943));
-assertToStringEquals("aXb", res[459].exec("aXb"), 944);
-assertToStringEquals("a\nX\nXb", res[459].exec("a\nX\nXb "), 945);
-assertNull(res[459].exec("** Failers", 946));
-assertNull(res[459].exec("ab  ", 947));
-assertToStringEquals("acb", res[463].exec("acb"), 948);
-assertToStringEquals("ab", res[463].exec("ab"), 949);
-assertNull(res[463].exec("ax{100}b ", 950));
-assertNull(res[463].exec("*** Failers", 951));
-assertNull(res[463].exec("a\nb  ", 952));
-assertNull(res[464].exec("ax{4000}xyb ", 953));
-assertNull(res[464].exec("ax{4000}yb ", 954));
-assertNull(res[464].exec("ax{4000}x{100}yb ", 955));
-assertNull(res[464].exec("*** Failers", 956));
-assertNull(res[464].exec("ax{4000}b ", 957));
-assertNull(res[464].exec("ac\ncb ", 958));
-assertToStringEquals("a\xc0,,\xc0", res[465].exec("a\xc0\x88b"), 959);
-assertToStringEquals("ax,,x", res[466].exec("ax{100}b"), 960);
-assertToStringEquals("a\xc0\x88b,\xc0\x88,b", res[467].exec("a\xc0\x88b"), 961);
-assertToStringEquals("ax{100}b,x{100},b", res[468].exec("ax{100}b"), 962);
-assertToStringEquals("a\xc0\x92,\xc0,\x92", res[469].exec("a\xc0\x92bcd"), 963);
-assertToStringEquals("ax{,x,{", res[470].exec("ax{240}bcd"), 964);
-assertToStringEquals("a\xc0\x92,\xc0,\x92", res[471].exec("a\xc0\x92bcd"), 965);
-assertToStringEquals("ax{,x,{", res[472].exec("ax{240}bcd"), 966);
-assertToStringEquals("a\xc0,,\xc0", res[473].exec("a\xc0\x92bcd"), 967);
-assertToStringEquals("ax,,x", res[474].exec("ax{240}bcd"), 968);
-assertNull(res[475].exec("ax{1234}xyb ", 969));
-assertNull(res[475].exec("ax{1234}x{4321}yb ", 970));
-assertNull(res[475].exec("ax{1234}x{4321}x{3412}b ", 971));
-assertNull(res[475].exec("*** Failers", 972));
-assertNull(res[475].exec("ax{1234}b ", 973));
-assertNull(res[475].exec("ac\ncb ", 974));
-assertToStringEquals("ax{1234}xyb,x{1234}xy", res[476].exec("ax{1234}xyb "), 975);
-assertToStringEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[476].exec("ax{1234}x{4321}yb "), 976);
-assertToStringEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[476].exec("ax{1234}x{4321}x{3412}b "), 977);
-assertToStringEquals("axxxxbcdefghijb,xxxxbcdefghij", res[476].exec("axxxxbcdefghijb "), 978);
-assertToStringEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[476].exec("ax{1234}x{4321}x{3412}x{3421}b "), 979);
-assertNull(res[476].exec("*** Failers", 980));
-assertToStringEquals("ax{1234}b,x{1234}", res[476].exec("ax{1234}b "), 981);
-assertToStringEquals("ax{1234}xyb,x{1234}xy", res[477].exec("ax{1234}xyb "), 982);
-assertToStringEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[477].exec("ax{1234}x{4321}yb "), 983);
-assertToStringEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[477].exec("ax{1234}x{4321}x{3412}b "), 984);
-assertToStringEquals("axxxxb,xxxx", res[477].exec("axxxxbcdefghijb "), 985);
-assertToStringEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[477].exec("ax{1234}x{4321}x{3412}x{3421}b "), 986);
-assertNull(res[477].exec("*** Failers", 987));
-assertToStringEquals("ax{1234}b,x{1234}", res[477].exec("ax{1234}b "), 988);
-assertNull(res[478].exec("ax{1234}xyb ", 989));
-assertNull(res[478].exec("ax{1234}x{4321}yb ", 990));
-assertNull(res[478].exec("ax{1234}x{4321}x{3412}b ", 991));
-assertToStringEquals("axxxxb,xxxx", res[478].exec("axxxxbcdefghijb "), 992);
-assertNull(res[478].exec("ax{1234}x{4321}x{3412}x{3421}b ", 993));
-assertToStringEquals("axbxxb,xbxx", res[478].exec("axbxxbcdefghijb "), 994);
-assertToStringEquals("axxxxxb,xxxxx", res[478].exec("axxxxxbcdefghijb "), 995);
-assertNull(res[478].exec("*** Failers", 996));
-assertNull(res[478].exec("ax{1234}b ", 997));
-assertNull(res[478].exec("axxxxxxbcdefghijb ", 998));
-assertNull(res[479].exec("ax{1234}xyb ", 999));
-assertNull(res[479].exec("ax{1234}x{4321}yb ", 1000));
-assertNull(res[479].exec("ax{1234}x{4321}x{3412}b ", 1001));
-assertToStringEquals("axxxxb,xxxx", res[479].exec("axxxxbcdefghijb "), 1002);
-assertNull(res[479].exec("ax{1234}x{4321}x{3412}x{3421}b ", 1003));
-assertToStringEquals("axbxxb,xbxx", res[479].exec("axbxxbcdefghijb "), 1004);
-assertToStringEquals("axxxxxb,xxxxx", res[479].exec("axxxxxbcdefghijb "), 1005);
-assertNull(res[479].exec("*** Failers", 1006));
-assertNull(res[479].exec("ax{1234}b ", 1007));
-assertNull(res[479].exec("axxxxxxbcdefghijb ", 1008));
-assertNull(res[479].exec("*** Failers", 1009));
-assertNull(res[479].exec("x{100}", 1010));
-assertNull(res[479].exec("aXbcd", 1011));
-assertNull(res[479].exec("ax{100}bcd", 1012));
-assertNull(res[479].exec("ax{100000}bcd", 1013));
-assertNull(res[479].exec("x{100}x{100}x{100}b", 1014));
-assertNull(res[479].exec("*** Failers ", 1015));
-assertNull(res[479].exec("x{100}x{100}b", 1016));
-assertNull(res[479].exec("x{ab} ", 1017));
-assertNull(res[479].exec("\xc2\xab", 1018));
-assertNull(res[479].exec("*** Failers ", 1019));
-assertNull(res[479].exec("\x00{ab}", 1020));
-assertNull(res[479].exec("WXYZ", 1021));
-assertNull(res[479].exec("x{256}XYZ ", 1022));
-assertNull(res[479].exec("*** Failers", 1023));
-assertNull(res[479].exec("XYZ ", 1024));
-assertNull(res[480].exec("Xx{1234}", 1025));
-assertNull(res[481].exec("Xx{1234}YZ", 1026));
-assertToStringEquals("X", res[482].exec("XYZabcdce"), 1027);
-assertToStringEquals("X", res[483].exec("XYZabcde"), 1028);
-assertNull(res[484].exec("Xabcdefg   ", 1029));
-assertNull(res[484].exec("Xx{1234} ", 1030));
-assertNull(res[484].exec("Xx{1234}YZ", 1031));
-assertNull(res[484].exec("Xx{1234}x{512}  ", 1032));
-assertNull(res[484].exec("Xx{1234}x{512}YZ", 1033));
-assertNull(res[485].exec("Xabcdefg   ", 1034));
-assertNull(res[485].exec("Xx{1234} ", 1035));
-assertNull(res[485].exec("Xx{1234}YZ", 1036));
-assertNull(res[485].exec("Xx{1234}x{512}  ", 1037));
-assertToStringEquals("bcd", res[486].exec("bcd"), 1038);
-assertToStringEquals("00}", res[486].exec("x{100}aYx{256}Z "), 1039);
-assertToStringEquals("x{", res[487].exec("x{100}bc"), 1040);
-assertToStringEquals("x{100}bcA", res[488].exec("x{100}bcAa"), 1041);
-assertToStringEquals("x{", res[489].exec("x{100}bca"), 1042);
-assertToStringEquals("bcd", res[490].exec("bcd"), 1043);
-assertToStringEquals("00}", res[490].exec("x{100}aYx{256}Z "), 1044);
-assertToStringEquals("x{", res[491].exec("x{100}bc"), 1045);
-assertToStringEquals("x{100}bc", res[492].exec("x{100}bcAa"), 1046);
-assertToStringEquals("x{", res[493].exec("x{100}bca"), 1047);
-assertNull(res[493].exec("abcd", 1048));
-assertNull(res[493].exec("abcd", 1049));
-assertToStringEquals("x{", res[493].exec("x{100}x{100} "), 1050);
-assertToStringEquals("x{", res[493].exec("x{100}x{100} "), 1051);
-assertToStringEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1052);
-assertNull(res[493].exec("abce", 1053));
-assertToStringEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1054);
-assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1055));
-assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1056));
-assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1057));
-assertNull(res[493].exec("abcdx{100}x{100}x{100}XX", 1058));
-assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1059));
-assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1060));
-assertToStringEquals("Xy", res[493].exec("Xyyyax{100}x{100}bXzzz"), 1061);
-assertToStringEquals("X", res[496].exec("1X2"), 1062);
-assertToStringEquals("x", res[496].exec("1x{100}2 "), 1063);
-assertToStringEquals(">X", res[497].exec("> >X Y"), 1064);
-assertToStringEquals(">x", res[497].exec("> >x{100} Y"), 1065);
-assertToStringEquals("1", res[498].exec("x{100}3"), 1066);
-assertToStringEquals(" ", res[499].exec("x{100} X"), 1067);
-assertToStringEquals("abcd", res[500].exec("12abcd34"), 1068);
-assertToStringEquals("*** Failers", res[500].exec("*** Failers"), 1069);
-assertToStringEquals("  ", res[500].exec("1234  "), 1070);
-assertToStringEquals("abc", res[501].exec("12abcd34"), 1071);
-assertToStringEquals("ab", res[501].exec("12ab34"), 1072);
-assertToStringEquals("***", res[501].exec("*** Failers  "), 1073);
-assertNull(res[501].exec("1234", 1074));
-assertToStringEquals("  ", res[501].exec("12a34  "), 1075);
-assertToStringEquals("ab", res[502].exec("12abcd34"), 1076);
-assertToStringEquals("ab", res[502].exec("12ab34"), 1077);
-assertToStringEquals("**", res[502].exec("*** Failers  "), 1078);
-assertNull(res[502].exec("1234", 1079));
-assertToStringEquals("  ", res[502].exec("12a34  "), 1080);
-assertToStringEquals("12", res[503].exec("12abcd34"), 1081);
-assertNull(res[503].exec("*** Failers", 1082));
-assertToStringEquals("12", res[504].exec("12abcd34"), 1083);
-assertToStringEquals("123", res[504].exec("1234abcd"), 1084);
-assertNull(res[504].exec("*** Failers  ", 1085));
-assertNull(res[504].exec("1.4 ", 1086));
-assertToStringEquals("12", res[505].exec("12abcd34"), 1087);
-assertToStringEquals("12", res[505].exec("1234abcd"), 1088);
-assertNull(res[505].exec("*** Failers  ", 1089));
-assertNull(res[505].exec("1.4 ", 1090));
-assertToStringEquals("12abcd34", res[506].exec("12abcd34"), 1091);
-assertToStringEquals("***", res[506].exec("*** Failers"), 1092);
-assertNull(res[506].exec("     ", 1093));
-assertToStringEquals("12a", res[507].exec("12abcd34"), 1094);
-assertToStringEquals("123", res[507].exec("1234abcd"), 1095);
-assertToStringEquals("***", res[507].exec("*** Failers"), 1096);
-assertNull(res[507].exec("       ", 1097));
-assertToStringEquals("12", res[508].exec("12abcd34"), 1098);
-assertToStringEquals("12", res[508].exec("1234abcd"), 1099);
-assertToStringEquals("**", res[508].exec("*** Failers"), 1100);
-assertNull(res[508].exec("       ", 1101));
-assertToStringEquals(">      <", res[509].exec("12>      <34"), 1102);
-assertNull(res[509].exec("*** Failers", 1103));
-assertToStringEquals(">  <", res[510].exec("ab>  <cd"), 1104);
-assertToStringEquals(">   <", res[510].exec("ab>   <ce"), 1105);
-assertNull(res[510].exec("*** Failers", 1106));
-assertNull(res[510].exec("ab>    <cd ", 1107));
-assertToStringEquals(">  <", res[511].exec("ab>  <cd"), 1108);
-assertToStringEquals(">   <", res[511].exec("ab>   <ce"), 1109);
-assertNull(res[511].exec("*** Failers", 1110));
-assertNull(res[511].exec("ab>    <cd ", 1111));
-assertToStringEquals("12", res[512].exec("12      34"), 1112);
-assertToStringEquals("Failers", res[512].exec("*** Failers"), 1113);
-assertNull(res[512].exec("+++=*! ", 1114));
-assertToStringEquals("ab", res[513].exec("ab  cd"), 1115);
-assertToStringEquals("abc", res[513].exec("abcd ce"), 1116);
-assertToStringEquals("Fai", res[513].exec("*** Failers"), 1117);
-assertNull(res[513].exec("a.b.c", 1118));
-assertToStringEquals("ab", res[514].exec("ab  cd"), 1119);
-assertToStringEquals("ab", res[514].exec("abcd ce"), 1120);
-assertToStringEquals("Fa", res[514].exec("*** Failers"), 1121);
-assertNull(res[514].exec("a.b.c", 1122));
-assertToStringEquals("====", res[515].exec("12====34"), 1123);
-assertToStringEquals("*** ", res[515].exec("*** Failers"), 1124);
-assertToStringEquals(" ", res[515].exec("abcd "), 1125);
-assertToStringEquals("===", res[516].exec("ab====cd"), 1126);
-assertToStringEquals("==", res[516].exec("ab==cd"), 1127);
-assertToStringEquals("***", res[516].exec("*** Failers"), 1128);
-assertNull(res[516].exec("a.b.c", 1129));
-assertToStringEquals("==", res[517].exec("ab====cd"), 1130);
-assertToStringEquals("==", res[517].exec("ab==cd"), 1131);
-assertToStringEquals("**", res[517].exec("*** Failers"), 1132);
-assertNull(res[517].exec("a.b.c", 1133));
-assertNull(res[517].exec("x{100}", 1134));
-assertNull(res[517].exec("Zx{100}", 1135));
-assertNull(res[517].exec("x{100}Z", 1136));
-assertToStringEquals("**", res[517].exec("*** Failers "), 1137);
-assertNull(res[517].exec("Zx{100}", 1138));
-assertNull(res[517].exec("x{100}", 1139));
-assertNull(res[517].exec("x{100}Z", 1140));
-assertToStringEquals("**", res[517].exec("*** Failers "), 1141);
-assertNull(res[517].exec("abcx{200}X", 1142));
-assertNull(res[517].exec("abcx{100}X ", 1143));
-assertToStringEquals("**", res[517].exec("*** Failers"), 1144);
-assertToStringEquals("  ", res[517].exec("X  "), 1145);
-assertNull(res[517].exec("abcx{200}X", 1146));
-assertNull(res[517].exec("abcx{100}X ", 1147));
-assertNull(res[517].exec("abQX ", 1148));
-assertToStringEquals("**", res[517].exec("*** Failers"), 1149);
-assertToStringEquals("  ", res[517].exec("X  "), 1150);
-assertNull(res[517].exec("abcx{100}x{200}x{100}X", 1151));
-assertToStringEquals("**", res[517].exec("*** Failers"), 1152);
-assertNull(res[517].exec("abcx{200}X", 1153));
-assertToStringEquals("  ", res[517].exec("X  "), 1154);
-assertNull(res[517].exec("AX", 1155));
-assertNull(res[517].exec("x{150}X", 1156));
-assertNull(res[517].exec("x{500}X ", 1157));
-assertToStringEquals("**", res[517].exec("*** Failers"), 1158);
-assertNull(res[517].exec("x{100}X", 1159));
-assertToStringEquals("  ", res[517].exec("x{200}X   "), 1160);
-assertNull(res[517].exec("AX", 1161));
-assertNull(res[517].exec("x{150}X", 1162));
-assertNull(res[517].exec("x{500}X ", 1163));
-assertToStringEquals("**", res[517].exec("*** Failers"), 1164);
-assertNull(res[517].exec("x{100}X", 1165));
-assertToStringEquals("  ", res[517].exec("x{200}X   "), 1166);
-assertNull(res[517].exec("QX ", 1167));
-assertNull(res[517].exec("AX", 1168));
-assertNull(res[517].exec("x{500}X ", 1169));
-assertToStringEquals("**", res[517].exec("*** Failers"), 1170);
-assertNull(res[517].exec("x{100}X", 1171));
-assertNull(res[517].exec("x{150}X", 1172));
-assertToStringEquals("  ", res[517].exec("x{200}X   "), 1173);
-assertNull(res[518].exec("aXb", 1174));
-assertNull(res[518].exec("a\nb", 1175));
-assertNull(res[519].exec("aXb", 1176));
-assertNull(res[519].exec("a\nb", 1177));
-assertNull(res[519].exec("*** Failers ", 1178));
-assertNull(res[519].exec("ax{100}b ", 1179));
-assertNull(res[519].exec("z", 1180));
-assertNull(res[519].exec("Z ", 1181));
-assertNull(res[519].exec("x{100}", 1182));
-assertNull(res[519].exec("*** Failers", 1183));
-assertNull(res[519].exec("x{102}", 1184));
-assertNull(res[519].exec("y    ", 1185));
-assertToStringEquals("\xff", res[520].exec(">\xff<"), 1186);
-assertNull(res[521].exec(">x{ff}<", 1187));
-assertToStringEquals("X", res[522].exec("XYZ"), 1188);
-assertToStringEquals("X", res[523].exec("XYZ"), 1189);
-assertToStringEquals("x", res[523].exec("x{123} "), 1190);
-assertToStringEquals(",", res[528].exec("catac"), 1191);
-assertToStringEquals(",", res[528].exec("ax{256}a "), 1192);
-assertToStringEquals(",", res[528].exec("x{85}"), 1193);
-assertToStringEquals(",", res[528].exec("\u1234 "), 1194);
-assertToStringEquals(",", res[528].exec("\u1234 "), 1195);
-assertToStringEquals(",", res[528].exec("abcdefg"), 1196);
-assertToStringEquals(",", res[528].exec("ab"), 1197);
-assertToStringEquals(",", res[528].exec("a "), 1198);
-assertToStringEquals("Ax", res[529].exec("Ax{a3}BC"), 1199);
-assertToStringEquals("Ax", res[530].exec("Ax{a3}BC"), 1200);
-assertToStringEquals("}=", res[531].exec("+x{a3}== "), 1201);
-assertToStringEquals("}=", res[532].exec("+x{a3}== "), 1202);
-assertToStringEquals("x", res[533].exec("x{442}x{435}x{441}x{442}"), 1203);
-assertToStringEquals("x", res[534].exec("x{442}x{435}x{441}x{442}"), 1204);
-assertToStringEquals("x", res[535].exec("x{442}x{435}x{441}x{442}"), 1205);
-assertToStringEquals("x", res[536].exec("x{442}x{435}x{441}x{442}"), 1206);
-assertToStringEquals("{", res[537].exec("x{2442}x{2435}x{2441}x{2442}"), 1207);
-assertToStringEquals("{", res[538].exec("x{2442}x{2435}x{2441}x{2442}"), 1208);
-assertToStringEquals("abc\n\x0dx{442}x{435}x{441}x{442}xyz ", res[539].exec("abc\n\x0dx{442}x{435}x{441}x{442}xyz "), 1209);
-assertToStringEquals("x{442}x{435}x{441}x{442}", res[539].exec("x{442}x{435}x{441}x{442}"), 1210);
-assertToStringEquals("c d", res[540].exec("abc defx{442}x{443}xyz\npqr"), 1211);
-assertToStringEquals("c d", res[541].exec("abc defx{442}x{443}xyz\npqr"), 1212);
-assertNull(res[542].exec("+x{2442}", 1213));
-assertNull(res[543].exec("+x{2442}", 1214));
-assertNull(res[544].exec("Ax{442}", 1215));
-assertNull(res[545].exec("Ax{442}", 1216));
-assertNull(res[546].exec("Ax{442}", 1217));
-assertNull(res[547].exec("Ax{442}", 1218));
-assertNull(res[548].exec("\x19x{e01ff}", 1219));
-assertNull(res[549].exec("Ax{422}", 1220));
-assertNull(res[550].exec("x{19}x{e01ff}", 1221));
-assertNull(res[551].exec("Ax{442}", 1222));
-assertNull(res[552].exec("Ax{442}", 1223));
-assertNull(res[553].exec("ax{442}", 1224));
-assertNull(res[554].exec("+x{2442}", 1225));
-assertNull(res[555].exec("Mx{442}", 1226));
-assertToStringEquals("abc", res[556].exec("abc"), 1227);
-assertToStringEquals("abc", res[557].exec("abc"), 1228);
-assertToStringEquals("abc", res[558].exec("abc"), 1229);
-assertToStringEquals("abc", res[559].exec("abc"), 1230);
-assertNull(res[560].exec("x{100}ax{1234}bcd", 1231));
-assertNull(res[562].exec("x{0041}x{2262}x{0391}x{002e}", 1232));
-assertNull(res[562].exec("x{D55c}x{ad6d}x{C5B4} ", 1233));
-assertNull(res[562].exec("x{65e5}x{672c}x{8a9e}", 1234));
-assertToStringEquals("{861}X", res[563].exec("x{212ab}x{212ab}x{212ab}x{861}X"), 1235);
-assertToStringEquals("x{2", res[564].exec("x{212ab}x{212ab}x{212ab}x{861}"), 1236);
-assertToStringEquals("x{c", res[564].exec("x{c0}b"), 1237);
-assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1238);
-assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1239);
-assertToStringEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1240);
-assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1241);
-assertToStringEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1242);
-assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1243);
-assertToStringEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1244);
-assertToStringEquals("Sho", res[564].exec("Should produce an error diagnostic"), 1245);
-assertNull(res[565].exec("Xx{1234}", 1246));
-assertNull(res[565].exec("X\nabc ", 1247));
-assertToStringEquals("b", res[566].exec("bar"), 1248);
-assertNull(res[566].exec("*** Failers", 1249));
-assertNull(res[566].exec("c", 1250));
-assertNull(res[566].exec("x{ff}", 1251));
-assertNull(res[566].exec("x{100}  ", 1252));
-assertToStringEquals("c", res[567].exec("c"), 1253);
-assertToStringEquals("x", res[567].exec("x{ff}"), 1254);
-assertToStringEquals("x", res[567].exec("x{100}  "), 1255);
-assertToStringEquals("*", res[567].exec("*** Failers "), 1256);
-assertNull(res[567].exec("aaa", 1257));
-assertToStringEquals("x", res[568].exec("x{f1}"), 1258);
-assertToStringEquals("x", res[568].exec("x{bf}"), 1259);
-assertToStringEquals("x", res[568].exec("x{100}"), 1260);
-assertToStringEquals("x", res[568].exec("x{1000}   "), 1261);
-assertToStringEquals("*", res[568].exec("*** Failers"), 1262);
-assertToStringEquals("x", res[568].exec("x{c0} "), 1263);
-assertToStringEquals("x", res[568].exec("x{f0} "), 1264);
-assertToStringEquals("1", res[568].exec("1234"), 1265);
-assertToStringEquals("\"", res[568].exec("\"1234\" "), 1266);
-assertToStringEquals("x", res[568].exec("x{100}1234"), 1267);
-assertToStringEquals("\"", res[568].exec("\"x{100}1234\"  "), 1268);
-assertToStringEquals("x", res[568].exec("x{100}x{100}12ab "), 1269);
-assertToStringEquals("x", res[568].exec("x{100}x{100}\"12\" "), 1270);
-assertToStringEquals("*", res[568].exec("*** Failers "), 1271);
-assertToStringEquals("x", res[568].exec("x{100}x{100}abcd"), 1272);
-assertToStringEquals("A", res[568].exec("A"), 1273);
-assertToStringEquals("x", res[568].exec("x{100}"), 1274);
-assertToStringEquals("Z", res[568].exec("Zx{100}"), 1275);
-assertToStringEquals("x", res[568].exec("x{100}Z"), 1276);
-assertToStringEquals("*", res[568].exec("*** Failers "), 1277);
-assertToStringEquals("Z", res[568].exec("Zx{100}"), 1278);
-assertToStringEquals("x", res[568].exec("x{100}"), 1279);
-assertToStringEquals("x", res[568].exec("x{100}Z"), 1280);
-assertToStringEquals("*", res[568].exec("*** Failers "), 1281);
-assertToStringEquals("x", res[568].exec("x{100}"), 1282);
-assertToStringEquals("x", res[568].exec("x{104}"), 1283);
-assertToStringEquals("*", res[568].exec("*** Failers"), 1284);
-assertToStringEquals("x", res[568].exec("x{105}"), 1285);
-assertToStringEquals("x", res[568].exec("x{ff}    "), 1286);
-assertToStringEquals("x", res[568].exec("x{100}"), 1287);
-assertToStringEquals("\u0100", res[568].exec("\u0100 "), 1288);
-assertToStringEquals("\xff", res[569].exec(">\xff<"), 1289);
-assertNull(res[570].exec(">x{ff}<", 1290));
-assertToStringEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1291);
-assertToStringEquals("x", res[572].exec("x{d6}"), 1292);
-assertToStringEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1293);
-assertToStringEquals("x", res[572].exec("x{d6}"), 1294);
-assertToStringEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1295);
-assertToStringEquals("x", res[572].exec("x{d6} "), 1296);
-assertToStringEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1297);
-assertToStringEquals("x", res[572].exec("x{d6} "), 1298);
-assertToStringEquals("\ufffd", res[572].exec("\ufffd]"), 1299);
-assertToStringEquals("\ufffd", res[572].exec("\ufffd"), 1300);
-assertToStringEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd"), 1301);
-assertToStringEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd?"), 1302);
-assertNull(res[573].exec("\xc0\x80", 1303));
-assertNull(res[573].exec("\xc1\x8f ", 1304));
-assertNull(res[573].exec("\xe0\x9f\x80", 1305));
-assertNull(res[573].exec("\xf0\x8f\x80\x80 ", 1306));
-assertNull(res[573].exec("\xf8\x87\x80\x80\x80  ", 1307));
-assertNull(res[573].exec("\xfc\x83\x80\x80\x80\x80", 1308));
-assertNull(res[573].exec("\xfe\x80\x80\x80\x80\x80  ", 1309));
-assertNull(res[573].exec("\xff\x80\x80\x80\x80\x80  ", 1310));
-assertNull(res[573].exec("\xc3\x8f", 1311));
-assertNull(res[573].exec("\xe0\xaf\x80", 1312));
-assertNull(res[573].exec("\xe1\x80\x80", 1313));
-assertNull(res[573].exec("\xf0\x9f\x80\x80 ", 1314));
-assertNull(res[573].exec("\xf1\x8f\x80\x80 ", 1315));
-assertNull(res[573].exec("\xf8\x88\x80\x80\x80  ", 1316));
-assertNull(res[573].exec("\xf9\x87\x80\x80\x80  ", 1317));
-assertNull(res[573].exec("\xfc\x84\x80\x80\x80\x80", 1318));
-assertNull(res[573].exec("\xfd\x83\x80\x80\x80\x80", 1319));
-assertNull(res[573].exec("?\xf8\x88\x80\x80\x80  ", 1320));
-assertNull(res[573].exec("?\xf9\x87\x80\x80\x80  ", 1321));
-assertNull(res[573].exec("?\xfc\x84\x80\x80\x80\x80", 1322));
-assertNull(res[573].exec("?\xfd\x83\x80\x80\x80\x80", 1323));
-assertToStringEquals(".", res[574].exec("A.B"), 1324);
-assertToStringEquals("{", res[574].exec("Ax{100}B "), 1325);
-assertToStringEquals("x", res[575].exec("x{100}X   "), 1326);
-assertToStringEquals("a", res[575].exec("ax{1234}b"), 1327);
-assertNull(res[577].exec("AxxB     ", 1328));
-assertToStringEquals("abc1", res[578].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 1329);
-assertToStringEquals("abc1", res[579].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 1330);
-assertNull(res[580].exec("a\nb", 1331));
-assertNull(res[580].exec("a\x0db", 1332));
-assertNull(res[580].exec("a\x0d\nb", 1333));
-assertNull(res[580].exec("a\x0bb", 1334));
-assertNull(res[580].exec("a\x0cb", 1335));
-assertNull(res[580].exec("ax{85}b   ", 1336));
-assertNull(res[580].exec("ax{2028}b ", 1337));
-assertNull(res[580].exec("ax{2029}b ", 1338));
-assertNull(res[580].exec("** Failers", 1339));
-assertNull(res[580].exec("a\n\x0db    ", 1340));
-assertToStringEquals("ab", res[581].exec("ab"), 1341);
-assertNull(res[581].exec("a\nb", 1342));
-assertNull(res[581].exec("a\x0db", 1343));
-assertNull(res[581].exec("a\x0d\nb", 1344));
-assertNull(res[581].exec("a\x0bb", 1345));
-assertNull(res[581].exec("a\x0cx{2028}x{2029}b", 1346));
-assertNull(res[581].exec("ax{85}b   ", 1347));
-assertNull(res[581].exec("a\n\x0db    ", 1348));
-assertNull(res[581].exec("a\n\x0dx{85}\x0cb ", 1349));
-assertNull(res[582].exec("a\nb", 1350));
-assertNull(res[582].exec("a\x0db", 1351));
-assertNull(res[582].exec("a\x0d\nb", 1352));
-assertNull(res[582].exec("a\x0bb", 1353));
-assertNull(res[582].exec("a\x0cx{2028}x{2029}b", 1354));
-assertNull(res[582].exec("ax{85}b   ", 1355));
-assertNull(res[582].exec("a\n\x0db    ", 1356));
-assertNull(res[582].exec("a\n\x0dx{85}\x0cb ", 1357));
-assertNull(res[582].exec("** Failers", 1358));
-assertNull(res[582].exec("ab  ", 1359));
-assertNull(res[583].exec("a\nb", 1360));
-assertNull(res[583].exec("a\n\x0db", 1361));
-assertNull(res[583].exec("a\n\x0dx{85}b", 1362));
-assertNull(res[583].exec("a\x0d\n\x0d\nb ", 1363));
-assertNull(res[583].exec("a\x0d\n\x0d\n\x0d\nb ", 1364));
-assertNull(res[583].exec("a\n\x0d\n\x0db", 1365));
-assertNull(res[583].exec("a\n\n\x0d\nb ", 1366));
-assertNull(res[583].exec("** Failers", 1367));
-assertNull(res[583].exec("a\n\n\n\x0db", 1368));
-assertNull(res[583].exec("a\x0d", 1369));
-assertNull(res[584].exec("X X\n", 1370));
-assertNull(res[584].exec("X\x09X\x0b", 1371));
-assertNull(res[584].exec("** Failers", 1372));
-assertNull(res[584].exec("x{a0} X\n   ", 1373));
-assertNull(res[585].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 1374));
-assertNull(res[585].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 1375));
-assertNull(res[585].exec("\x09 x{a0}\n\x0b\x0c", 1376));
-assertNull(res[585].exec("** Failers ", 1377));
-assertNull(res[585].exec("\x09 x{a0}\n\x0b", 1378));
-assertNull(res[585].exec(" ", 1379));
-assertNull(res[586].exec("x{3001}x{3000}x{2030}x{2028}", 1380));
-assertNull(res[586].exec("Xx{180e}Xx{85}", 1381));
-assertNull(res[586].exec("** Failers", 1382));
-assertNull(res[586].exec("x{2009} X\n   ", 1383));
-assertNull(res[587].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 1384));
-assertNull(res[587].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 1385));
-assertNull(res[587].exec("\x09 x{202f}\n\x0b\x0c", 1386));
-assertNull(res[587].exec("** Failers ", 1387));
-assertNull(res[587].exec("\x09x{200a}x{a0}x{2028}\x0b", 1388));
-assertNull(res[587].exec(" ", 1389));
-assertNull(res[588].exec(">x{1680}", 1390));
-assertNull(res[589].exec(">x{1680}x{180e}x{2000}x{2003}x{200a}x{202f}x{205f}x{3000}<", 1391));
-assertToStringEquals("x{1ec5} ", res[593].exec("x{1ec5} "), 1392);
-assertNull(res[594].exec("x{0}x{d7ff}x{e000}x{10ffff}", 1393));
-assertNull(res[594].exec("x{d800}", 1394));
-assertNull(res[594].exec("x{d800}?", 1395));
-assertNull(res[594].exec("x{da00}", 1396));
-assertNull(res[594].exec("x{da00}?", 1397));
-assertNull(res[594].exec("x{dfff}", 1398));
-assertNull(res[594].exec("x{dfff}?", 1399));
-assertNull(res[594].exec("x{110000}    ", 1400));
-assertNull(res[594].exec("x{110000}?    ", 1401));
-assertNull(res[594].exec("x{2000000} ", 1402));
-assertNull(res[594].exec("x{2000000}? ", 1403));
-assertNull(res[594].exec("x{7fffffff} ", 1404));
-assertNull(res[594].exec("x{7fffffff}? ", 1405));
-assertNull(res[595].exec("a\x0db", 1406));
-assertNull(res[595].exec("a\nb", 1407));
-assertNull(res[595].exec("a\x0d\nb", 1408));
-assertNull(res[595].exec("** Failers", 1409));
-assertNull(res[595].exec("ax{85}b", 1410));
-assertNull(res[595].exec("a\x0bb     ", 1411));
-assertNull(res[596].exec("a\x0db", 1412));
-assertNull(res[596].exec("a\nb", 1413));
-assertNull(res[596].exec("a\x0d\nb", 1414));
-assertNull(res[596].exec("ax{85}b", 1415));
-assertNull(res[596].exec("a\x0bb     ", 1416));
-assertNull(res[596].exec("** Failers ", 1417));
-assertNull(res[596].exec("ax{85}b<bsr_anycrlf>", 1418));
-assertNull(res[596].exec("a\x0bb<bsr_anycrlf>", 1419));
-assertNull(res[597].exec("a\x0db", 1420));
-assertNull(res[597].exec("a\nb", 1421));
-assertNull(res[597].exec("a\x0d\nb", 1422));
-assertNull(res[597].exec("** Failers", 1423));
-assertNull(res[597].exec("ax{85}b", 1424));
-assertNull(res[597].exec("a\x0bb     ", 1425));
-assertNull(res[598].exec("a\x0db", 1426));
-assertNull(res[598].exec("a\nb", 1427));
-assertNull(res[598].exec("a\x0d\nb", 1428));
-assertNull(res[598].exec("ax{85}b", 1429));
-assertNull(res[598].exec("a\x0bb     ", 1430));
-assertNull(res[598].exec("** Failers ", 1431));
-assertNull(res[598].exec("ax{85}b<bsr_anycrlf>", 1432));
-assertNull(res[598].exec("a\x0bb<bsr_anycrlf>", 1433));
-assertToStringEquals("QQQx{2029}ABCaXYZ=!bPQR", res[599].exec("QQQx{2029}ABCaXYZ=!bPQR"), 1434);
-assertNull(res[599].exec("** Failers", 1435));
-assertNull(res[599].exec("ax{2029}b", 1436));
-assertNull(res[599].exec("a\xe2\x80\xa9b ", 1437));
-assertNull(res[600].exec("ax{1234}b", 1438));
-assertToStringEquals("a\nb", res[600].exec("a\nb "), 1439);
-assertNull(res[600].exec("** Failers", 1440));
-assertNull(res[600].exec("ab  ", 1441));
-assertToStringEquals("aXb", res[601].exec("aXb"), 1442);
-assertToStringEquals("a\nX\nXx{1234}b", res[601].exec("a\nX\nXx{1234}b "), 1443);
-assertNull(res[601].exec("** Failers", 1444));
-assertNull(res[601].exec("ab  ", 1445));
-assertNull(res[601].exec("x{de}x{de}", 1446));
-assertNull(res[601].exec("x{123} ", 1447));
-assertToStringEquals("X", res[602].exec("Ax{1ec5}ABCXYZ"), 1448);
-assertNull(res[604].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 1449));
-assertNull(res[604].exec("\npx{300}9!$ < ", 1450));
-assertNull(res[604].exec("** Failers ", 1451));
-assertNull(res[604].exec("apx{300}9!$ < ", 1452));
-assertNull(res[605].exec("X", 1453));
-assertNull(res[605].exec("** Failers ", 1454));
-assertNull(res[605].exec("", 1455));
-assertNull(res[606].exec("9", 1456));
-assertNull(res[606].exec("** Failers ", 1457));
-assertNull(res[606].exec("x{c0}", 1458));
-assertNull(res[607].exec("X", 1459));
-assertNull(res[607].exec("** Failers ", 1460));
-assertNull(res[607].exec("x{30f}", 1461));
-assertNull(res[608].exec("X", 1462));
-assertNull(res[608].exec("** Failers ", 1463));
-assertNull(res[608].exec("x{660}", 1464));
-assertNull(res[609].exec("X", 1465));
-assertNull(res[609].exec("** Failers ", 1466));
-assertNull(res[609].exec("x{66c}", 1467));
-assertNull(res[610].exec("X", 1468));
-assertNull(res[610].exec("** Failers ", 1469));
-assertNull(res[610].exec("x{f01}", 1470));
-assertNull(res[611].exec("X", 1471));
-assertNull(res[611].exec("** Failers ", 1472));
-assertNull(res[611].exec("x{1680}", 1473));
-assertNull(res[612].exec("x{017}", 1474));
-assertNull(res[612].exec("x{09f} ", 1475));
-assertNull(res[612].exec("** Failers", 1476));
-assertNull(res[612].exec("x{0600} ", 1477));
-assertNull(res[613].exec("x{601}", 1478));
-assertNull(res[613].exec("** Failers", 1479));
-assertNull(res[613].exec("x{09f} ", 1480));
-assertNull(res[614].exec("x{e0000}", 1481));
-assertNull(res[614].exec("** Failers", 1482));
-assertNull(res[614].exec("x{09f} ", 1483));
-assertNull(res[615].exec("x{f8ff}", 1484));
-assertNull(res[615].exec("** Failers", 1485));
-assertNull(res[615].exec("x{09f} ", 1486));
-assertNull(res[616].exec("?x{dfff}", 1487));
-assertNull(res[616].exec("** Failers", 1488));
-assertNull(res[616].exec("x{09f} ", 1489));
-assertNull(res[617].exec("a", 1490));
-assertNull(res[617].exec("** Failers ", 1491));
-assertNull(res[617].exec("Z", 1492));
-assertNull(res[617].exec("x{e000}  ", 1493));
-assertNull(res[618].exec("x{2b0}", 1494));
-assertNull(res[618].exec("** Failers", 1495));
-assertNull(res[618].exec("a ", 1496));
-assertNull(res[619].exec("x{1bb}", 1497));
-assertNull(res[619].exec("x{3400}", 1498));
-assertNull(res[619].exec("x{3401}", 1499));
-assertNull(res[619].exec("x{4d00}", 1500));
-assertNull(res[619].exec("x{4db4}", 1501));
-assertNull(res[619].exec("x{4db5}     ", 1502));
-assertNull(res[619].exec("** Failers", 1503));
-assertNull(res[619].exec("a ", 1504));
-assertNull(res[619].exec("x{2b0}", 1505));
-assertNull(res[619].exec("x{4db6} ", 1506));
-assertNull(res[620].exec("x{1c5}", 1507));
-assertNull(res[620].exec("** Failers", 1508));
-assertNull(res[620].exec("a ", 1509));
-assertNull(res[620].exec("x{2b0}", 1510));
-assertNull(res[621].exec("A", 1511));
-assertNull(res[621].exec("** Failers", 1512));
-assertNull(res[621].exec("x{2b0}", 1513));
-assertNull(res[622].exec("x{903}", 1514));
-assertNull(res[622].exec("** Failers", 1515));
-assertNull(res[622].exec("X", 1516));
-assertNull(res[622].exec("x{300}", 1517));
-assertNull(res[622].exec("   ", 1518));
-assertNull(res[623].exec("x{488}", 1519));
-assertNull(res[623].exec("** Failers", 1520));
-assertNull(res[623].exec("X", 1521));
-assertNull(res[623].exec("x{903}", 1522));
-assertNull(res[623].exec("x{300}", 1523));
-assertNull(res[624].exec("x{300}", 1524));
-assertNull(res[624].exec("** Failers", 1525));
-assertNull(res[624].exec("X", 1526));
-assertNull(res[624].exec("x{903}", 1527));
-assertNull(res[624].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 1528));
-assertNull(res[624].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 1529));
-assertNull(res[624].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 1530));
-assertNull(res[624].exec("** Failers", 1531));
-assertNull(res[624].exec("X", 1532));
-assertNull(res[625].exec("x{16ee}", 1533));
-assertNull(res[625].exec("** Failers", 1534));
-assertNull(res[625].exec("X", 1535));
-assertNull(res[625].exec("x{966}", 1536));
-assertNull(res[626].exec("x{b2}", 1537));
-assertNull(res[626].exec("x{b3}", 1538));
-assertNull(res[626].exec("** Failers", 1539));
-assertNull(res[626].exec("X", 1540));
-assertNull(res[626].exec("x{16ee}", 1541));
-assertNull(res[627].exec("_", 1542));
-assertNull(res[627].exec("x{203f}", 1543));
-assertNull(res[627].exec("** Failers", 1544));
-assertNull(res[627].exec("X", 1545));
-assertNull(res[627].exec("-", 1546));
-assertNull(res[627].exec("x{58a}", 1547));
-assertNull(res[628].exec("-", 1548));
-assertNull(res[628].exec("x{58a}", 1549));
-assertNull(res[628].exec("** Failers", 1550));
-assertNull(res[628].exec("X", 1551));
-assertNull(res[628].exec("x{203f}", 1552));
-assertNull(res[629].exec(")", 1553));
-assertNull(res[629].exec("]", 1554));
-assertNull(res[629].exec("}", 1555));
-assertNull(res[629].exec("x{f3b}", 1556));
-assertNull(res[629].exec("** Failers", 1557));
-assertNull(res[629].exec("X", 1558));
-assertNull(res[629].exec("x{203f}", 1559));
-assertNull(res[629].exec("(", 1560));
-assertNull(res[629].exec("[", 1561));
-assertNull(res[629].exec("{", 1562));
-assertNull(res[629].exec("x{f3c}", 1563));
-assertNull(res[630].exec("x{bb}", 1564));
-assertNull(res[630].exec("x{2019}", 1565));
-assertNull(res[630].exec("** Failers", 1566));
-assertNull(res[630].exec("X", 1567));
-assertNull(res[630].exec("x{203f}", 1568));
-assertNull(res[631].exec("x{ab}", 1569));
-assertNull(res[631].exec("x{2018}", 1570));
-assertNull(res[631].exec("** Failers", 1571));
-assertNull(res[631].exec("X", 1572));
-assertNull(res[631].exec("x{203f}", 1573));
-assertNull(res[632].exec("!", 1574));
-assertNull(res[632].exec("x{37e}", 1575));
-assertNull(res[632].exec("** Failers", 1576));
-assertNull(res[632].exec("X", 1577));
-assertNull(res[632].exec("x{203f}", 1578));
-assertNull(res[633].exec("(", 1579));
-assertNull(res[633].exec("[", 1580));
-assertNull(res[633].exec("{", 1581));
-assertNull(res[633].exec("x{f3c}", 1582));
-assertNull(res[633].exec("** Failers", 1583));
-assertNull(res[633].exec("X", 1584));
-assertNull(res[633].exec(")", 1585));
-assertNull(res[633].exec("]", 1586));
-assertNull(res[633].exec("}", 1587));
-assertNull(res[633].exec("x{f3b}", 1588));
-assertNull(res[633].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 1589));
-assertNull(res[633].exec("x{9f2}", 1590));
-assertNull(res[633].exec("** Failers", 1591));
-assertNull(res[633].exec("X", 1592));
-assertNull(res[633].exec("x{2c2}", 1593));
-assertNull(res[634].exec("x{2c2}", 1594));
-assertNull(res[634].exec("** Failers", 1595));
-assertNull(res[634].exec("X", 1596));
-assertNull(res[634].exec("x{9f2}", 1597));
-assertNull(res[634].exec("+<|~x{ac}x{2044}", 1598));
-assertNull(res[634].exec("** Failers", 1599));
-assertNull(res[634].exec("X", 1600));
-assertNull(res[634].exec("x{9f2}", 1601));
-assertNull(res[635].exec("x{a6}", 1602));
-assertNull(res[635].exec("x{482} ", 1603));
-assertNull(res[635].exec("** Failers", 1604));
-assertNull(res[635].exec("X", 1605));
-assertNull(res[635].exec("x{9f2}", 1606));
-assertNull(res[636].exec("x{2028}", 1607));
-assertNull(res[636].exec("** Failers", 1608));
-assertNull(res[636].exec("X", 1609));
-assertNull(res[636].exec("x{2029}", 1610));
-assertNull(res[637].exec("x{2029}", 1611));
-assertNull(res[637].exec("** Failers", 1612));
-assertNull(res[637].exec("X", 1613));
-assertNull(res[637].exec("x{2028}", 1614));
-assertNull(res[638].exec("\\ \\", 1615));
-assertNull(res[638].exec("x{a0}", 1616));
-assertNull(res[638].exec("x{1680}", 1617));
-assertNull(res[638].exec("x{180e}", 1618));
-assertNull(res[638].exec("x{2000}", 1619));
-assertNull(res[638].exec("x{2001}     ", 1620));
-assertNull(res[638].exec("** Failers", 1621));
-assertNull(res[638].exec("x{2028}", 1622));
-assertNull(res[638].exec("x{200d} ", 1623));
-assertNull(res[638].exec("  x{660}x{661}x{662}ABC", 1624));
-assertNull(res[638].exec("  x{660}x{661}x{662}ABC", 1625));
-assertNull(res[639].exec("  x{660}x{661}x{662}ABC", 1626));
-assertNull(res[640].exec("  x{660}x{661}x{662}ABC", 1627));
-assertNull(res[641].exec("  x{660}x{661}x{662}ABC", 1628));
-assertNull(res[642].exec("  x{660}x{661}x{662}ABC", 1629));
-assertNull(res[643].exec("  x{660}x{661}x{662}ABC", 1630));
-assertNull(res[644].exec("  x{660}x{661}x{662}ABC", 1631));
-assertNull(res[645].exec("  x{660}x{661}x{662}ABC", 1632));
-assertNull(res[646].exec("  x{660}x{661}x{662}ABC", 1633));
-assertNull(res[647].exec("  x{660}x{661}x{662}ABC", 1634));
-assertNull(res[647].exec("  x{660}x{661}x{662}ABC", 1635));
-assertNull(res[647].exec("  x{660}x{661}x{662}ABC", 1636));
-assertNull(res[647].exec("  ** Failers", 1637));
-assertNull(res[647].exec("  x{660}x{661}x{662}ABC", 1638));
-assertNull(res[648].exec("A", 1639));
-assertNull(res[648].exec("ax{10a0}B ", 1640));
-assertNull(res[648].exec("** Failers ", 1641));
-assertNull(res[648].exec("a", 1642));
-assertNull(res[648].exec("x{1d00}  ", 1643));
-assertNull(res[649].exec("1234", 1644));
-assertNull(res[649].exec("** Failers", 1645));
-assertNull(res[649].exec("ABC ", 1646));
-assertNull(res[650].exec("1234", 1647));
-assertNull(res[650].exec("** Failers", 1648));
-assertNull(res[650].exec("ABC ", 1649));
-assertNull(res[650].exec("A2XYZ", 1650));
-assertNull(res[650].exec("123A5XYZPQR", 1651));
-assertNull(res[650].exec("ABAx{660}XYZpqr", 1652));
-assertNull(res[650].exec("** Failers", 1653));
-assertNull(res[650].exec("AXYZ", 1654));
-assertNull(res[650].exec("XYZ     ", 1655));
-assertNull(res[650].exec("1XYZ", 1656));
-assertNull(res[650].exec("AB=XYZ.. ", 1657));
-assertNull(res[650].exec("XYZ ", 1658));
-assertNull(res[650].exec("** Failers", 1659));
-assertNull(res[650].exec("WXYZ ", 1660));
-assertNull(res[655].exec("1234", 1661));
-assertNull(res[655].exec("1234", 1662));
-assertNull(res[655].exec("12-34", 1663));
-assertToStringEquals("{", res[655].exec("12+x{661}-34  "), 1664);
-assertNull(res[655].exec("** Failers", 1665));
-assertToStringEquals("d", res[655].exec("abcd  "), 1666);
-assertToStringEquals("d", res[656].exec("abcd"), 1667);
-assertNull(res[656].exec("** Failers", 1668));
-assertNull(res[656].exec("1234", 1669));
-assertNull(res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1670));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1671);
-assertToStringEquals(" ", res[657].exec(" "), 1672);
-assertNull(res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1673));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1674);
-assertNull(res[658].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1675));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[658].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1676);
-assertNull(res[659].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1677));
-assertNull(res[659].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1678));
-assertNull(res[660].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1679));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[660].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1680);
-assertNull(res[661].exec("a", 1681));
-assertNull(res[661].exec("A ", 1682));
-assertNull(res[662].exec("a", 1683));
-assertNull(res[662].exec("A ", 1684));
-assertNull(res[663].exec("A", 1685));
-assertNull(res[663].exec("aZ", 1686));
-assertNull(res[663].exec("** Failers", 1687));
-assertNull(res[663].exec("abc   ", 1688));
-assertNull(res[664].exec("A", 1689));
-assertNull(res[664].exec("aZ", 1690));
-assertNull(res[664].exec("** Failers", 1691));
-assertNull(res[664].exec("abc   ", 1692));
-assertNull(res[665].exec("a", 1693));
-assertNull(res[665].exec("Az", 1694));
-assertNull(res[665].exec("** Failers", 1695));
-assertNull(res[665].exec("ABC   ", 1696));
-assertNull(res[666].exec("a", 1697));
-assertNull(res[666].exec("Az", 1698));
-assertNull(res[666].exec("** Failers", 1699));
-assertNull(res[666].exec("ABC   ", 1700));
-assertNull(res[666].exec("x{c0}", 1701));
-assertNull(res[666].exec("x{e0} ", 1702));
-assertNull(res[666].exec("x{c0}", 1703));
-assertNull(res[666].exec("x{e0} ", 1704));
-assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1705));
-assertNull(res[666].exec("** Failers", 1706));
-assertNull(res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 1707));
-assertNull(res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1708));
-assertNull(res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1709));
-assertNull(res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1710));
-assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1711));
-assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1712));
-assertNull(res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 1713));
-assertNull(res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1714));
-assertNull(res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1715));
-assertNull(res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1716));
-assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1717));
-assertNull(res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 1718));
-assertNull(res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1719));
-assertNull(res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1720));
-assertNull(res[666].exec("x{391}", 1721));
-assertNull(res[666].exec("x{ff3a}", 1722));
-assertNull(res[666].exec("x{3b1}", 1723));
-assertNull(res[666].exec("x{ff5a}   ", 1724));
-assertNull(res[666].exec("x{c0}", 1725));
-assertNull(res[666].exec("x{e0} ", 1726));
-assertNull(res[666].exec("x{104}", 1727));
-assertNull(res[666].exec("x{105}", 1728));
-assertNull(res[666].exec("x{109}  ", 1729));
-assertNull(res[666].exec("** Failers", 1730));
-assertNull(res[666].exec("x{100}", 1731));
-assertNull(res[666].exec("x{10a} ", 1732));
-assertNull(res[666].exec("Z", 1733));
-assertNull(res[666].exec("z", 1734));
-assertNull(res[666].exec("x{39c}", 1735));
-assertNull(res[666].exec("x{178}", 1736));
-assertNull(res[666].exec("|", 1737));
-assertNull(res[666].exec("x{80}", 1738));
-assertNull(res[666].exec("x{ff}", 1739));
-assertNull(res[666].exec("x{100}", 1740));
-assertNull(res[666].exec("x{101} ", 1741));
-assertNull(res[666].exec("** Failers", 1742));
-assertNull(res[666].exec("x{102}", 1743));
-assertNull(res[666].exec("Y", 1744));
-assertNull(res[666].exec("y           ", 1745));
-assertNull(res[667].exec("A", 1746));
-assertNull(res[667].exec("Ax{300}BC ", 1747));
-assertNull(res[667].exec("Ax{300}x{301}x{302}BC ", 1748));
-assertNull(res[667].exec("*** Failers", 1749));
-assertNull(res[667].exec("x{300}  ", 1750));
-assertToStringEquals("X", res[668].exec("X123"), 1751);
-assertNull(res[668].exec("*** Failers", 1752));
-assertNull(res[668].exec("AXYZ", 1753));
-assertNull(res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1754));
-assertNull(res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1755));
-assertNull(res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1756));
-assertNull(res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1757));
-assertToStringEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1758);
-assertToStringEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1759);
-assertToStringEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1760);
-assertToStringEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1761);
-assertNull(res[673].exec("*** Failers", 1762));
-assertNull(res[673].exec("Ax{300}x{301}x{302}", 1763));
-assertNull(res[674].exec("Ax{300}x{301}Bx{300}X", 1764));
-assertNull(res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1765));
-assertNull(res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1766));
-assertNull(res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1767));
-assertNull(res[675].exec("Ax{300}x{301}Bx{300}X", 1768));
-assertNull(res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1769));
-assertNull(res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1770));
-assertNull(res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1771));
-assertNull(res[675].exec("x{2e81}x{3007}x{2f804}x{31a0}", 1772));
-assertNull(res[675].exec("** Failers", 1773));
-assertNull(res[675].exec("x{2e7f}  ", 1774));
-assertNull(res[675].exec("x{3105}", 1775));
-assertNull(res[675].exec("** Failers", 1776));
-assertNull(res[675].exec("x{30ff}  ", 1777));
-assertNull(res[676].exec("x{06e9}", 1778));
-assertNull(res[676].exec("x{060b}", 1779));
-assertNull(res[676].exec("** Failers", 1780));
-assertNull(res[676].exec("Xx{06e9}   ", 1781));
-assertNull(res[677].exec("x{2f800}", 1782));
-assertNull(res[677].exec("** Failers", 1783));
-assertNull(res[677].exec("x{a014}", 1784));
-assertNull(res[677].exec("x{a4c6}   ", 1785));
-assertNull(res[678].exec("AXYZ", 1786));
-assertNull(res[678].exec("x{1234}XYZ ", 1787));
-assertNull(res[678].exec("** Failers", 1788));
-assertNull(res[678].exec("X  ", 1789));
-assertNull(res[679].exec("** Failers", 1790));
-assertNull(res[679].exec("AX", 1791));
-assertNull(res[680].exec("XYZ", 1792));
-assertNull(res[680].exec("AXYZ", 1793));
-assertNull(res[680].exec("x{1234}XYZ ", 1794));
-assertNull(res[680].exec("** Failers", 1795));
-assertNull(res[680].exec("ABXYZ   ", 1796));
-assertNull(res[681].exec("XYZ", 1797));
-assertNull(res[681].exec("** Failers", 1798));
-assertNull(res[681].exec("AXYZ", 1799));
-assertNull(res[681].exec("x{1234}XYZ ", 1800));
-assertNull(res[681].exec("ABXYZ   ", 1801));
-assertNull(res[681].exec("AXYZ", 1802));
-assertNull(res[681].exec("x{1234}XYZ", 1803));
-assertNull(res[681].exec("Ax{1234}XYZ", 1804));
-assertNull(res[681].exec("** Failers", 1805));
-assertNull(res[681].exec("XYZ", 1806));
-assertNull(res[681].exec("** Failers", 1807));
-assertNull(res[681].exec("AXYZ", 1808));
-assertNull(res[681].exec("x{1234}XYZ", 1809));
-assertNull(res[681].exec("Ax{1234}XYZ", 1810));
-assertNull(res[681].exec("XYZ", 1811));
-assertNull(res[682].exec("XYZ", 1812));
-assertNull(res[682].exec("AXYZ", 1813));
-assertNull(res[682].exec("x{1234}XYZ", 1814));
-assertNull(res[682].exec("Ax{1234}XYZ", 1815));
-assertNull(res[682].exec("** Failers", 1816));
-assertNull(res[683].exec("XYZ", 1817));
-assertNull(res[683].exec("** Failers", 1818));
-assertNull(res[683].exec("AXYZ", 1819));
-assertNull(res[683].exec("x{1234}XYZ", 1820));
-assertNull(res[683].exec("Ax{1234}XYZ", 1821));
-assertToStringEquals("AX", res[684].exec("AXYZ"), 1822);
-assertNull(res[684].exec("x{1234}XYZ ", 1823));
-assertNull(res[684].exec("** Failers", 1824));
-assertNull(res[684].exec("X  ", 1825));
-assertNull(res[685].exec("** Failers", 1826));
-assertToStringEquals("AX", res[685].exec("AX"), 1827);
-assertToStringEquals("X", res[686].exec("XYZ"), 1828);
-assertToStringEquals("AX", res[686].exec("AXYZ"), 1829);
-assertNull(res[686].exec("x{1234}XYZ ", 1830));
-assertNull(res[686].exec("** Failers", 1831));
-assertNull(res[686].exec("ABXYZ   ", 1832));
-assertToStringEquals("X", res[687].exec("XYZ"), 1833);
-assertNull(res[687].exec("** Failers", 1834));
-assertToStringEquals("AX", res[687].exec("AXYZ"), 1835);
-assertNull(res[687].exec("x{1234}XYZ ", 1836));
-assertNull(res[687].exec("ABXYZ   ", 1837));
-assertToStringEquals("AX", res[688].exec("AXYZ"), 1838);
-assertNull(res[688].exec("x{1234}XYZ", 1839));
-assertNull(res[688].exec("Ax{1234}XYZ", 1840));
-assertNull(res[688].exec("** Failers", 1841));
-assertNull(res[688].exec("XYZ", 1842));
-assertNull(res[689].exec("** Failers", 1843));
-assertToStringEquals("AX", res[689].exec("AXYZ"), 1844);
-assertNull(res[689].exec("x{1234}XYZ", 1845));
-assertNull(res[689].exec("Ax{1234}XYZ", 1846));
-assertNull(res[689].exec("XYZ", 1847));
-assertToStringEquals("X", res[690].exec("XYZ"), 1848);
-assertToStringEquals("AX", res[690].exec("AXYZ"), 1849);
-assertNull(res[690].exec("x{1234}XYZ", 1850));
-assertNull(res[690].exec("Ax{1234}XYZ", 1851));
-assertNull(res[690].exec("** Failers", 1852));
-assertToStringEquals("X", res[691].exec("XYZ"), 1853);
-assertNull(res[691].exec("** Failers", 1854));
-assertToStringEquals("AX", res[691].exec("AXYZ"), 1855);
-assertNull(res[691].exec("x{1234}XYZ", 1856));
-assertNull(res[691].exec("Ax{1234}XYZ", 1857));
-assertNull(res[692].exec("abcdefgh", 1858));
-assertNull(res[692].exec("x{1234}\n\x0dx{3456}xyz ", 1859));
-assertNull(res[693].exec("abcdefgh", 1860));
-assertNull(res[693].exec("x{1234}\n\x0dx{3456}xyz ", 1861));
-assertNull(res[694].exec("** Failers", 1862));
-assertNull(res[694].exec("abcdefgh", 1863));
-assertNull(res[694].exec("x{1234}\n\x0dx{3456}xyz ", 1864));
-assertNull(res[695].exec(" AXY", 1865));
-assertNull(res[695].exec(" aXY", 1866));
-assertNull(res[695].exec(" x{1c5}XY", 1867));
-assertNull(res[695].exec(" ** Failers", 1868));
-assertNull(res[695].exec(" x{1bb}XY", 1869));
-assertNull(res[695].exec(" x{2b0}XY", 1870));
-assertNull(res[695].exec(" !XY      ", 1871));
-assertNull(res[696].exec(" AXY", 1872));
-assertNull(res[696].exec(" aXY", 1873));
-assertNull(res[696].exec(" x{1c5}XY", 1874));
-assertNull(res[696].exec(" ** Failers", 1875));
-assertNull(res[696].exec(" x{1bb}XY", 1876));
-assertNull(res[696].exec(" x{2b0}XY", 1877));
-assertNull(res[696].exec(" !XY      ", 1878));
-assertNull(res[696].exec(" AXY", 1879));
-assertNull(res[696].exec(" aXY", 1880));
-assertNull(res[696].exec(" AbcdeXyz ", 1881));
-assertNull(res[696].exec(" x{1c5}AbXY", 1882));
-assertNull(res[696].exec(" abcDEXypqreXlmn ", 1883));
-assertNull(res[696].exec(" ** Failers", 1884));
-assertNull(res[696].exec(" x{1bb}XY", 1885));
-assertNull(res[696].exec(" x{2b0}XY", 1886));
-assertNull(res[696].exec(" !XY      ", 1887));
-assertNull(res[697].exec(" AXY", 1888));
-assertNull(res[697].exec(" aXY", 1889));
-assertNull(res[697].exec(" AbcdeXyz ", 1890));
-assertNull(res[697].exec(" x{1c5}AbXY", 1891));
-assertNull(res[697].exec(" abcDEXypqreXlmn ", 1892));
-assertNull(res[697].exec(" ** Failers", 1893));
-assertNull(res[697].exec(" x{1bb}XY", 1894));
-assertNull(res[697].exec(" x{2b0}XY", 1895));
-assertNull(res[697].exec(" !XY      ", 1896));
-assertNull(res[697].exec(" AXY", 1897));
-assertNull(res[697].exec(" aXY", 1898));
-assertNull(res[697].exec(" AbcdeXyz ", 1899));
-assertNull(res[697].exec(" x{1c5}AbXY", 1900));
-assertNull(res[697].exec(" abcDEXypqreXlmn ", 1901));
-assertNull(res[697].exec(" ** Failers", 1902));
-assertNull(res[697].exec(" x{1bb}XY", 1903));
-assertNull(res[697].exec(" x{2b0}XY", 1904));
-assertNull(res[697].exec(" !XY      ", 1905));
-assertNull(res[698].exec(" AXY", 1906));
-assertNull(res[698].exec(" aXY", 1907));
-assertNull(res[698].exec(" AbcdeXyz ", 1908));
-assertNull(res[698].exec(" x{1c5}AbXY", 1909));
-assertNull(res[698].exec(" abcDEXypqreXlmn ", 1910));
-assertNull(res[698].exec(" ** Failers", 1911));
-assertNull(res[698].exec(" x{1bb}XY", 1912));
-assertNull(res[698].exec(" x{2b0}XY", 1913));
-assertNull(res[698].exec(" !XY      ", 1914));
-assertNull(res[699].exec(" !XY", 1915));
-assertNull(res[699].exec(" x{1bb}XY", 1916));
-assertNull(res[699].exec(" x{2b0}XY", 1917));
-assertNull(res[699].exec(" ** Failers", 1918));
-assertNull(res[699].exec(" x{1c5}XY", 1919));
-assertNull(res[699].exec(" AXY      ", 1920));
-assertNull(res[700].exec(" !XY", 1921));
-assertNull(res[700].exec(" x{1bb}XY", 1922));
-assertNull(res[700].exec(" x{2b0}XY", 1923));
-assertNull(res[700].exec(" ** Failers", 1924));
-assertNull(res[700].exec(" x{1c5}XY", 1925));
-assertNull(res[700].exec(" AXY      ", 1926));
-assertNull(res[701].exec("\xa0!", 1927));
-assertNull(res[701].exec("AabcabcYZ    ", 1928));
-assertToStringEquals("L=abcX,L=abc,abc", res[702].exec("L=abcX"), 1929);
-assertNull(res[702].exec("x{c0}", 1930));
-assertNull(res[702].exec("x{e0} ", 1931));
-assertNull(res[702].exec("x{c0}", 1932));
-assertNull(res[702].exec("x{e0} ", 1933));
-assertNull(res[703].exec("x{1b00}x{12000}x{7c0}x{a840}x{10900}", 1934));
-assertNull(res[706].exec("123abcdefg", 1935));
-assertNull(res[706].exec("123abc\xc4\xc5zz", 1936));
-assertNull(res[710].exec("A\x80", 1937));
-assertNull(res[725].exec("x{60e} ", 1938));
-assertNull(res[725].exec("x{656} ", 1939));
-assertNull(res[725].exec("x{657} ", 1940));
-assertNull(res[725].exec("x{658} ", 1941));
-assertNull(res[725].exec("x{659} ", 1942));
-assertNull(res[725].exec("x{65a} ", 1943));
-assertNull(res[725].exec("x{65b} ", 1944));
-assertNull(res[725].exec("x{65c} ", 1945));
-assertNull(res[725].exec("x{65d} ", 1946));
-assertNull(res[725].exec("x{65e} ", 1947));
-assertNull(res[725].exec("x{66a} ", 1948));
-assertNull(res[725].exec("x{6e9} ", 1949));
-assertNull(res[725].exec("x{6ef}", 1950));
-assertNull(res[725].exec("x{6fa}  ", 1951));
-assertNull(res[725].exec("** Failers", 1952));
-assertNull(res[725].exec("x{600}", 1953));
-assertNull(res[725].exec("x{650}", 1954));
-assertNull(res[725].exec("x{651}  ", 1955));
-assertNull(res[725].exec("x{652}  ", 1956));
-assertNull(res[725].exec("x{653}  ", 1957));
-assertNull(res[725].exec("x{654} ", 1958));
-assertNull(res[725].exec("x{655} ", 1959));
-assertNull(res[725].exec("x{65f}  ", 1960));
-assertNull(res[726].exec("x{1d2b} ", 1961));
-assertNull(res[727].exec("x{589}", 1962));
-assertNull(res[727].exec("x{60c}", 1963));
-assertNull(res[727].exec("x{61f}  ", 1964));
-assertNull(res[727].exec("x{964}", 1965));
-assertNull(res[727].exec("x{965}  ", 1966));
-assertNull(res[727].exec("x{970}  ", 1967));
-assertNull(res[728].exec("x{64b}", 1968));
-assertNull(res[728].exec("x{654}", 1969));
-assertNull(res[728].exec("x{655}", 1970));
-assertNull(res[728].exec("x{200c} ", 1971));
-assertNull(res[728].exec("** Failers", 1972));
-assertNull(res[728].exec("x{64a}", 1973));
-assertNull(res[728].exec("x{656}     ", 1974));
-assertNull(res[729].exec("x{10450}", 1975));
-assertNull(res[729].exec("x{1047f}", 1976));
-assertNull(res[730].exec("x{10400}", 1977));
-assertNull(res[730].exec("x{1044f}", 1978));
-assertNull(res[731].exec("x{10480}", 1979));
-assertNull(res[731].exec("x{1049d}", 1980));
-assertNull(res[731].exec("x{104a0}", 1981));
-assertNull(res[731].exec("x{104a9}", 1982));
-assertNull(res[731].exec("** Failers", 1983));
-assertNull(res[731].exec("x{1049e}", 1984));
-assertNull(res[731].exec("x{1049f}", 1985));
-assertNull(res[731].exec("x{104aa}           ", 1986));
-assertNull(res[731].exec("\xe2\x80\xa8\xe2\x80\xa8", 1987));
-assertNull(res[731].exec("x{2028}x{2028}x{2028}", 1988));
-assertNull(res[732].exec("x{c0}x{e0}x{116}x{117}", 1989));
-assertNull(res[732].exec("x{c0}x{e0}x{116}x{117}", 1990));
-assertNull(res[733].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 1991));
-assertNull(res[733].exec("x{a77d}x{1d79}", 1992));
-assertNull(res[733].exec("x{1d79}x{a77d} ", 1993));
-assertNull(res[733].exec("x{a77d}x{1d79}", 1994));
-assertNull(res[733].exec("** Failers ", 1995));
-assertNull(res[733].exec("x{1d79}x{a77d} ", 1996));
-assertToStringEquals("AA,A", res[734].exec("AA"), 1997);
-assertToStringEquals("Aa,A", res[734].exec("Aa"), 1998);
-assertToStringEquals("aa,a", res[734].exec("aa"), 1999);
-assertToStringEquals("aA,a", res[734].exec("aA"), 2000);
-assertNull(res[734].exec("x{de}x{de}", 2001));
-assertNull(res[734].exec("x{de}x{fe}", 2002));
-assertNull(res[734].exec("x{fe}x{fe}", 2003));
-assertNull(res[734].exec("x{fe}x{de}", 2004));
-assertNull(res[734].exec("x{10a}x{10a}", 2005));
-assertNull(res[734].exec("x{10a}x{10b}", 2006));
-assertNull(res[734].exec("x{10b}x{10b}", 2007));
-assertNull(res[734].exec("x{10b}x{10a}", 2008));
-assertToStringEquals("abc", res[736].exec("abc"), 2009);
-assertToStringEquals("abc", res[737].exec("abc"), 2010);
-assertToStringEquals("abbbbc", res[737].exec("abbbbc"), 2011);
-assertToStringEquals("ac", res[737].exec("ac"), 2012);
-assertToStringEquals("abc", res[738].exec("abc"), 2013);
-assertToStringEquals("abbbbbbc", res[738].exec("abbbbbbc"), 2014);
-assertNull(res[738].exec("*** Failers ", 2015));
-assertNull(res[738].exec("ac", 2016));
-assertNull(res[738].exec("ab", 2017));
-assertToStringEquals("a", res[739].exec("a"), 2018);
-assertToStringEquals("aaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaa"), 2019);
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "), 2020);
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaF "), 2021);
-assertToStringEquals("a,a", res[740].exec("a"), 2022);
-assertToStringEquals("a,a", res[740].exec("abcd"), 2023);
-assertToStringEquals("a,a", res[740].exec("african"), 2024);
-assertToStringEquals("abc", res[741].exec("abcdef"), 2025);
-assertNull(res[741].exec("*** Failers", 2026));
-assertNull(res[741].exec("xyzabc", 2027));
-assertNull(res[741].exec("xyz\nabc    ", 2028));
-assertToStringEquals("abc", res[742].exec("abcdef"), 2029);
-assertToStringEquals("abc", res[742].exec("xyz\nabc    "), 2030);
-assertNull(res[742].exec("*** Failers", 2031));
-assertNull(res[742].exec("xyzabc", 2032));
-assertNull(res[743].exec("abcdef", 2033));
-assertNull(res[743].exec("*** Failers", 2034));
-assertNull(res[743].exec("xyzabc", 2035));
-assertNull(res[743].exec("xyz\nabc    ", 2036));
-assertNull(res[744].exec("abcdef", 2037));
-assertNull(res[744].exec("*** Failers", 2038));
-assertNull(res[744].exec("xyzabc", 2039));
-assertNull(res[744].exec("xyz\nabc    ", 2040));
-assertNull(res[745].exec("abcdef", 2041));
-assertNull(res[745].exec("xyzabc>3", 2042));
-assertNull(res[745].exec("*** Failers", 2043));
-assertNull(res[745].exec("xyzabc    ", 2044));
-assertNull(res[745].exec("xyzabc>2 ", 2045));
-assertToStringEquals("x9yzz", res[746].exec("x9yzz"), 2046);
-assertToStringEquals("x0y+z", res[746].exec("x0y+z"), 2047);
-assertNull(res[746].exec("*** Failers", 2048));
-assertNull(res[746].exec("xyz", 2049));
-assertNull(res[746].exec("xxy0z     ", 2050));
-assertToStringEquals("x yzz", res[747].exec("x yzz"), 2051);
-assertToStringEquals("x y+z", res[747].exec("x y+z"), 2052);
-assertNull(res[747].exec("*** Failers", 2053));
-assertNull(res[747].exec("xyz", 2054));
-assertNull(res[747].exec("xxyyz", 2055));
-assertToStringEquals("xxy+z", res[748].exec("xxy+z"), 2056);
-assertNull(res[748].exec("*** Failers", 2057));
-assertNull(res[748].exec("xxy0z", 2058));
-assertNull(res[748].exec("x+y+z         ", 2059));
-assertToStringEquals("x+y", res[749].exec("x+y"), 2060);
-assertToStringEquals("x-y", res[749].exec("x-y"), 2061);
-assertNull(res[749].exec("*** Failers", 2062));
-assertNull(res[749].exec("x\ny", 2063));
-assertToStringEquals("x+y", res[750].exec("x+y"), 2064);
-assertToStringEquals("x-y", res[750].exec("x-y"), 2065);
-assertNull(res[750].exec("x\ny", 2066));
-assertNull(res[750].exec("a+bc+dp+q", 2067));
-assertNull(res[750].exec("a+bc\ndp+q", 2068));
-assertNull(res[750].exec("x\nyp+q ", 2069));
-assertNull(res[750].exec("*** Failers ", 2070));
-assertNull(res[750].exec("a\nbc\ndp+q", 2071));
-assertNull(res[750].exec("a+bc\ndp\nq", 2072));
-assertNull(res[750].exec("x\nyp\nq ", 2073));
-assertNull(res[751].exec("ba0", 2074));
-assertNull(res[751].exec("*** Failers", 2075));
-assertNull(res[751].exec("ba0\n", 2076));
-assertNull(res[751].exec("ba0\ncd   ", 2077));
-assertNull(res[752].exec("ba0", 2078));
-assertNull(res[752].exec("*** Failers", 2079));
-assertNull(res[752].exec("ba0\n", 2080));
-assertNull(res[752].exec("ba0\ncd   ", 2081));
-assertNull(res[753].exec("ba0", 2082));
-assertNull(res[753].exec("ba0\n", 2083));
-assertNull(res[753].exec("*** Failers", 2084));
-assertNull(res[753].exec("ba0\ncd   ", 2085));
-assertNull(res[754].exec("ba0", 2086));
-assertNull(res[754].exec("ba0\n", 2087));
-assertNull(res[754].exec("*** Failers", 2088));
-assertNull(res[754].exec("ba0\ncd   ", 2089));
-assertToStringEquals("a0", res[755].exec("ba0"), 2090);
-assertNull(res[755].exec("ba0\n", 2091));
-assertNull(res[755].exec("*** Failers", 2092));
-assertNull(res[755].exec("ba0\ncd   ", 2093));
-assertToStringEquals("a0", res[756].exec("ba0"), 2094);
-assertToStringEquals("a0", res[756].exec("ba0\n"), 2095);
-assertToStringEquals("a0", res[756].exec("ba0\ncd   "), 2096);
-assertNull(res[756].exec("*** Failers", 2097));
-assertToStringEquals("abc", res[757].exec("abc"), 2098);
-assertToStringEquals("aBc", res[757].exec("aBc"), 2099);
-assertToStringEquals("ABC", res[757].exec("ABC"), 2100);
-assertToStringEquals("b", res[758].exec("abcd"), 2101);
-assertToStringEquals("abz", res[759].exec("abz"), 2102);
-assertToStringEquals("abb", res[759].exec("abbz"), 2103);
-assertToStringEquals("az", res[759].exec("azz  "), 2104);
-assertToStringEquals("yz", res[760].exec("ayzq"), 2105);
-assertToStringEquals("xyz", res[760].exec("axyzq"), 2106);
-assertToStringEquals("xxyz", res[760].exec("axxyz"), 2107);
-assertToStringEquals("xxxyz", res[760].exec("axxxyzq"), 2108);
-assertToStringEquals("xxxyz", res[760].exec("axxxxyzq"), 2109);
-assertNull(res[760].exec("*** Failers", 2110));
-assertNull(res[760].exec("ax", 2111));
-assertNull(res[760].exec("axx     ", 2112));
-assertNull(res[760].exec("  ", 2113));
-assertToStringEquals("xxxyz", res[761].exec("axxxyzq"), 2114);
-assertToStringEquals("xxxyz", res[761].exec("axxxxyzq"), 2115);
-assertNull(res[761].exec("*** Failers", 2116));
-assertNull(res[761].exec("ax", 2117));
-assertNull(res[761].exec("axx     ", 2118));
-assertNull(res[761].exec("ayzq", 2119));
-assertNull(res[761].exec("axyzq", 2120));
-assertNull(res[761].exec("axxyz", 2121));
-assertNull(res[761].exec("  ", 2122));
-assertToStringEquals("xxyz", res[762].exec("axxyz"), 2123);
-assertToStringEquals("xxxyz", res[762].exec("axxxyzq"), 2124);
-assertToStringEquals("xxxyz", res[762].exec("axxxxyzq"), 2125);
-assertNull(res[762].exec("*** Failers", 2126));
-assertNull(res[762].exec("ax", 2127));
-assertNull(res[762].exec("axx     ", 2128));
-assertNull(res[762].exec("ayzq", 2129));
-assertNull(res[762].exec("axyzq", 2130));
-assertNull(res[762].exec("  ", 2131));
-assertToStringEquals("b", res[763].exec("bac"), 2132);
-assertToStringEquals("bcdef", res[763].exec("bcdefax"), 2133);
-assertToStringEquals("*** F", res[763].exec("*** Failers"), 2134);
-assertToStringEquals("   ", res[763].exec("aaaaa   "), 2135);
-assertToStringEquals("b", res[764].exec("bac"), 2136);
-assertToStringEquals("bcdef", res[764].exec("bcdefax"), 2137);
-assertToStringEquals("*** F", res[764].exec("*** Failers"), 2138);
-assertToStringEquals("", res[764].exec("aaaaa   "), 2139);
-assertToStringEquals("xyz", res[765].exec("xyz"), 2140);
-assertToStringEquals("wxyz", res[765].exec("awxyza"), 2141);
-assertToStringEquals("bcdef", res[765].exec("abcdefa"), 2142);
-assertToStringEquals("bcdef", res[765].exec("abcdefghijk"), 2143);
-assertToStringEquals("*** F", res[765].exec("*** Failers"), 2144);
-assertNull(res[765].exec("axya", 2145));
-assertNull(res[765].exec("axa", 2146));
-assertToStringEquals("     ", res[765].exec("aaaaa         "), 2147);
-assertToStringEquals("1234", res[766].exec("1234b567"), 2148);
-assertToStringEquals("", res[766].exec("xyz"), 2149);
-assertToStringEquals("a", res[767].exec("a1234b567"), 2150);
-assertToStringEquals("xyz", res[767].exec("xyz"), 2151);
-assertToStringEquals(" ", res[767].exec(" "), 2152);
-assertToStringEquals("1234", res[768].exec("ab1234c56"), 2153);
-assertNull(res[768].exec("*** Failers", 2154));
-assertNull(res[768].exec("xyz", 2155));
-assertToStringEquals("ab", res[769].exec("ab123c56"), 2156);
-assertToStringEquals("*** Failers", res[769].exec("*** Failers"), 2157);
-assertNull(res[769].exec("789", 2158));
-assertToStringEquals("5A", res[770].exec("045ABC"), 2159);
-assertToStringEquals("A", res[770].exec("ABC"), 2160);
-assertNull(res[770].exec("*** Failers", 2161));
-assertNull(res[770].exec("XYZ", 2162));
-assertToStringEquals("A", res[771].exec("ABC"), 2163);
-assertToStringEquals("BA", res[771].exec("BAC"), 2164);
-assertToStringEquals("A", res[771].exec("9ABC             "), 2165);
-assertNull(res[771].exec("*** Failers", 2166));
-assertToStringEquals("aaaa", res[772].exec("aaaa"), 2167);
-assertToStringEquals("xyz", res[773].exec("xyz"), 2168);
-assertToStringEquals("ggggggggxyz", res[773].exec("ggggggggxyz"), 2169);
-assertToStringEquals("abcdxyz", res[774].exec("abcdxyz"), 2170);
-assertToStringEquals("axyz", res[774].exec("axyz"), 2171);
-assertNull(res[774].exec("*** Failers", 2172));
-assertNull(res[774].exec("xyz", 2173));
-assertToStringEquals("xyz", res[775].exec("xyz"), 2174);
-assertToStringEquals("cxyz", res[775].exec("cxyz       "), 2175);
-assertToStringEquals("12X", res[776].exec("12X"), 2176);
-assertToStringEquals("123X", res[776].exec("123X"), 2177);
-assertNull(res[776].exec("*** Failers", 2178));
-assertNull(res[776].exec("X", 2179));
-assertNull(res[776].exec("1X", 2180));
-assertNull(res[776].exec("1234X     ", 2181));
-assertToStringEquals("a4", res[777].exec("a45"), 2182);
-assertToStringEquals("b9", res[777].exec("b93"), 2183);
-assertToStringEquals("c9", res[777].exec("c99z"), 2184);
-assertToStringEquals("d0", res[777].exec("d04"), 2185);
-assertNull(res[777].exec("*** Failers", 2186));
-assertNull(res[777].exec("e45", 2187));
-assertNull(res[777].exec("abcd      ", 2188));
-assertNull(res[777].exec("abcd1234", 2189));
-assertNull(res[777].exec("1234  ", 2190));
-assertToStringEquals("a4", res[778].exec("a45"), 2191);
-assertToStringEquals("b9", res[778].exec("b93"), 2192);
-assertToStringEquals("c9", res[778].exec("c99z"), 2193);
-assertToStringEquals("d0", res[778].exec("d04"), 2194);
-assertToStringEquals("abcd1", res[778].exec("abcd1234"), 2195);
-assertToStringEquals("1", res[778].exec("1234  "), 2196);
-assertNull(res[778].exec("*** Failers", 2197));
-assertNull(res[778].exec("e45", 2198));
-assertNull(res[778].exec("abcd      ", 2199));
-assertToStringEquals("a4", res[779].exec("a45"), 2200);
-assertToStringEquals("b9", res[779].exec("b93"), 2201);
-assertToStringEquals("c9", res[779].exec("c99z"), 2202);
-assertToStringEquals("d0", res[779].exec("d04"), 2203);
-assertToStringEquals("abcd1", res[779].exec("abcd1234"), 2204);
-assertNull(res[779].exec("*** Failers", 2205));
-assertNull(res[779].exec("1234  ", 2206));
-assertNull(res[779].exec("e45", 2207));
-assertNull(res[779].exec("abcd      ", 2208));
-assertToStringEquals("aX", res[780].exec("aX"), 2209);
-assertToStringEquals("aaX", res[780].exec("aaX "), 2210);
-assertToStringEquals("a4", res[781].exec("a45"), 2211);
-assertToStringEquals("b9", res[781].exec("b93"), 2212);
-assertToStringEquals("c9", res[781].exec("c99z"), 2213);
-assertToStringEquals("d0", res[781].exec("d04"), 2214);
-assertToStringEquals("1", res[781].exec("1234  "), 2215);
-assertNull(res[781].exec("*** Failers", 2216));
-assertNull(res[781].exec("abcd1234", 2217));
-assertNull(res[781].exec("e45", 2218));
-assertToStringEquals("ab4", res[782].exec("ab45"), 2219);
-assertToStringEquals("bcd9", res[782].exec("bcd93"), 2220);
-assertNull(res[782].exec("*** Failers", 2221));
-assertNull(res[782].exec("1234 ", 2222));
-assertNull(res[782].exec("a36 ", 2223));
-assertNull(res[782].exec("abcd1234", 2224));
-assertNull(res[782].exec("ee45", 2225));
-assertToStringEquals("abc4,abc", res[783].exec("abc45"), 2226);
-assertToStringEquals("abcabcabc4,abc", res[783].exec("abcabcabc45"), 2227);
-assertToStringEquals("4,", res[783].exec("42xyz "), 2228);
-assertNull(res[783].exec("*** Failers", 2229));
-assertToStringEquals("abc4,abc", res[784].exec("abc45"), 2230);
-assertToStringEquals("abcabcabc4,abc", res[784].exec("abcabcabc45"), 2231);
-assertNull(res[784].exec("*** Failers", 2232));
-assertNull(res[784].exec("42xyz ", 2233));
-assertToStringEquals("abc4,abc", res[785].exec("abc45"), 2234);
-assertToStringEquals("4,", res[785].exec("42xyz "), 2235);
-assertNull(res[785].exec("*** Failers", 2236));
-assertNull(res[785].exec("abcabcabc45", 2237));
-assertToStringEquals("abcabc4,abc", res[786].exec("abcabc45"), 2238);
-assertToStringEquals("abcabcabc4,abc", res[786].exec("abcabcabc45"), 2239);
-assertNull(res[786].exec("*** Failers", 2240));
-assertNull(res[786].exec("abcabcabcabc45", 2241));
-assertNull(res[786].exec("abc45", 2242));
-assertNull(res[786].exec("42xyz ", 2243));
-assertNull(res[786].exec("1abc2abc3456", 2244));
-assertNull(res[786].exec("1abc2xyz3456 ", 2245));
-assertToStringEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2246);
-assertToStringEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2247);
-assertNull(res[787].exec("abc", 2248));
-assertNull(res[787].exec("a(b)c", 2249));
-assertNull(res[787].exec("a(b(c))d  ", 2250));
-assertNull(res[787].exec("*** Failers)", 2251));
-assertNull(res[787].exec("a(b(c)d  ", 2252));
-assertNull(res[787].exec(">abc>123<xyz<", 2253));
-assertNull(res[787].exec(">abc>1(2)3<xyz<", 2254));
-assertNull(res[787].exec(">abc>(1(2)3)<xyz<", 2255));
-assertNull(res[787].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9876", 2256));
-assertNull(res[787].exec("*** Failers ", 2257));
-assertNull(res[787].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 2258));
-assertNull(res[787].exec("<>", 2259));
-assertNull(res[787].exec("<abcd>", 2260));
-assertNull(res[787].exec("<abc <123> hij>", 2261));
-assertNull(res[787].exec("<abc <def> hij>", 2262));
-assertNull(res[787].exec("<abc<>def> ", 2263));
-assertNull(res[787].exec("<abc<>      ", 2264));
-assertNull(res[787].exec("*** Failers", 2265));
-assertNull(res[787].exec("<abc", 2266));
-assertNull(res[787].exec("abc:                          ", 2267));
-assertNull(res[787].exec("12                             ", 2268));
-assertNull(res[787].exec("*** Failers                     ", 2269));
-assertNull(res[787].exec("123                       ", 2270));
-assertNull(res[787].exec("xyz                        ", 2271));
-assertNull(res[787].exec("                            ", 2272));
-assertNull(res[787].exec("abc:                        ", 2273));
-assertNull(res[787].exec("12         ", 2274));
-assertNull(res[787].exec("*** Failers", 2275));
-assertNull(res[787].exec("123", 2276));
-assertNull(res[787].exec("xyz    ", 2277));
-assertNull(res[788].exec("abcde:                          ", 2278));
-assertNull(res[788].exec("*** Failers                     ", 2279));
-assertNull(res[788].exec("abc.. ", 2280));
-assertNull(res[788].exec("123                       ", 2281));
-assertNull(res[788].exec("vwxyz                        ", 2282));
-assertNull(res[788].exec("                            ", 2283));
-assertNull(res[789].exec("12         ", 2284));
-assertNull(res[789].exec("*** Failers", 2285));
-assertNull(res[789].exec("abcde:", 2286));
-assertNull(res[789].exec("abc..  ", 2287));
-assertNull(res[789].exec("123", 2288));
-assertNull(res[789].exec("vwxyz    ", 2289));
-assertNull(res[789].exec("abc12345", 2290));
-assertNull(res[789].exec("wxy123z", 2291));
-assertNull(res[789].exec("*** Failers", 2292));
-assertNull(res[789].exec("123abc", 2293));
-assertNull(res[789].exec("123abc", 2294));
-assertNull(res[789].exec("mno123456 ", 2295));
-assertNull(res[789].exec("*** Failers", 2296));
-assertNull(res[789].exec("abc12345", 2297));
-assertNull(res[789].exec("wxy123z", 2298));
-assertNull(res[789].exec("abcxyz", 2299));
-assertNull(res[789].exec("123abcxyz999 ", 2300));
-assertToStringEquals("abc", res[791].exec("abcdef"), 2301);
-assertNull(res[791].exec("*** Failers", 2302));
-assertToStringEquals("abc", res[791].exec("abcdefB  "), 2303);
-assertToStringEquals(",", res[792].exec("bcd"), 2304);
-assertToStringEquals("aaa,aaa", res[792].exec("aaabcd"), 2305);
-assertToStringEquals(",", res[792].exec("xyz"), 2306);
-assertToStringEquals(",", res[792].exec("xyzN  "), 2307);
-assertToStringEquals(",", res[792].exec("*** Failers"), 2308);
-assertToStringEquals(",", res[792].exec("bcdN   "), 2309);
-assertToStringEquals("xyz", res[793].exec("xyz"), 2310);
-assertNull(res[793].exec("xyz\n", 2311));
-assertNull(res[793].exec("*** Failers", 2312));
-assertNull(res[793].exec("xyzZ", 2313));
-assertNull(res[793].exec("xyz\nZ    ", 2314));
-assertToStringEquals("xyz", res[794].exec("xyz"), 2315);
-assertToStringEquals("xyz", res[794].exec("xyz\n "), 2316);
-assertToStringEquals("xyz", res[794].exec("abcxyz\npqr "), 2317);
-assertToStringEquals("xyz", res[794].exec("abcxyz\npqrZ "), 2318);
-assertToStringEquals("xyz", res[794].exec("xyz\nZ    "), 2319);
-assertNull(res[794].exec("*** Failers", 2320));
-assertNull(res[794].exec("xyzZ", 2321));
-assertNull(res[795].exec("abcdef", 2322));
-assertNull(res[795].exec("defabcxyz>3 ", 2323));
-assertNull(res[795].exec("*** Failers ", 2324));
-assertNull(res[795].exec("defabcxyz", 2325));
-assertNull(res[796].exec("abP", 2326));
-assertNull(res[796].exec("abcdeP", 2327));
-assertToStringEquals("abcdef", res[796].exec("abcdefP"), 2328);
-assertNull(res[796].exec("*** Failers", 2329));
-assertNull(res[796].exec("abxP    ", 2330));
-assertNull(res[797].exec("aP", 2331));
-assertNull(res[797].exec("aaP", 2332));
-assertNull(res[797].exec("aa2P ", 2333));
-assertNull(res[797].exec("aaaP", 2334));
-assertNull(res[797].exec("aaa23P ", 2335));
-assertNull(res[797].exec("aaaa12345P", 2336));
-assertToStringEquals("aa0z", res[797].exec("aa0zP"), 2337);
-assertToStringEquals("aaaa4444444444444z", res[797].exec("aaaa4444444444444zP "), 2338);
-assertNull(res[797].exec("*** Failers", 2339));
-assertNull(res[797].exec("azP ", 2340));
-assertNull(res[797].exec("aaaaaP ", 2341));
-assertNull(res[797].exec("a56P ", 2342));
-assertNull(res[799].exec("adfadadaklhlkalkajhlkjahdfasdfasdfladsfjkjPZ", 2343));
-assertNull(res[799].exec("lkjhlkjhlkjhlkjhabbbbbbcdaefabbbbbbbefaPBZ", 2344));
-assertNull(res[799].exec("cdabbbbbbbbPRBZ", 2345));
-assertNull(res[799].exec("efabbbbbbbbbbbbbbbbPRBZ", 2346));
-assertNull(res[799].exec("bbbbbbbbbbbbcdXyasdfadfPRBZ    ", 2347));
-assertNull(res[799].exec("abc", 2348));
-assertNull(res[799].exec("** Failers", 2349));
-assertNull(res[799].exec("def  ", 2350));
-assertToStringEquals("the quick brown fox", res[800].exec("the quick brown fox"), 2351);
-assertNull(res[800].exec("The quick brown FOX", 2352));
-assertToStringEquals("the quick brown fox", res[800].exec("What do you know about the quick brown fox?"), 2353);
-assertNull(res[800].exec("What do you know about THE QUICK BROWN FOX?", 2354));
-assertToStringEquals("the quick brown fox", res[801].exec("the quick brown fox"), 2355);
-assertToStringEquals("The quick brown FOX", res[801].exec("The quick brown FOX"), 2356);
-assertToStringEquals("the quick brown fox", res[801].exec("What do you know about the quick brown fox?"), 2357);
-assertToStringEquals("THE QUICK BROWN FOX", res[801].exec("What do you know about THE QUICK BROWN FOX?"), 2358);
-assertToStringEquals("abcd\x09\n\x0d\x0cae9;$\\?caxyz", res[802].exec("abcd\x09\n\x0d\x0cae9;$\\?caxyz"), 2359);
-assertToStringEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2360);
-assertToStringEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2361);
-assertToStringEquals("aabxyzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzpqrrrabbxyyyypqAzz"), 2362);
-assertToStringEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzpqrrrabbxyyyypqAzz"), 2363);
-assertToStringEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzpqrrrabbxyyyypqAzz"), 2364);
-assertToStringEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzpqrrrabbxyyyypqAzz"), 2365);
-assertToStringEquals("aabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzpqrrrabbxyyyypqAzz"), 2366);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypAzz"), 2367);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqAzz"), 2368);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqAzz"), 2369);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqAzz"), 2370);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqAzz"), 2371);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqAzz"), 2372);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqAzz"), 2373);
-assertToStringEquals("aaaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzpqrrrabbxyyyypqAzz"), 2374);
-assertToStringEquals("abxyzzpqrrrabbxyyyypqAzz", res[803].exec("abxyzzpqrrrabbxyyyypqAzz"), 2375);
-assertToStringEquals("aabxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzzzpqrrrabbxyyyypqAzz"), 2376);
-assertToStringEquals("aaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzzzzpqrrrabbxyyyypqAzz"), 2377);
-assertToStringEquals("aaaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzzzzpqrrrabbxyyyypqAzz"), 2378);
-assertToStringEquals("abcxyzzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzzpqrrrabbxyyyypqAzz"), 2379);
-assertToStringEquals("aabcxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzzzpqrrrabbxyyyypqAzz"), 2380);
-assertToStringEquals("aaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzzzzpqrrrabbxyyyypqAzz"), 2381);
-assertToStringEquals("aaaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbxyyyypqAzz"), 2382);
-assertToStringEquals("aaaabcxyzzzzpqrrrabbbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyypqAzz"), 2383);
-assertToStringEquals("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz"), 2384);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypABzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABzz"), 2385);
-assertToStringEquals("aaabcxyzpqrrrabbxyyyypABBzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABBzz"), 2386);
-assertToStringEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>aaabxyzpqrrrabbxyyyypqAzz"), 2387);
-assertToStringEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">aaaabxyzpqrrrabbxyyyypqAzz"), 2388);
-assertToStringEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>>abcxyzpqrrrabbxyyyypqAzz"), 2389);
-assertNull(res[803].exec("*** Failers", 2390));
-assertNull(res[803].exec("abxyzpqrrabbxyyyypqAzz", 2391));
-assertNull(res[803].exec("abxyzpqrrrrabbxyyyypqAzz", 2392));
-assertNull(res[803].exec("abxyzpqrrrabxyyyypqAzz", 2393));
-assertNull(res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz", 2394));
-assertNull(res[803].exec("aaaabcxyzzzzpqrrrabbbxyyypqAzz", 2395));
-assertNull(res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqqAzz", 2396));
-assertToStringEquals("abczz,abc", res[804].exec("abczz"), 2397);
-assertToStringEquals("abcabczz,abc", res[804].exec("abcabczz"), 2398);
-assertNull(res[804].exec("*** Failers", 2399));
-assertNull(res[804].exec("zz", 2400));
-assertNull(res[804].exec("abcabcabczz", 2401));
-assertNull(res[804].exec(">>abczz", 2402));
-assertToStringEquals("bc,b", res[805].exec("bc"), 2403);
-assertToStringEquals("bbc,b", res[805].exec("bbc"), 2404);
-assertToStringEquals("bbbc,bb", res[805].exec("bbbc"), 2405);
-assertToStringEquals("bac,a", res[805].exec("bac"), 2406);
-assertToStringEquals("bbac,a", res[805].exec("bbac"), 2407);
-assertToStringEquals("aac,a", res[805].exec("aac"), 2408);
-assertToStringEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[805].exec("abbbbbbbbbbbc"), 2409);
-assertToStringEquals("bbbbbbbbbbbac,a", res[805].exec("bbbbbbbbbbbac"), 2410);
-assertNull(res[805].exec("*** Failers", 2411));
-assertNull(res[805].exec("aaac", 2412));
-assertNull(res[805].exec("abbbbbbbbbbbac", 2413));
-assertToStringEquals("bc,b", res[806].exec("bc"), 2414);
-assertToStringEquals("bbc,bb", res[806].exec("bbc"), 2415);
-assertToStringEquals("bbbc,bbb", res[806].exec("bbbc"), 2416);
-assertToStringEquals("bac,a", res[806].exec("bac"), 2417);
-assertToStringEquals("bbac,a", res[806].exec("bbac"), 2418);
-assertToStringEquals("aac,a", res[806].exec("aac"), 2419);
-assertToStringEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[806].exec("abbbbbbbbbbbc"), 2420);
-assertToStringEquals("bbbbbbbbbbbac,a", res[806].exec("bbbbbbbbbbbac"), 2421);
-assertNull(res[806].exec("*** Failers", 2422));
-assertNull(res[806].exec("aaac", 2423));
-assertNull(res[806].exec("abbbbbbbbbbbac", 2424));
-assertToStringEquals("bbc,bb", res[806].exec("bbc"), 2425);
-assertToStringEquals("babc,ba", res[807].exec("babc"), 2426);
-assertToStringEquals("bbabc,ba", res[807].exec("bbabc"), 2427);
-assertToStringEquals("bababc,ba", res[807].exec("bababc"), 2428);
-assertNull(res[807].exec("*** Failers", 2429));
-assertNull(res[807].exec("bababbc", 2430));
-assertNull(res[807].exec("babababc", 2431));
-assertToStringEquals("babc,ba", res[808].exec("babc"), 2432);
-assertToStringEquals("bbabc,ba", res[808].exec("bbabc"), 2433);
-assertToStringEquals("bababc,ba", res[808].exec("bababc"), 2434);
-assertNull(res[808].exec("*** Failers", 2435));
-assertNull(res[808].exec("bababbc", 2436));
-assertNull(res[808].exec("babababc", 2437));
+assertEquals(null, res[443].exec("aaaa", 885));
+assertEquals(null, res[443].exec("bacxxx", 886));
+assertEquals(null, res[443].exec("bbaccxxx ", 887));
+assertEquals(null, res[443].exec("bbbacccxx", 888));
+assertEquals(null, res[443].exec("aaaa", 889));
+assertEquals(null, res[443].exec("bacxxx", 890));
+assertEquals(null, res[443].exec("bbaccxxx ", 891));
+assertEquals(null, res[443].exec("bbbacccxx", 892));
+assertEquals("a,a", res[444].exec("aaaa"), 893);
+assertEquals(null, res[444].exec("bacxxx", 894));
+assertEquals(null, res[444].exec("bbaccxxx ", 895));
+assertEquals(null, res[444].exec("bbbacccxx", 896));
+assertEquals("a,a", res[445].exec("aaaa"), 897);
+assertEquals(null, res[445].exec("bacxxx", 898));
+assertEquals(null, res[445].exec("bbaccxxx ", 899));
+assertEquals(null, res[445].exec("bbbacccxx", 900));
+assertEquals("a,a", res[446].exec("aaaa"), 901);
+assertEquals(null, res[446].exec("bacxxx", 902));
+assertEquals(null, res[446].exec("bbaccxxx ", 903));
+assertEquals(null, res[446].exec("bbbacccxx", 904));
+assertEquals("a,a,a", res[447].exec("aaaa"), 905);
+assertEquals(null, res[447].exec("bacxxx", 906));
+assertEquals(null, res[447].exec("bbaccxxx ", 907));
+assertEquals(null, res[447].exec("bbbacccxx", 908));
+assertEquals(null, res[449].exec("bacxxx", 909));
+assertEquals(null, res[449].exec("XaaX", 910));
+assertEquals(null, res[449].exec("XAAX ", 911));
+assertEquals(null, res[449].exec("XaaX", 912));
+assertEquals(null, res[449].exec("** Failers ", 913));
+assertEquals(null, res[449].exec("XAAX ", 914));
+assertEquals(null, res[449].exec("XaaX", 915));
+assertEquals(null, res[449].exec("XAAX ", 916));
+assertEquals(null, res[449].exec("xzxx", 917));
+assertEquals(null, res[449].exec("yzyy ", 918));
+assertEquals(null, res[449].exec("** Failers", 919));
+assertEquals(null, res[449].exec("xxz  ", 920));
+assertEquals("a,,,a", res[450].exec("cat"), 921);
+assertEquals("a,,,a", res[451].exec("cat"), 922);
+assertEquals("TA]", res[452].exec("The ACTA] comes "), 923);
+assertEquals("TA]", res[453].exec("The ACTA] comes "), 924);
+assertEquals(null, res[453].exec("abcbabc", 925));
+assertEquals(null, res[453].exec("abcbabc", 926));
+assertEquals(null, res[453].exec("abcbabc", 927));
+assertEquals(null, res[453].exec("** Failers ", 928));
+assertEquals(null, res[453].exec("abcXabc", 929));
+assertEquals(null, res[453].exec("abcXabc", 930));
+assertEquals(null, res[453].exec("** Failers ", 931));
+assertEquals(null, res[453].exec("abcbabc", 932));
+assertEquals(null, res[453].exec("xyzbabcxyz", 933));
+assertEquals(null, res[456].exec("** Failers", 934));
+assertEquals(null, res[456].exec("ab", 935));
+assertEquals(null, res[457].exec("** Failers", 936));
+assertEquals(null, res[457].exec("ab ", 937));
+assertEquals(null, res[457].exec("** Failers", 938));
+assertEquals(null, res[457].exec("ab ", 939));
+assertEquals("aXb", res[458].exec("aXb"), 940);
+assertEquals("a\nb", res[458].exec("a\nb "), 941);
+assertEquals(null, res[458].exec("** Failers", 942));
+assertEquals(null, res[458].exec("ab  ", 943));
+assertEquals("aXb", res[459].exec("aXb"), 944);
+assertEquals("a\nX\nXb", res[459].exec("a\nX\nXb "), 945);
+assertEquals(null, res[459].exec("** Failers", 946));
+assertEquals(null, res[459].exec("ab  ", 947));
+assertEquals("acb", res[463].exec("acb"), 948);
+assertEquals("ab", res[463].exec("ab"), 949);
+assertEquals(null, res[463].exec("ax{100}b ", 950));
+assertEquals(null, res[463].exec("*** Failers", 951));
+assertEquals(null, res[463].exec("a\nb  ", 952));
+assertEquals(null, res[464].exec("ax{4000}xyb ", 953));
+assertEquals(null, res[464].exec("ax{4000}yb ", 954));
+assertEquals(null, res[464].exec("ax{4000}x{100}yb ", 955));
+assertEquals(null, res[464].exec("*** Failers", 956));
+assertEquals(null, res[464].exec("ax{4000}b ", 957));
+assertEquals(null, res[464].exec("ac\ncb ", 958));
+assertEquals("a\xc0,,\xc0", res[465].exec("a\xc0\x88b"), 959);
+assertEquals("ax,,x", res[466].exec("ax{100}b"), 960);
+assertEquals("a\xc0\x88b,\xc0\x88,b", res[467].exec("a\xc0\x88b"), 961);
+assertEquals("ax{100}b,x{100},b", res[468].exec("ax{100}b"), 962);
+assertEquals("a\xc0\x92,\xc0,\x92", res[469].exec("a\xc0\x92bcd"), 963);
+assertEquals("ax{,x,{", res[470].exec("ax{240}bcd"), 964);
+assertEquals("a\xc0\x92,\xc0,\x92", res[471].exec("a\xc0\x92bcd"), 965);
+assertEquals("ax{,x,{", res[472].exec("ax{240}bcd"), 966);
+assertEquals("a\xc0,,\xc0", res[473].exec("a\xc0\x92bcd"), 967);
+assertEquals("ax,,x", res[474].exec("ax{240}bcd"), 968);
+assertEquals(null, res[475].exec("ax{1234}xyb ", 969));
+assertEquals(null, res[475].exec("ax{1234}x{4321}yb ", 970));
+assertEquals(null, res[475].exec("ax{1234}x{4321}x{3412}b ", 971));
+assertEquals(null, res[475].exec("*** Failers", 972));
+assertEquals(null, res[475].exec("ax{1234}b ", 973));
+assertEquals(null, res[475].exec("ac\ncb ", 974));
+assertEquals("ax{1234}xyb,x{1234}xy", res[476].exec("ax{1234}xyb "), 975);
+assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[476].exec("ax{1234}x{4321}yb "), 976);
+assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[476].exec("ax{1234}x{4321}x{3412}b "), 977);
+assertEquals("axxxxbcdefghijb,xxxxbcdefghij", res[476].exec("axxxxbcdefghijb "), 978);
+assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[476].exec("ax{1234}x{4321}x{3412}x{3421}b "), 979);
+assertEquals(null, res[476].exec("*** Failers", 980));
+assertEquals("ax{1234}b,x{1234}", res[476].exec("ax{1234}b "), 981);
+assertEquals("ax{1234}xyb,x{1234}xy", res[477].exec("ax{1234}xyb "), 982);
+assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[477].exec("ax{1234}x{4321}yb "), 983);
+assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[477].exec("ax{1234}x{4321}x{3412}b "), 984);
+assertEquals("axxxxb,xxxx", res[477].exec("axxxxbcdefghijb "), 985);
+assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[477].exec("ax{1234}x{4321}x{3412}x{3421}b "), 986);
+assertEquals(null, res[477].exec("*** Failers", 987));
+assertEquals("ax{1234}b,x{1234}", res[477].exec("ax{1234}b "), 988);
+assertEquals(null, res[478].exec("ax{1234}xyb ", 989));
+assertEquals(null, res[478].exec("ax{1234}x{4321}yb ", 990));
+assertEquals(null, res[478].exec("ax{1234}x{4321}x{3412}b ", 991));
+assertEquals("axxxxb,xxxx", res[478].exec("axxxxbcdefghijb "), 992);
+assertEquals(null, res[478].exec("ax{1234}x{4321}x{3412}x{3421}b ", 993));
+assertEquals("axbxxb,xbxx", res[478].exec("axbxxbcdefghijb "), 994);
+assertEquals("axxxxxb,xxxxx", res[478].exec("axxxxxbcdefghijb "), 995);
+assertEquals(null, res[478].exec("*** Failers", 996));
+assertEquals(null, res[478].exec("ax{1234}b ", 997));
+assertEquals(null, res[478].exec("axxxxxxbcdefghijb ", 998));
+assertEquals(null, res[479].exec("ax{1234}xyb ", 999));
+assertEquals(null, res[479].exec("ax{1234}x{4321}yb ", 1000));
+assertEquals(null, res[479].exec("ax{1234}x{4321}x{3412}b ", 1001));
+assertEquals("axxxxb,xxxx", res[479].exec("axxxxbcdefghijb "), 1002);
+assertEquals(null, res[479].exec("ax{1234}x{4321}x{3412}x{3421}b ", 1003));
+assertEquals("axbxxb,xbxx", res[479].exec("axbxxbcdefghijb "), 1004);
+assertEquals("axxxxxb,xxxxx", res[479].exec("axxxxxbcdefghijb "), 1005);
+assertEquals(null, res[479].exec("*** Failers", 1006));
+assertEquals(null, res[479].exec("ax{1234}b ", 1007));
+assertEquals(null, res[479].exec("axxxxxxbcdefghijb ", 1008));
+assertEquals(null, res[479].exec("*** Failers", 1009));
+assertEquals(null, res[479].exec("x{100}", 1010));
+assertEquals(null, res[479].exec("aXbcd", 1011));
+assertEquals(null, res[479].exec("ax{100}bcd", 1012));
+assertEquals(null, res[479].exec("ax{100000}bcd", 1013));
+assertEquals(null, res[479].exec("x{100}x{100}x{100}b", 1014));
+assertEquals(null, res[479].exec("*** Failers ", 1015));
+assertEquals(null, res[479].exec("x{100}x{100}b", 1016));
+assertEquals(null, res[479].exec("x{ab} ", 1017));
+assertEquals(null, res[479].exec("\xc2\xab", 1018));
+assertEquals(null, res[479].exec("*** Failers ", 1019));
+assertEquals(null, res[479].exec("\x00{ab}", 1020));
+assertEquals(null, res[479].exec("WXYZ", 1021));
+assertEquals(null, res[479].exec("x{256}XYZ ", 1022));
+assertEquals(null, res[479].exec("*** Failers", 1023));
+assertEquals(null, res[479].exec("XYZ ", 1024));
+assertEquals(null, res[480].exec("Xx{1234}", 1025));
+assertEquals(null, res[481].exec("Xx{1234}YZ", 1026));
+assertEquals("X", res[482].exec("XYZabcdce"), 1027);
+assertEquals("X", res[483].exec("XYZabcde"), 1028);
+assertEquals(null, res[484].exec("Xabcdefg   ", 1029));
+assertEquals(null, res[484].exec("Xx{1234} ", 1030));
+assertEquals(null, res[484].exec("Xx{1234}YZ", 1031));
+assertEquals(null, res[484].exec("Xx{1234}x{512}  ", 1032));
+assertEquals(null, res[484].exec("Xx{1234}x{512}YZ", 1033));
+assertEquals(null, res[485].exec("Xabcdefg   ", 1034));
+assertEquals(null, res[485].exec("Xx{1234} ", 1035));
+assertEquals(null, res[485].exec("Xx{1234}YZ", 1036));
+assertEquals(null, res[485].exec("Xx{1234}x{512}  ", 1037));
+assertEquals("bcd", res[486].exec("bcd"), 1038);
+assertEquals("00}", res[486].exec("x{100}aYx{256}Z "), 1039);
+assertEquals("x{", res[487].exec("x{100}bc"), 1040);
+assertEquals("x{100}bcA", res[488].exec("x{100}bcAa"), 1041);
+assertEquals("x{", res[489].exec("x{100}bca"), 1042);
+assertEquals("bcd", res[490].exec("bcd"), 1043);
+assertEquals("00}", res[490].exec("x{100}aYx{256}Z "), 1044);
+assertEquals("x{", res[491].exec("x{100}bc"), 1045);
+assertEquals("x{100}bc", res[492].exec("x{100}bcAa"), 1046);
+assertEquals("x{", res[493].exec("x{100}bca"), 1047);
+assertEquals(null, res[493].exec("abcd", 1048));
+assertEquals(null, res[493].exec("abcd", 1049));
+assertEquals("x{", res[493].exec("x{100}x{100} "), 1050);
+assertEquals("x{", res[493].exec("x{100}x{100} "), 1051);
+assertEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1052);
+assertEquals(null, res[493].exec("abce", 1053));
+assertEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1054);
+assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1055));
+assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1056));
+assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1057));
+assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}XX", 1058));
+assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1059));
+assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1060));
+assertEquals("Xy", res[493].exec("Xyyyax{100}x{100}bXzzz"), 1061);
+assertEquals("X", res[496].exec("1X2"), 1062);
+assertEquals("x", res[496].exec("1x{100}2 "), 1063);
+assertEquals(">X", res[497].exec("> >X Y"), 1064);
+assertEquals(">x", res[497].exec("> >x{100} Y"), 1065);
+assertEquals("1", res[498].exec("x{100}3"), 1066);
+assertEquals(" ", res[499].exec("x{100} X"), 1067);
+assertEquals("abcd", res[500].exec("12abcd34"), 1068);
+assertEquals("*** Failers", res[500].exec("*** Failers"), 1069);
+assertEquals("  ", res[500].exec("1234  "), 1070);
+assertEquals("abc", res[501].exec("12abcd34"), 1071);
+assertEquals("ab", res[501].exec("12ab34"), 1072);
+assertEquals("***", res[501].exec("*** Failers  "), 1073);
+assertEquals(null, res[501].exec("1234", 1074));
+assertEquals("  ", res[501].exec("12a34  "), 1075);
+assertEquals("ab", res[502].exec("12abcd34"), 1076);
+assertEquals("ab", res[502].exec("12ab34"), 1077);
+assertEquals("**", res[502].exec("*** Failers  "), 1078);
+assertEquals(null, res[502].exec("1234", 1079));
+assertEquals("  ", res[502].exec("12a34  "), 1080);
+assertEquals("12", res[503].exec("12abcd34"), 1081);
+assertEquals(null, res[503].exec("*** Failers", 1082));
+assertEquals("12", res[504].exec("12abcd34"), 1083);
+assertEquals("123", res[504].exec("1234abcd"), 1084);
+assertEquals(null, res[504].exec("*** Failers  ", 1085));
+assertEquals(null, res[504].exec("1.4 ", 1086));
+assertEquals("12", res[505].exec("12abcd34"), 1087);
+assertEquals("12", res[505].exec("1234abcd"), 1088);
+assertEquals(null, res[505].exec("*** Failers  ", 1089));
+assertEquals(null, res[505].exec("1.4 ", 1090));
+assertEquals("12abcd34", res[506].exec("12abcd34"), 1091);
+assertEquals("***", res[506].exec("*** Failers"), 1092);
+assertEquals(null, res[506].exec("     ", 1093));
+assertEquals("12a", res[507].exec("12abcd34"), 1094);
+assertEquals("123", res[507].exec("1234abcd"), 1095);
+assertEquals("***", res[507].exec("*** Failers"), 1096);
+assertEquals(null, res[507].exec("       ", 1097));
+assertEquals("12", res[508].exec("12abcd34"), 1098);
+assertEquals("12", res[508].exec("1234abcd"), 1099);
+assertEquals("**", res[508].exec("*** Failers"), 1100);
+assertEquals(null, res[508].exec("       ", 1101));
+assertEquals(">      <", res[509].exec("12>      <34"), 1102);
+assertEquals(null, res[509].exec("*** Failers", 1103));
+assertEquals(">  <", res[510].exec("ab>  <cd"), 1104);
+assertEquals(">   <", res[510].exec("ab>   <ce"), 1105);
+assertEquals(null, res[510].exec("*** Failers", 1106));
+assertEquals(null, res[510].exec("ab>    <cd ", 1107));
+assertEquals(">  <", res[511].exec("ab>  <cd"), 1108);
+assertEquals(">   <", res[511].exec("ab>   <ce"), 1109);
+assertEquals(null, res[511].exec("*** Failers", 1110));
+assertEquals(null, res[511].exec("ab>    <cd ", 1111));
+assertEquals("12", res[512].exec("12      34"), 1112);
+assertEquals("Failers", res[512].exec("*** Failers"), 1113);
+assertEquals(null, res[512].exec("+++=*! ", 1114));
+assertEquals("ab", res[513].exec("ab  cd"), 1115);
+assertEquals("abc", res[513].exec("abcd ce"), 1116);
+assertEquals("Fai", res[513].exec("*** Failers"), 1117);
+assertEquals(null, res[513].exec("a.b.c", 1118));
+assertEquals("ab", res[514].exec("ab  cd"), 1119);
+assertEquals("ab", res[514].exec("abcd ce"), 1120);
+assertEquals("Fa", res[514].exec("*** Failers"), 1121);
+assertEquals(null, res[514].exec("a.b.c", 1122));
+assertEquals("====", res[515].exec("12====34"), 1123);
+assertEquals("*** ", res[515].exec("*** Failers"), 1124);
+assertEquals(" ", res[515].exec("abcd "), 1125);
+assertEquals("===", res[516].exec("ab====cd"), 1126);
+assertEquals("==", res[516].exec("ab==cd"), 1127);
+assertEquals("***", res[516].exec("*** Failers"), 1128);
+assertEquals(null, res[516].exec("a.b.c", 1129));
+assertEquals("==", res[517].exec("ab====cd"), 1130);
+assertEquals("==", res[517].exec("ab==cd"), 1131);
+assertEquals("**", res[517].exec("*** Failers"), 1132);
+assertEquals(null, res[517].exec("a.b.c", 1133));
+assertEquals(null, res[517].exec("x{100}", 1134));
+assertEquals(null, res[517].exec("Zx{100}", 1135));
+assertEquals(null, res[517].exec("x{100}Z", 1136));
+assertEquals("**", res[517].exec("*** Failers "), 1137);
+assertEquals(null, res[517].exec("Zx{100}", 1138));
+assertEquals(null, res[517].exec("x{100}", 1139));
+assertEquals(null, res[517].exec("x{100}Z", 1140));
+assertEquals("**", res[517].exec("*** Failers "), 1141);
+assertEquals(null, res[517].exec("abcx{200}X", 1142));
+assertEquals(null, res[517].exec("abcx{100}X ", 1143));
+assertEquals("**", res[517].exec("*** Failers"), 1144);
+assertEquals("  ", res[517].exec("X  "), 1145);
+assertEquals(null, res[517].exec("abcx{200}X", 1146));
+assertEquals(null, res[517].exec("abcx{100}X ", 1147));
+assertEquals(null, res[517].exec("abQX ", 1148));
+assertEquals("**", res[517].exec("*** Failers"), 1149);
+assertEquals("  ", res[517].exec("X  "), 1150);
+assertEquals(null, res[517].exec("abcx{100}x{200}x{100}X", 1151));
+assertEquals("**", res[517].exec("*** Failers"), 1152);
+assertEquals(null, res[517].exec("abcx{200}X", 1153));
+assertEquals("  ", res[517].exec("X  "), 1154);
+assertEquals(null, res[517].exec("AX", 1155));
+assertEquals(null, res[517].exec("x{150}X", 1156));
+assertEquals(null, res[517].exec("x{500}X ", 1157));
+assertEquals("**", res[517].exec("*** Failers"), 1158);
+assertEquals(null, res[517].exec("x{100}X", 1159));
+assertEquals("  ", res[517].exec("x{200}X   "), 1160);
+assertEquals(null, res[517].exec("AX", 1161));
+assertEquals(null, res[517].exec("x{150}X", 1162));
+assertEquals(null, res[517].exec("x{500}X ", 1163));
+assertEquals("**", res[517].exec("*** Failers"), 1164);
+assertEquals(null, res[517].exec("x{100}X", 1165));
+assertEquals("  ", res[517].exec("x{200}X   "), 1166);
+assertEquals(null, res[517].exec("QX ", 1167));
+assertEquals(null, res[517].exec("AX", 1168));
+assertEquals(null, res[517].exec("x{500}X ", 1169));
+assertEquals("**", res[517].exec("*** Failers"), 1170);
+assertEquals(null, res[517].exec("x{100}X", 1171));
+assertEquals(null, res[517].exec("x{150}X", 1172));
+assertEquals("  ", res[517].exec("x{200}X   "), 1173);
+assertEquals(null, res[518].exec("aXb", 1174));
+assertEquals(null, res[518].exec("a\nb", 1175));
+assertEquals(null, res[519].exec("aXb", 1176));
+assertEquals(null, res[519].exec("a\nb", 1177));
+assertEquals(null, res[519].exec("*** Failers ", 1178));
+assertEquals(null, res[519].exec("ax{100}b ", 1179));
+assertEquals(null, res[519].exec("z", 1180));
+assertEquals(null, res[519].exec("Z ", 1181));
+assertEquals(null, res[519].exec("x{100}", 1182));
+assertEquals(null, res[519].exec("*** Failers", 1183));
+assertEquals(null, res[519].exec("x{102}", 1184));
+assertEquals(null, res[519].exec("y    ", 1185));
+assertEquals("\xff", res[520].exec(">\xff<"), 1186);
+assertEquals(null, res[521].exec(">x{ff}<", 1187));
+assertEquals("X", res[522].exec("XYZ"), 1188);
+assertEquals("X", res[523].exec("XYZ"), 1189);
+assertEquals("x", res[523].exec("x{123} "), 1190);
+assertEquals(",", res[528].exec("catac"), 1191);
+assertEquals(",", res[528].exec("ax{256}a "), 1192);
+assertEquals(",", res[528].exec("x{85}"), 1193);
+assertEquals(",", res[528].exec("\u1234 "), 1194);
+assertEquals(",", res[528].exec("\u1234 "), 1195);
+assertEquals(",", res[528].exec("abcdefg"), 1196);
+assertEquals(",", res[528].exec("ab"), 1197);
+assertEquals(",", res[528].exec("a "), 1198);
+assertEquals("Ax", res[529].exec("Ax{a3}BC"), 1199);
+assertEquals("Ax", res[530].exec("Ax{a3}BC"), 1200);
+assertEquals("}=", res[531].exec("+x{a3}== "), 1201);
+assertEquals("}=", res[532].exec("+x{a3}== "), 1202);
+assertEquals("x", res[533].exec("x{442}x{435}x{441}x{442}"), 1203);
+assertEquals("x", res[534].exec("x{442}x{435}x{441}x{442}"), 1204);
+assertEquals("x", res[535].exec("x{442}x{435}x{441}x{442}"), 1205);
+assertEquals("x", res[536].exec("x{442}x{435}x{441}x{442}"), 1206);
+assertEquals("{", res[537].exec("x{2442}x{2435}x{2441}x{2442}"), 1207);
+assertEquals("{", res[538].exec("x{2442}x{2435}x{2441}x{2442}"), 1208);
+assertEquals("abc\n\x0dx{442}x{435}x{441}x{442}xyz ", res[539].exec("abc\n\x0dx{442}x{435}x{441}x{442}xyz "), 1209);
+assertEquals("x{442}x{435}x{441}x{442}", res[539].exec("x{442}x{435}x{441}x{442}"), 1210);
+assertEquals("c d", res[540].exec("abc defx{442}x{443}xyz\npqr"), 1211);
+assertEquals("c d", res[541].exec("abc defx{442}x{443}xyz\npqr"), 1212);
+assertEquals(null, res[542].exec("+x{2442}", 1213));
+assertEquals(null, res[543].exec("+x{2442}", 1214));
+assertEquals(null, res[544].exec("Ax{442}", 1215));
+assertEquals(null, res[545].exec("Ax{442}", 1216));
+assertEquals(null, res[546].exec("Ax{442}", 1217));
+assertEquals(null, res[547].exec("Ax{442}", 1218));
+assertEquals(null, res[548].exec("\x19x{e01ff}", 1219));
+assertEquals(null, res[549].exec("Ax{422}", 1220));
+assertEquals(null, res[550].exec("x{19}x{e01ff}", 1221));
+assertEquals(null, res[551].exec("Ax{442}", 1222));
+assertEquals(null, res[552].exec("Ax{442}", 1223));
+assertEquals(null, res[553].exec("ax{442}", 1224));
+assertEquals(null, res[554].exec("+x{2442}", 1225));
+assertEquals(null, res[555].exec("Mx{442}", 1226));
+assertEquals("abc", res[556].exec("abc"), 1227);
+assertEquals("abc", res[557].exec("abc"), 1228);
+assertEquals("abc", res[558].exec("abc"), 1229);
+assertEquals("abc", res[559].exec("abc"), 1230);
+assertEquals(null, res[560].exec("x{100}ax{1234}bcd", 1231));
+assertEquals(null, res[562].exec("x{0041}x{2262}x{0391}x{002e}", 1232));
+assertEquals(null, res[562].exec("x{D55c}x{ad6d}x{C5B4} ", 1233));
+assertEquals(null, res[562].exec("x{65e5}x{672c}x{8a9e}", 1234));
+assertEquals("{861}X", res[563].exec("x{212ab}x{212ab}x{212ab}x{861}X"), 1235);
+assertEquals("x{2", res[564].exec("x{212ab}x{212ab}x{212ab}x{861}"), 1236);
+assertEquals("x{c", res[564].exec("x{c0}b"), 1237);
+assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1238);
+assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1239);
+assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1240);
+assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1241);
+assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1242);
+assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1243);
+assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1244);
+assertEquals("Sho", res[564].exec("Should produce an error diagnostic"), 1245);
+assertEquals(null, res[565].exec("Xx{1234}", 1246));
+assertEquals(null, res[565].exec("X\nabc ", 1247));
+assertEquals("b", res[566].exec("bar"), 1248);
+assertEquals(null, res[566].exec("*** Failers", 1249));
+assertEquals(null, res[566].exec("c", 1250));
+assertEquals(null, res[566].exec("x{ff}", 1251));
+assertEquals(null, res[566].exec("x{100}  ", 1252));
+assertEquals("c", res[567].exec("c"), 1253);
+assertEquals("x", res[567].exec("x{ff}"), 1254);
+assertEquals("x", res[567].exec("x{100}  "), 1255);
+assertEquals("*", res[567].exec("*** Failers "), 1256);
+assertEquals(null, res[567].exec("aaa", 1257));
+assertEquals("x", res[568].exec("x{f1}"), 1258);
+assertEquals("x", res[568].exec("x{bf}"), 1259);
+assertEquals("x", res[568].exec("x{100}"), 1260);
+assertEquals("x", res[568].exec("x{1000}   "), 1261);
+assertEquals("*", res[568].exec("*** Failers"), 1262);
+assertEquals("x", res[568].exec("x{c0} "), 1263);
+assertEquals("x", res[568].exec("x{f0} "), 1264);
+assertEquals("1", res[568].exec("1234"), 1265);
+assertEquals("\"", res[568].exec("\"1234\" "), 1266);
+assertEquals("x", res[568].exec("x{100}1234"), 1267);
+assertEquals("\"", res[568].exec("\"x{100}1234\"  "), 1268);
+assertEquals("x", res[568].exec("x{100}x{100}12ab "), 1269);
+assertEquals("x", res[568].exec("x{100}x{100}\"12\" "), 1270);
+assertEquals("*", res[568].exec("*** Failers "), 1271);
+assertEquals("x", res[568].exec("x{100}x{100}abcd"), 1272);
+assertEquals("A", res[568].exec("A"), 1273);
+assertEquals("x", res[568].exec("x{100}"), 1274);
+assertEquals("Z", res[568].exec("Zx{100}"), 1275);
+assertEquals("x", res[568].exec("x{100}Z"), 1276);
+assertEquals("*", res[568].exec("*** Failers "), 1277);
+assertEquals("Z", res[568].exec("Zx{100}"), 1278);
+assertEquals("x", res[568].exec("x{100}"), 1279);
+assertEquals("x", res[568].exec("x{100}Z"), 1280);
+assertEquals("*", res[568].exec("*** Failers "), 1281);
+assertEquals("x", res[568].exec("x{100}"), 1282);
+assertEquals("x", res[568].exec("x{104}"), 1283);
+assertEquals("*", res[568].exec("*** Failers"), 1284);
+assertEquals("x", res[568].exec("x{105}"), 1285);
+assertEquals("x", res[568].exec("x{ff}    "), 1286);
+assertEquals("x", res[568].exec("x{100}"), 1287);
+assertEquals("\u0100", res[568].exec("\u0100 "), 1288);
+assertEquals("\xff", res[569].exec(">\xff<"), 1289);
+assertEquals(null, res[570].exec(">x{ff}<", 1290));
+assertEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1291);
+assertEquals("x", res[572].exec("x{d6}"), 1292);
+assertEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1293);
+assertEquals("x", res[572].exec("x{d6}"), 1294);
+assertEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1295);
+assertEquals("x", res[572].exec("x{d6} "), 1296);
+assertEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1297);
+assertEquals("x", res[572].exec("x{d6} "), 1298);
+assertEquals("\ufffd", res[572].exec("\ufffd]"), 1299);
+assertEquals("\ufffd", res[572].exec("\ufffd"), 1300);
+assertEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd"), 1301);
+assertEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd?"), 1302);
+assertEquals(null, res[573].exec("\xc0\x80", 1303));
+assertEquals(null, res[573].exec("\xc1\x8f ", 1304));
+assertEquals(null, res[573].exec("\xe0\x9f\x80", 1305));
+assertEquals(null, res[573].exec("\xf0\x8f\x80\x80 ", 1306));
+assertEquals(null, res[573].exec("\xf8\x87\x80\x80\x80  ", 1307));
+assertEquals(null, res[573].exec("\xfc\x83\x80\x80\x80\x80", 1308));
+assertEquals(null, res[573].exec("\xfe\x80\x80\x80\x80\x80  ", 1309));
+assertEquals(null, res[573].exec("\xff\x80\x80\x80\x80\x80  ", 1310));
+assertEquals(null, res[573].exec("\xc3\x8f", 1311));
+assertEquals(null, res[573].exec("\xe0\xaf\x80", 1312));
+assertEquals(null, res[573].exec("\xe1\x80\x80", 1313));
+assertEquals(null, res[573].exec("\xf0\x9f\x80\x80 ", 1314));
+assertEquals(null, res[573].exec("\xf1\x8f\x80\x80 ", 1315));
+assertEquals(null, res[573].exec("\xf8\x88\x80\x80\x80  ", 1316));
+assertEquals(null, res[573].exec("\xf9\x87\x80\x80\x80  ", 1317));
+assertEquals(null, res[573].exec("\xfc\x84\x80\x80\x80\x80", 1318));
+assertEquals(null, res[573].exec("\xfd\x83\x80\x80\x80\x80", 1319));
+assertEquals(null, res[573].exec("?\xf8\x88\x80\x80\x80  ", 1320));
+assertEquals(null, res[573].exec("?\xf9\x87\x80\x80\x80  ", 1321));
+assertEquals(null, res[573].exec("?\xfc\x84\x80\x80\x80\x80", 1322));
+assertEquals(null, res[573].exec("?\xfd\x83\x80\x80\x80\x80", 1323));
+assertEquals(".", res[574].exec("A.B"), 1324);
+assertEquals("{", res[574].exec("Ax{100}B "), 1325);
+assertEquals("x", res[575].exec("x{100}X   "), 1326);
+assertEquals("a", res[575].exec("ax{1234}b"), 1327);
+assertEquals(null, res[577].exec("AxxB     ", 1328));
+assertEquals("abc1", res[578].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 1329);
+assertEquals("abc1", res[579].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 1330);
+assertEquals(null, res[580].exec("a\nb", 1331));
+assertEquals(null, res[580].exec("a\x0db", 1332));
+assertEquals(null, res[580].exec("a\x0d\nb", 1333));
+assertEquals(null, res[580].exec("a\x0bb", 1334));
+assertEquals(null, res[580].exec("a\x0cb", 1335));
+assertEquals(null, res[580].exec("ax{85}b   ", 1336));
+assertEquals(null, res[580].exec("ax{2028}b ", 1337));
+assertEquals(null, res[580].exec("ax{2029}b ", 1338));
+assertEquals(null, res[580].exec("** Failers", 1339));
+assertEquals(null, res[580].exec("a\n\x0db    ", 1340));
+assertEquals("ab", res[581].exec("ab"), 1341);
+assertEquals(null, res[581].exec("a\nb", 1342));
+assertEquals(null, res[581].exec("a\x0db", 1343));
+assertEquals(null, res[581].exec("a\x0d\nb", 1344));
+assertEquals(null, res[581].exec("a\x0bb", 1345));
+assertEquals(null, res[581].exec("a\x0cx{2028}x{2029}b", 1346));
+assertEquals(null, res[581].exec("ax{85}b   ", 1347));
+assertEquals(null, res[581].exec("a\n\x0db    ", 1348));
+assertEquals(null, res[581].exec("a\n\x0dx{85}\x0cb ", 1349));
+assertEquals(null, res[582].exec("a\nb", 1350));
+assertEquals(null, res[582].exec("a\x0db", 1351));
+assertEquals(null, res[582].exec("a\x0d\nb", 1352));
+assertEquals(null, res[582].exec("a\x0bb", 1353));
+assertEquals(null, res[582].exec("a\x0cx{2028}x{2029}b", 1354));
+assertEquals(null, res[582].exec("ax{85}b   ", 1355));
+assertEquals(null, res[582].exec("a\n\x0db    ", 1356));
+assertEquals(null, res[582].exec("a\n\x0dx{85}\x0cb ", 1357));
+assertEquals(null, res[582].exec("** Failers", 1358));
+assertEquals(null, res[582].exec("ab  ", 1359));
+assertEquals(null, res[583].exec("a\nb", 1360));
+assertEquals(null, res[583].exec("a\n\x0db", 1361));
+assertEquals(null, res[583].exec("a\n\x0dx{85}b", 1362));
+assertEquals(null, res[583].exec("a\x0d\n\x0d\nb ", 1363));
+assertEquals(null, res[583].exec("a\x0d\n\x0d\n\x0d\nb ", 1364));
+assertEquals(null, res[583].exec("a\n\x0d\n\x0db", 1365));
+assertEquals(null, res[583].exec("a\n\n\x0d\nb ", 1366));
+assertEquals(null, res[583].exec("** Failers", 1367));
+assertEquals(null, res[583].exec("a\n\n\n\x0db", 1368));
+assertEquals(null, res[583].exec("a\x0d", 1369));
+assertEquals(null, res[584].exec("X X\n", 1370));
+assertEquals(null, res[584].exec("X\x09X\x0b", 1371));
+assertEquals(null, res[584].exec("** Failers", 1372));
+assertEquals(null, res[584].exec("x{a0} X\n   ", 1373));
+assertEquals(null, res[585].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 1374));
+assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 1375));
+assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b\x0c", 1376));
+assertEquals(null, res[585].exec("** Failers ", 1377));
+assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b", 1378));
+assertEquals(null, res[585].exec(" ", 1379));
+assertEquals(null, res[586].exec("x{3001}x{3000}x{2030}x{2028}", 1380));
+assertEquals(null, res[586].exec("Xx{180e}Xx{85}", 1381));
+assertEquals(null, res[586].exec("** Failers", 1382));
+assertEquals(null, res[586].exec("x{2009} X\n   ", 1383));
+assertEquals(null, res[587].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 1384));
+assertEquals(null, res[587].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 1385));
+assertEquals(null, res[587].exec("\x09 x{202f}\n\x0b\x0c", 1386));
+assertEquals(null, res[587].exec("** Failers ", 1387));
+assertEquals(null, res[587].exec("\x09x{200a}x{a0}x{2028}\x0b", 1388));
+assertEquals(null, res[587].exec(" ", 1389));
+assertEquals(null, res[588].exec(">x{1680}", 1390));
+assertEquals(null, res[589].exec(">x{1680}x{180e}x{2000}x{2003}x{200a}x{202f}x{205f}x{3000}<", 1391));
+assertEquals("x{1ec5} ", res[593].exec("x{1ec5} "), 1392);
+assertEquals(null, res[594].exec("x{0}x{d7ff}x{e000}x{10ffff}", 1393));
+assertEquals(null, res[594].exec("x{d800}", 1394));
+assertEquals(null, res[594].exec("x{d800}?", 1395));
+assertEquals(null, res[594].exec("x{da00}", 1396));
+assertEquals(null, res[594].exec("x{da00}?", 1397));
+assertEquals(null, res[594].exec("x{dfff}", 1398));
+assertEquals(null, res[594].exec("x{dfff}?", 1399));
+assertEquals(null, res[594].exec("x{110000}    ", 1400));
+assertEquals(null, res[594].exec("x{110000}?    ", 1401));
+assertEquals(null, res[594].exec("x{2000000} ", 1402));
+assertEquals(null, res[594].exec("x{2000000}? ", 1403));
+assertEquals(null, res[594].exec("x{7fffffff} ", 1404));
+assertEquals(null, res[594].exec("x{7fffffff}? ", 1405));
+assertEquals(null, res[595].exec("a\x0db", 1406));
+assertEquals(null, res[595].exec("a\nb", 1407));
+assertEquals(null, res[595].exec("a\x0d\nb", 1408));
+assertEquals(null, res[595].exec("** Failers", 1409));
+assertEquals(null, res[595].exec("ax{85}b", 1410));
+assertEquals(null, res[595].exec("a\x0bb     ", 1411));
+assertEquals(null, res[596].exec("a\x0db", 1412));
+assertEquals(null, res[596].exec("a\nb", 1413));
+assertEquals(null, res[596].exec("a\x0d\nb", 1414));
+assertEquals(null, res[596].exec("ax{85}b", 1415));
+assertEquals(null, res[596].exec("a\x0bb     ", 1416));
+assertEquals(null, res[596].exec("** Failers ", 1417));
+assertEquals(null, res[596].exec("ax{85}b<bsr_anycrlf>", 1418));
+assertEquals(null, res[596].exec("a\x0bb<bsr_anycrlf>", 1419));
+assertEquals(null, res[597].exec("a\x0db", 1420));
+assertEquals(null, res[597].exec("a\nb", 1421));
+assertEquals(null, res[597].exec("a\x0d\nb", 1422));
+assertEquals(null, res[597].exec("** Failers", 1423));
+assertEquals(null, res[597].exec("ax{85}b", 1424));
+assertEquals(null, res[597].exec("a\x0bb     ", 1425));
+assertEquals(null, res[598].exec("a\x0db", 1426));
+assertEquals(null, res[598].exec("a\nb", 1427));
+assertEquals(null, res[598].exec("a\x0d\nb", 1428));
+assertEquals(null, res[598].exec("ax{85}b", 1429));
+assertEquals(null, res[598].exec("a\x0bb     ", 1430));
+assertEquals(null, res[598].exec("** Failers ", 1431));
+assertEquals(null, res[598].exec("ax{85}b<bsr_anycrlf>", 1432));
+assertEquals(null, res[598].exec("a\x0bb<bsr_anycrlf>", 1433));
+assertEquals("QQQx{2029}ABCaXYZ=!bPQR", res[599].exec("QQQx{2029}ABCaXYZ=!bPQR"), 1434);
+assertEquals(null, res[599].exec("** Failers", 1435));
+assertEquals(null, res[599].exec("ax{2029}b", 1436));
+assertEquals(null, res[599].exec("a\xe2\x80\xa9b ", 1437));
+assertEquals(null, res[600].exec("ax{1234}b", 1438));
+assertEquals("a\nb", res[600].exec("a\nb "), 1439);
+assertEquals(null, res[600].exec("** Failers", 1440));
+assertEquals(null, res[600].exec("ab  ", 1441));
+assertEquals("aXb", res[601].exec("aXb"), 1442);
+assertEquals("a\nX\nXx{1234}b", res[601].exec("a\nX\nXx{1234}b "), 1443);
+assertEquals(null, res[601].exec("** Failers", 1444));
+assertEquals(null, res[601].exec("ab  ", 1445));
+assertEquals(null, res[601].exec("x{de}x{de}", 1446));
+assertEquals(null, res[601].exec("x{123} ", 1447));
+assertEquals("X", res[602].exec("Ax{1ec5}ABCXYZ"), 1448);
+assertEquals(null, res[604].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 1449));
+assertEquals(null, res[604].exec("\npx{300}9!$ < ", 1450));
+assertEquals(null, res[604].exec("** Failers ", 1451));
+assertEquals(null, res[604].exec("apx{300}9!$ < ", 1452));
+assertEquals(null, res[605].exec("X", 1453));
+assertEquals(null, res[605].exec("** Failers ", 1454));
+assertEquals(null, res[605].exec("", 1455));
+assertEquals(null, res[606].exec("9", 1456));
+assertEquals(null, res[606].exec("** Failers ", 1457));
+assertEquals(null, res[606].exec("x{c0}", 1458));
+assertEquals(null, res[607].exec("X", 1459));
+assertEquals(null, res[607].exec("** Failers ", 1460));
+assertEquals(null, res[607].exec("x{30f}", 1461));
+assertEquals(null, res[608].exec("X", 1462));
+assertEquals(null, res[608].exec("** Failers ", 1463));
+assertEquals(null, res[608].exec("x{660}", 1464));
+assertEquals(null, res[609].exec("X", 1465));
+assertEquals(null, res[609].exec("** Failers ", 1466));
+assertEquals(null, res[609].exec("x{66c}", 1467));
+assertEquals(null, res[610].exec("X", 1468));
+assertEquals(null, res[610].exec("** Failers ", 1469));
+assertEquals(null, res[610].exec("x{f01}", 1470));
+assertEquals(null, res[611].exec("X", 1471));
+assertEquals(null, res[611].exec("** Failers ", 1472));
+assertEquals(null, res[611].exec("x{1680}", 1473));
+assertEquals(null, res[612].exec("x{017}", 1474));
+assertEquals(null, res[612].exec("x{09f} ", 1475));
+assertEquals(null, res[612].exec("** Failers", 1476));
+assertEquals(null, res[612].exec("x{0600} ", 1477));
+assertEquals(null, res[613].exec("x{601}", 1478));
+assertEquals(null, res[613].exec("** Failers", 1479));
+assertEquals(null, res[613].exec("x{09f} ", 1480));
+assertEquals(null, res[614].exec("x{e0000}", 1481));
+assertEquals(null, res[614].exec("** Failers", 1482));
+assertEquals(null, res[614].exec("x{09f} ", 1483));
+assertEquals(null, res[615].exec("x{f8ff}", 1484));
+assertEquals(null, res[615].exec("** Failers", 1485));
+assertEquals(null, res[615].exec("x{09f} ", 1486));
+assertEquals(null, res[616].exec("?x{dfff}", 1487));
+assertEquals(null, res[616].exec("** Failers", 1488));
+assertEquals(null, res[616].exec("x{09f} ", 1489));
+assertEquals(null, res[617].exec("a", 1490));
+assertEquals(null, res[617].exec("** Failers ", 1491));
+assertEquals(null, res[617].exec("Z", 1492));
+assertEquals(null, res[617].exec("x{e000}  ", 1493));
+assertEquals(null, res[618].exec("x{2b0}", 1494));
+assertEquals(null, res[618].exec("** Failers", 1495));
+assertEquals(null, res[618].exec("a ", 1496));
+assertEquals(null, res[619].exec("x{1bb}", 1497));
+assertEquals(null, res[619].exec("x{3400}", 1498));
+assertEquals(null, res[619].exec("x{3401}", 1499));
+assertEquals(null, res[619].exec("x{4d00}", 1500));
+assertEquals(null, res[619].exec("x{4db4}", 1501));
+assertEquals(null, res[619].exec("x{4db5}     ", 1502));
+assertEquals(null, res[619].exec("** Failers", 1503));
+assertEquals(null, res[619].exec("a ", 1504));
+assertEquals(null, res[619].exec("x{2b0}", 1505));
+assertEquals(null, res[619].exec("x{4db6} ", 1506));
+assertEquals(null, res[620].exec("x{1c5}", 1507));
+assertEquals(null, res[620].exec("** Failers", 1508));
+assertEquals(null, res[620].exec("a ", 1509));
+assertEquals(null, res[620].exec("x{2b0}", 1510));
+assertEquals(null, res[621].exec("A", 1511));
+assertEquals(null, res[621].exec("** Failers", 1512));
+assertEquals(null, res[621].exec("x{2b0}", 1513));
+assertEquals(null, res[622].exec("x{903}", 1514));
+assertEquals(null, res[622].exec("** Failers", 1515));
+assertEquals(null, res[622].exec("X", 1516));
+assertEquals(null, res[622].exec("x{300}", 1517));
+assertEquals(null, res[622].exec("   ", 1518));
+assertEquals(null, res[623].exec("x{488}", 1519));
+assertEquals(null, res[623].exec("** Failers", 1520));
+assertEquals(null, res[623].exec("X", 1521));
+assertEquals(null, res[623].exec("x{903}", 1522));
+assertEquals(null, res[623].exec("x{300}", 1523));
+assertEquals(null, res[624].exec("x{300}", 1524));
+assertEquals(null, res[624].exec("** Failers", 1525));
+assertEquals(null, res[624].exec("X", 1526));
+assertEquals(null, res[624].exec("x{903}", 1527));
+assertEquals(null, res[624].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 1528));
+assertEquals(null, res[624].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 1529));
+assertEquals(null, res[624].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 1530));
+assertEquals(null, res[624].exec("** Failers", 1531));
+assertEquals(null, res[624].exec("X", 1532));
+assertEquals(null, res[625].exec("x{16ee}", 1533));
+assertEquals(null, res[625].exec("** Failers", 1534));
+assertEquals(null, res[625].exec("X", 1535));
+assertEquals(null, res[625].exec("x{966}", 1536));
+assertEquals(null, res[626].exec("x{b2}", 1537));
+assertEquals(null, res[626].exec("x{b3}", 1538));
+assertEquals(null, res[626].exec("** Failers", 1539));
+assertEquals(null, res[626].exec("X", 1540));
+assertEquals(null, res[626].exec("x{16ee}", 1541));
+assertEquals(null, res[627].exec("_", 1542));
+assertEquals(null, res[627].exec("x{203f}", 1543));
+assertEquals(null, res[627].exec("** Failers", 1544));
+assertEquals(null, res[627].exec("X", 1545));
+assertEquals(null, res[627].exec("-", 1546));
+assertEquals(null, res[627].exec("x{58a}", 1547));
+assertEquals(null, res[628].exec("-", 1548));
+assertEquals(null, res[628].exec("x{58a}", 1549));
+assertEquals(null, res[628].exec("** Failers", 1550));
+assertEquals(null, res[628].exec("X", 1551));
+assertEquals(null, res[628].exec("x{203f}", 1552));
+assertEquals(null, res[629].exec(")", 1553));
+assertEquals(null, res[629].exec("]", 1554));
+assertEquals(null, res[629].exec("}", 1555));
+assertEquals(null, res[629].exec("x{f3b}", 1556));
+assertEquals(null, res[629].exec("** Failers", 1557));
+assertEquals(null, res[629].exec("X", 1558));
+assertEquals(null, res[629].exec("x{203f}", 1559));
+assertEquals(null, res[629].exec("(", 1560));
+assertEquals(null, res[629].exec("[", 1561));
+assertEquals(null, res[629].exec("{", 1562));
+assertEquals(null, res[629].exec("x{f3c}", 1563));
+assertEquals(null, res[630].exec("x{bb}", 1564));
+assertEquals(null, res[630].exec("x{2019}", 1565));
+assertEquals(null, res[630].exec("** Failers", 1566));
+assertEquals(null, res[630].exec("X", 1567));
+assertEquals(null, res[630].exec("x{203f}", 1568));
+assertEquals(null, res[631].exec("x{ab}", 1569));
+assertEquals(null, res[631].exec("x{2018}", 1570));
+assertEquals(null, res[631].exec("** Failers", 1571));
+assertEquals(null, res[631].exec("X", 1572));
+assertEquals(null, res[631].exec("x{203f}", 1573));
+assertEquals(null, res[632].exec("!", 1574));
+assertEquals(null, res[632].exec("x{37e}", 1575));
+assertEquals(null, res[632].exec("** Failers", 1576));
+assertEquals(null, res[632].exec("X", 1577));
+assertEquals(null, res[632].exec("x{203f}", 1578));
+assertEquals(null, res[633].exec("(", 1579));
+assertEquals(null, res[633].exec("[", 1580));
+assertEquals(null, res[633].exec("{", 1581));
+assertEquals(null, res[633].exec("x{f3c}", 1582));
+assertEquals(null, res[633].exec("** Failers", 1583));
+assertEquals(null, res[633].exec("X", 1584));
+assertEquals(null, res[633].exec(")", 1585));
+assertEquals(null, res[633].exec("]", 1586));
+assertEquals(null, res[633].exec("}", 1587));
+assertEquals(null, res[633].exec("x{f3b}", 1588));
+assertEquals(null, res[633].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 1589));
+assertEquals(null, res[633].exec("x{9f2}", 1590));
+assertEquals(null, res[633].exec("** Failers", 1591));
+assertEquals(null, res[633].exec("X", 1592));
+assertEquals(null, res[633].exec("x{2c2}", 1593));
+assertEquals(null, res[634].exec("x{2c2}", 1594));
+assertEquals(null, res[634].exec("** Failers", 1595));
+assertEquals(null, res[634].exec("X", 1596));
+assertEquals(null, res[634].exec("x{9f2}", 1597));
+assertEquals(null, res[634].exec("+<|~x{ac}x{2044}", 1598));
+assertEquals(null, res[634].exec("** Failers", 1599));
+assertEquals(null, res[634].exec("X", 1600));
+assertEquals(null, res[634].exec("x{9f2}", 1601));
+assertEquals(null, res[635].exec("x{a6}", 1602));
+assertEquals(null, res[635].exec("x{482} ", 1603));
+assertEquals(null, res[635].exec("** Failers", 1604));
+assertEquals(null, res[635].exec("X", 1605));
+assertEquals(null, res[635].exec("x{9f2}", 1606));
+assertEquals(null, res[636].exec("x{2028}", 1607));
+assertEquals(null, res[636].exec("** Failers", 1608));
+assertEquals(null, res[636].exec("X", 1609));
+assertEquals(null, res[636].exec("x{2029}", 1610));
+assertEquals(null, res[637].exec("x{2029}", 1611));
+assertEquals(null, res[637].exec("** Failers", 1612));
+assertEquals(null, res[637].exec("X", 1613));
+assertEquals(null, res[637].exec("x{2028}", 1614));
+assertEquals(null, res[638].exec("\\ \\", 1615));
+assertEquals(null, res[638].exec("x{a0}", 1616));
+assertEquals(null, res[638].exec("x{1680}", 1617));
+assertEquals(null, res[638].exec("x{180e}", 1618));
+assertEquals(null, res[638].exec("x{2000}", 1619));
+assertEquals(null, res[638].exec("x{2001}     ", 1620));
+assertEquals(null, res[638].exec("** Failers", 1621));
+assertEquals(null, res[638].exec("x{2028}", 1622));
+assertEquals(null, res[638].exec("x{200d} ", 1623));
+assertEquals(null, res[638].exec("  x{660}x{661}x{662}ABC", 1624));
+assertEquals(null, res[638].exec("  x{660}x{661}x{662}ABC", 1625));
+assertEquals(null, res[639].exec("  x{660}x{661}x{662}ABC", 1626));
+assertEquals(null, res[640].exec("  x{660}x{661}x{662}ABC", 1627));
+assertEquals(null, res[641].exec("  x{660}x{661}x{662}ABC", 1628));
+assertEquals(null, res[642].exec("  x{660}x{661}x{662}ABC", 1629));
+assertEquals(null, res[643].exec("  x{660}x{661}x{662}ABC", 1630));
+assertEquals(null, res[644].exec("  x{660}x{661}x{662}ABC", 1631));
+assertEquals(null, res[645].exec("  x{660}x{661}x{662}ABC", 1632));
+assertEquals(null, res[646].exec("  x{660}x{661}x{662}ABC", 1633));
+assertEquals(null, res[647].exec("  x{660}x{661}x{662}ABC", 1634));
+assertEquals(null, res[647].exec("  x{660}x{661}x{662}ABC", 1635));
+assertEquals(null, res[647].exec("  x{660}x{661}x{662}ABC", 1636));
+assertEquals(null, res[647].exec("  ** Failers", 1637));
+assertEquals(null, res[647].exec("  x{660}x{661}x{662}ABC", 1638));
+assertEquals(null, res[648].exec("A", 1639));
+assertEquals(null, res[648].exec("ax{10a0}B ", 1640));
+assertEquals(null, res[648].exec("** Failers ", 1641));
+assertEquals(null, res[648].exec("a", 1642));
+assertEquals(null, res[648].exec("x{1d00}  ", 1643));
+assertEquals(null, res[649].exec("1234", 1644));
+assertEquals(null, res[649].exec("** Failers", 1645));
+assertEquals(null, res[649].exec("ABC ", 1646));
+assertEquals(null, res[650].exec("1234", 1647));
+assertEquals(null, res[650].exec("** Failers", 1648));
+assertEquals(null, res[650].exec("ABC ", 1649));
+assertEquals(null, res[650].exec("A2XYZ", 1650));
+assertEquals(null, res[650].exec("123A5XYZPQR", 1651));
+assertEquals(null, res[650].exec("ABAx{660}XYZpqr", 1652));
+assertEquals(null, res[650].exec("** Failers", 1653));
+assertEquals(null, res[650].exec("AXYZ", 1654));
+assertEquals(null, res[650].exec("XYZ     ", 1655));
+assertEquals(null, res[650].exec("1XYZ", 1656));
+assertEquals(null, res[650].exec("AB=XYZ.. ", 1657));
+assertEquals(null, res[650].exec("XYZ ", 1658));
+assertEquals(null, res[650].exec("** Failers", 1659));
+assertEquals(null, res[650].exec("WXYZ ", 1660));
+assertEquals(null, res[655].exec("1234", 1661));
+assertEquals(null, res[655].exec("1234", 1662));
+assertEquals(null, res[655].exec("12-34", 1663));
+assertEquals("{", res[655].exec("12+x{661}-34  "), 1664);
+assertEquals(null, res[655].exec("** Failers", 1665));
+assertEquals("d", res[655].exec("abcd  "), 1666);
+assertEquals("d", res[656].exec("abcd"), 1667);
+assertEquals(null, res[656].exec("** Failers", 1668));
+assertEquals(null, res[656].exec("1234", 1669));
+assertEquals(null, res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1670));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1671);
+assertEquals(" ", res[657].exec(" "), 1672);
+assertEquals(null, res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1673));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1674);
+assertEquals(null, res[658].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1675));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[658].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1676);
+assertEquals(null, res[659].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1677));
+assertEquals(null, res[659].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1678));
+assertEquals(null, res[660].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1679));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[660].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1680);
+assertEquals(null, res[661].exec("a", 1681));
+assertEquals(null, res[661].exec("A ", 1682));
+assertEquals(null, res[662].exec("a", 1683));
+assertEquals(null, res[662].exec("A ", 1684));
+assertEquals(null, res[663].exec("A", 1685));
+assertEquals(null, res[663].exec("aZ", 1686));
+assertEquals(null, res[663].exec("** Failers", 1687));
+assertEquals(null, res[663].exec("abc   ", 1688));
+assertEquals(null, res[664].exec("A", 1689));
+assertEquals(null, res[664].exec("aZ", 1690));
+assertEquals(null, res[664].exec("** Failers", 1691));
+assertEquals(null, res[664].exec("abc   ", 1692));
+assertEquals(null, res[665].exec("a", 1693));
+assertEquals(null, res[665].exec("Az", 1694));
+assertEquals(null, res[665].exec("** Failers", 1695));
+assertEquals(null, res[665].exec("ABC   ", 1696));
+assertEquals(null, res[666].exec("a", 1697));
+assertEquals(null, res[666].exec("Az", 1698));
+assertEquals(null, res[666].exec("** Failers", 1699));
+assertEquals(null, res[666].exec("ABC   ", 1700));
+assertEquals(null, res[666].exec("x{c0}", 1701));
+assertEquals(null, res[666].exec("x{e0} ", 1702));
+assertEquals(null, res[666].exec("x{c0}", 1703));
+assertEquals(null, res[666].exec("x{e0} ", 1704));
+assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1705));
+assertEquals(null, res[666].exec("** Failers", 1706));
+assertEquals(null, res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 1707));
+assertEquals(null, res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1708));
+assertEquals(null, res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1709));
+assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1710));
+assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1711));
+assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1712));
+assertEquals(null, res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 1713));
+assertEquals(null, res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1714));
+assertEquals(null, res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1715));
+assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1716));
+assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1717));
+assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 1718));
+assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1719));
+assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1720));
+assertEquals(null, res[666].exec("x{391}", 1721));
+assertEquals(null, res[666].exec("x{ff3a}", 1722));
+assertEquals(null, res[666].exec("x{3b1}", 1723));
+assertEquals(null, res[666].exec("x{ff5a}   ", 1724));
+assertEquals(null, res[666].exec("x{c0}", 1725));
+assertEquals(null, res[666].exec("x{e0} ", 1726));
+assertEquals(null, res[666].exec("x{104}", 1727));
+assertEquals(null, res[666].exec("x{105}", 1728));
+assertEquals(null, res[666].exec("x{109}  ", 1729));
+assertEquals(null, res[666].exec("** Failers", 1730));
+assertEquals(null, res[666].exec("x{100}", 1731));
+assertEquals(null, res[666].exec("x{10a} ", 1732));
+assertEquals(null, res[666].exec("Z", 1733));
+assertEquals(null, res[666].exec("z", 1734));
+assertEquals(null, res[666].exec("x{39c}", 1735));
+assertEquals(null, res[666].exec("x{178}", 1736));
+assertEquals(null, res[666].exec("|", 1737));
+assertEquals(null, res[666].exec("x{80}", 1738));
+assertEquals(null, res[666].exec("x{ff}", 1739));
+assertEquals(null, res[666].exec("x{100}", 1740));
+assertEquals(null, res[666].exec("x{101} ", 1741));
+assertEquals(null, res[666].exec("** Failers", 1742));
+assertEquals(null, res[666].exec("x{102}", 1743));
+assertEquals(null, res[666].exec("Y", 1744));
+assertEquals(null, res[666].exec("y           ", 1745));
+assertEquals(null, res[667].exec("A", 1746));
+assertEquals(null, res[667].exec("Ax{300}BC ", 1747));
+assertEquals(null, res[667].exec("Ax{300}x{301}x{302}BC ", 1748));
+assertEquals(null, res[667].exec("*** Failers", 1749));
+assertEquals(null, res[667].exec("x{300}  ", 1750));
+assertEquals("X", res[668].exec("X123"), 1751);
+assertEquals(null, res[668].exec("*** Failers", 1752));
+assertEquals(null, res[668].exec("AXYZ", 1753));
+assertEquals(null, res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1754));
+assertEquals(null, res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1755));
+assertEquals(null, res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1756));
+assertEquals(null, res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1757));
+assertEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1758);
+assertEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1759);
+assertEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1760);
+assertEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1761);
+assertEquals(null, res[673].exec("*** Failers", 1762));
+assertEquals(null, res[673].exec("Ax{300}x{301}x{302}", 1763));
+assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}X", 1764));
+assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1765));
+assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1766));
+assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1767));
+assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}X", 1768));
+assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1769));
+assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1770));
+assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1771));
+assertEquals(null, res[675].exec("x{2e81}x{3007}x{2f804}x{31a0}", 1772));
+assertEquals(null, res[675].exec("** Failers", 1773));
+assertEquals(null, res[675].exec("x{2e7f}  ", 1774));
+assertEquals(null, res[675].exec("x{3105}", 1775));
+assertEquals(null, res[675].exec("** Failers", 1776));
+assertEquals(null, res[675].exec("x{30ff}  ", 1777));
+assertEquals(null, res[676].exec("x{06e9}", 1778));
+assertEquals(null, res[676].exec("x{060b}", 1779));
+assertEquals(null, res[676].exec("** Failers", 1780));
+assertEquals(null, res[676].exec("Xx{06e9}   ", 1781));
+assertEquals(null, res[677].exec("x{2f800}", 1782));
+assertEquals(null, res[677].exec("** Failers", 1783));
+assertEquals(null, res[677].exec("x{a014}", 1784));
+assertEquals(null, res[677].exec("x{a4c6}   ", 1785));
+assertEquals(null, res[678].exec("AXYZ", 1786));
+assertEquals(null, res[678].exec("x{1234}XYZ ", 1787));
+assertEquals(null, res[678].exec("** Failers", 1788));
+assertEquals(null, res[678].exec("X  ", 1789));
+assertEquals(null, res[679].exec("** Failers", 1790));
+assertEquals(null, res[679].exec("AX", 1791));
+assertEquals(null, res[680].exec("XYZ", 1792));
+assertEquals(null, res[680].exec("AXYZ", 1793));
+assertEquals(null, res[680].exec("x{1234}XYZ ", 1794));
+assertEquals(null, res[680].exec("** Failers", 1795));
+assertEquals(null, res[680].exec("ABXYZ   ", 1796));
+assertEquals(null, res[681].exec("XYZ", 1797));
+assertEquals(null, res[681].exec("** Failers", 1798));
+assertEquals(null, res[681].exec("AXYZ", 1799));
+assertEquals(null, res[681].exec("x{1234}XYZ ", 1800));
+assertEquals(null, res[681].exec("ABXYZ   ", 1801));
+assertEquals(null, res[681].exec("AXYZ", 1802));
+assertEquals(null, res[681].exec("x{1234}XYZ", 1803));
+assertEquals(null, res[681].exec("Ax{1234}XYZ", 1804));
+assertEquals(null, res[681].exec("** Failers", 1805));
+assertEquals(null, res[681].exec("XYZ", 1806));
+assertEquals(null, res[681].exec("** Failers", 1807));
+assertEquals(null, res[681].exec("AXYZ", 1808));
+assertEquals(null, res[681].exec("x{1234}XYZ", 1809));
+assertEquals(null, res[681].exec("Ax{1234}XYZ", 1810));
+assertEquals(null, res[681].exec("XYZ", 1811));
+assertEquals(null, res[682].exec("XYZ", 1812));
+assertEquals(null, res[682].exec("AXYZ", 1813));
+assertEquals(null, res[682].exec("x{1234}XYZ", 1814));
+assertEquals(null, res[682].exec("Ax{1234}XYZ", 1815));
+assertEquals(null, res[682].exec("** Failers", 1816));
+assertEquals(null, res[683].exec("XYZ", 1817));
+assertEquals(null, res[683].exec("** Failers", 1818));
+assertEquals(null, res[683].exec("AXYZ", 1819));
+assertEquals(null, res[683].exec("x{1234}XYZ", 1820));
+assertEquals(null, res[683].exec("Ax{1234}XYZ", 1821));
+assertEquals("AX", res[684].exec("AXYZ"), 1822);
+assertEquals(null, res[684].exec("x{1234}XYZ ", 1823));
+assertEquals(null, res[684].exec("** Failers", 1824));
+assertEquals(null, res[684].exec("X  ", 1825));
+assertEquals(null, res[685].exec("** Failers", 1826));
+assertEquals("AX", res[685].exec("AX"), 1827);
+assertEquals("X", res[686].exec("XYZ"), 1828);
+assertEquals("AX", res[686].exec("AXYZ"), 1829);
+assertEquals(null, res[686].exec("x{1234}XYZ ", 1830));
+assertEquals(null, res[686].exec("** Failers", 1831));
+assertEquals(null, res[686].exec("ABXYZ   ", 1832));
+assertEquals("X", res[687].exec("XYZ"), 1833);
+assertEquals(null, res[687].exec("** Failers", 1834));
+assertEquals("AX", res[687].exec("AXYZ"), 1835);
+assertEquals(null, res[687].exec("x{1234}XYZ ", 1836));
+assertEquals(null, res[687].exec("ABXYZ   ", 1837));
+assertEquals("AX", res[688].exec("AXYZ"), 1838);
+assertEquals(null, res[688].exec("x{1234}XYZ", 1839));
+assertEquals(null, res[688].exec("Ax{1234}XYZ", 1840));
+assertEquals(null, res[688].exec("** Failers", 1841));
+assertEquals(null, res[688].exec("XYZ", 1842));
+assertEquals(null, res[689].exec("** Failers", 1843));
+assertEquals("AX", res[689].exec("AXYZ"), 1844);
+assertEquals(null, res[689].exec("x{1234}XYZ", 1845));
+assertEquals(null, res[689].exec("Ax{1234}XYZ", 1846));
+assertEquals(null, res[689].exec("XYZ", 1847));
+assertEquals("X", res[690].exec("XYZ"), 1848);
+assertEquals("AX", res[690].exec("AXYZ"), 1849);
+assertEquals(null, res[690].exec("x{1234}XYZ", 1850));
+assertEquals(null, res[690].exec("Ax{1234}XYZ", 1851));
+assertEquals(null, res[690].exec("** Failers", 1852));
+assertEquals("X", res[691].exec("XYZ"), 1853);
+assertEquals(null, res[691].exec("** Failers", 1854));
+assertEquals("AX", res[691].exec("AXYZ"), 1855);
+assertEquals(null, res[691].exec("x{1234}XYZ", 1856));
+assertEquals(null, res[691].exec("Ax{1234}XYZ", 1857));
+assertEquals(null, res[692].exec("abcdefgh", 1858));
+assertEquals(null, res[692].exec("x{1234}\n\x0dx{3456}xyz ", 1859));
+assertEquals(null, res[693].exec("abcdefgh", 1860));
+assertEquals(null, res[693].exec("x{1234}\n\x0dx{3456}xyz ", 1861));
+assertEquals(null, res[694].exec("** Failers", 1862));
+assertEquals(null, res[694].exec("abcdefgh", 1863));
+assertEquals(null, res[694].exec("x{1234}\n\x0dx{3456}xyz ", 1864));
+assertEquals(null, res[695].exec(" AXY", 1865));
+assertEquals(null, res[695].exec(" aXY", 1866));
+assertEquals(null, res[695].exec(" x{1c5}XY", 1867));
+assertEquals(null, res[695].exec(" ** Failers", 1868));
+assertEquals(null, res[695].exec(" x{1bb}XY", 1869));
+assertEquals(null, res[695].exec(" x{2b0}XY", 1870));
+assertEquals(null, res[695].exec(" !XY      ", 1871));
+assertEquals(null, res[696].exec(" AXY", 1872));
+assertEquals(null, res[696].exec(" aXY", 1873));
+assertEquals(null, res[696].exec(" x{1c5}XY", 1874));
+assertEquals(null, res[696].exec(" ** Failers", 1875));
+assertEquals(null, res[696].exec(" x{1bb}XY", 1876));
+assertEquals(null, res[696].exec(" x{2b0}XY", 1877));
+assertEquals(null, res[696].exec(" !XY      ", 1878));
+assertEquals(null, res[696].exec(" AXY", 1879));
+assertEquals(null, res[696].exec(" aXY", 1880));
+assertEquals(null, res[696].exec(" AbcdeXyz ", 1881));
+assertEquals(null, res[696].exec(" x{1c5}AbXY", 1882));
+assertEquals(null, res[696].exec(" abcDEXypqreXlmn ", 1883));
+assertEquals(null, res[696].exec(" ** Failers", 1884));
+assertEquals(null, res[696].exec(" x{1bb}XY", 1885));
+assertEquals(null, res[696].exec(" x{2b0}XY", 1886));
+assertEquals(null, res[696].exec(" !XY      ", 1887));
+assertEquals(null, res[697].exec(" AXY", 1888));
+assertEquals(null, res[697].exec(" aXY", 1889));
+assertEquals(null, res[697].exec(" AbcdeXyz ", 1890));
+assertEquals(null, res[697].exec(" x{1c5}AbXY", 1891));
+assertEquals(null, res[697].exec(" abcDEXypqreXlmn ", 1892));
+assertEquals(null, res[697].exec(" ** Failers", 1893));
+assertEquals(null, res[697].exec(" x{1bb}XY", 1894));
+assertEquals(null, res[697].exec(" x{2b0}XY", 1895));
+assertEquals(null, res[697].exec(" !XY      ", 1896));
+assertEquals(null, res[697].exec(" AXY", 1897));
+assertEquals(null, res[697].exec(" aXY", 1898));
+assertEquals(null, res[697].exec(" AbcdeXyz ", 1899));
+assertEquals(null, res[697].exec(" x{1c5}AbXY", 1900));
+assertEquals(null, res[697].exec(" abcDEXypqreXlmn ", 1901));
+assertEquals(null, res[697].exec(" ** Failers", 1902));
+assertEquals(null, res[697].exec(" x{1bb}XY", 1903));
+assertEquals(null, res[697].exec(" x{2b0}XY", 1904));
+assertEquals(null, res[697].exec(" !XY      ", 1905));
+assertEquals(null, res[698].exec(" AXY", 1906));
+assertEquals(null, res[698].exec(" aXY", 1907));
+assertEquals(null, res[698].exec(" AbcdeXyz ", 1908));
+assertEquals(null, res[698].exec(" x{1c5}AbXY", 1909));
+assertEquals(null, res[698].exec(" abcDEXypqreXlmn ", 1910));
+assertEquals(null, res[698].exec(" ** Failers", 1911));
+assertEquals(null, res[698].exec(" x{1bb}XY", 1912));
+assertEquals(null, res[698].exec(" x{2b0}XY", 1913));
+assertEquals(null, res[698].exec(" !XY      ", 1914));
+assertEquals(null, res[699].exec(" !XY", 1915));
+assertEquals(null, res[699].exec(" x{1bb}XY", 1916));
+assertEquals(null, res[699].exec(" x{2b0}XY", 1917));
+assertEquals(null, res[699].exec(" ** Failers", 1918));
+assertEquals(null, res[699].exec(" x{1c5}XY", 1919));
+assertEquals(null, res[699].exec(" AXY      ", 1920));
+assertEquals(null, res[700].exec(" !XY", 1921));
+assertEquals(null, res[700].exec(" x{1bb}XY", 1922));
+assertEquals(null, res[700].exec(" x{2b0}XY", 1923));
+assertEquals(null, res[700].exec(" ** Failers", 1924));
+assertEquals(null, res[700].exec(" x{1c5}XY", 1925));
+assertEquals(null, res[700].exec(" AXY      ", 1926));
+assertEquals(null, res[701].exec("\xa0!", 1927));
+assertEquals(null, res[701].exec("AabcabcYZ    ", 1928));
+assertEquals("L=abcX,L=abc,abc", res[702].exec("L=abcX"), 1929);
+assertEquals(null, res[702].exec("x{c0}", 1930));
+assertEquals(null, res[702].exec("x{e0} ", 1931));
+assertEquals(null, res[702].exec("x{c0}", 1932));
+assertEquals(null, res[702].exec("x{e0} ", 1933));
+assertEquals(null, res[703].exec("x{1b00}x{12000}x{7c0}x{a840}x{10900}", 1934));
+assertEquals(null, res[706].exec("123abcdefg", 1935));
+assertEquals(null, res[706].exec("123abc\xc4\xc5zz", 1936));
+assertEquals(null, res[710].exec("A\x80", 1937));
+assertEquals(null, res[725].exec("x{60e} ", 1938));
+assertEquals(null, res[725].exec("x{656} ", 1939));
+assertEquals(null, res[725].exec("x{657} ", 1940));
+assertEquals(null, res[725].exec("x{658} ", 1941));
+assertEquals(null, res[725].exec("x{659} ", 1942));
+assertEquals(null, res[725].exec("x{65a} ", 1943));
+assertEquals(null, res[725].exec("x{65b} ", 1944));
+assertEquals(null, res[725].exec("x{65c} ", 1945));
+assertEquals(null, res[725].exec("x{65d} ", 1946));
+assertEquals(null, res[725].exec("x{65e} ", 1947));
+assertEquals(null, res[725].exec("x{66a} ", 1948));
+assertEquals(null, res[725].exec("x{6e9} ", 1949));
+assertEquals(null, res[725].exec("x{6ef}", 1950));
+assertEquals(null, res[725].exec("x{6fa}  ", 1951));
+assertEquals(null, res[725].exec("** Failers", 1952));
+assertEquals(null, res[725].exec("x{600}", 1953));
+assertEquals(null, res[725].exec("x{650}", 1954));
+assertEquals(null, res[725].exec("x{651}  ", 1955));
+assertEquals(null, res[725].exec("x{652}  ", 1956));
+assertEquals(null, res[725].exec("x{653}  ", 1957));
+assertEquals(null, res[725].exec("x{654} ", 1958));
+assertEquals(null, res[725].exec("x{655} ", 1959));
+assertEquals(null, res[725].exec("x{65f}  ", 1960));
+assertEquals(null, res[726].exec("x{1d2b} ", 1961));
+assertEquals(null, res[727].exec("x{589}", 1962));
+assertEquals(null, res[727].exec("x{60c}", 1963));
+assertEquals(null, res[727].exec("x{61f}  ", 1964));
+assertEquals(null, res[727].exec("x{964}", 1965));
+assertEquals(null, res[727].exec("x{965}  ", 1966));
+assertEquals(null, res[727].exec("x{970}  ", 1967));
+assertEquals(null, res[728].exec("x{64b}", 1968));
+assertEquals(null, res[728].exec("x{654}", 1969));
+assertEquals(null, res[728].exec("x{655}", 1970));
+assertEquals(null, res[728].exec("x{200c} ", 1971));
+assertEquals(null, res[728].exec("** Failers", 1972));
+assertEquals(null, res[728].exec("x{64a}", 1973));
+assertEquals(null, res[728].exec("x{656}     ", 1974));
+assertEquals(null, res[729].exec("x{10450}", 1975));
+assertEquals(null, res[729].exec("x{1047f}", 1976));
+assertEquals(null, res[730].exec("x{10400}", 1977));
+assertEquals(null, res[730].exec("x{1044f}", 1978));
+assertEquals(null, res[731].exec("x{10480}", 1979));
+assertEquals(null, res[731].exec("x{1049d}", 1980));
+assertEquals(null, res[731].exec("x{104a0}", 1981));
+assertEquals(null, res[731].exec("x{104a9}", 1982));
+assertEquals(null, res[731].exec("** Failers", 1983));
+assertEquals(null, res[731].exec("x{1049e}", 1984));
+assertEquals(null, res[731].exec("x{1049f}", 1985));
+assertEquals(null, res[731].exec("x{104aa}           ", 1986));
+assertEquals(null, res[731].exec("\xe2\x80\xa8\xe2\x80\xa8", 1987));
+assertEquals(null, res[731].exec("x{2028}x{2028}x{2028}", 1988));
+assertEquals(null, res[732].exec("x{c0}x{e0}x{116}x{117}", 1989));
+assertEquals(null, res[732].exec("x{c0}x{e0}x{116}x{117}", 1990));
+assertEquals(null, res[733].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 1991));
+assertEquals(null, res[733].exec("x{a77d}x{1d79}", 1992));
+assertEquals(null, res[733].exec("x{1d79}x{a77d} ", 1993));
+assertEquals(null, res[733].exec("x{a77d}x{1d79}", 1994));
+assertEquals(null, res[733].exec("** Failers ", 1995));
+assertEquals(null, res[733].exec("x{1d79}x{a77d} ", 1996));
+assertEquals("AA,A", res[734].exec("AA"), 1997);
+assertEquals("Aa,A", res[734].exec("Aa"), 1998);
+assertEquals("aa,a", res[734].exec("aa"), 1999);
+assertEquals("aA,a", res[734].exec("aA"), 2000);
+assertEquals(null, res[734].exec("x{de}x{de}", 2001));
+assertEquals(null, res[734].exec("x{de}x{fe}", 2002));
+assertEquals(null, res[734].exec("x{fe}x{fe}", 2003));
+assertEquals(null, res[734].exec("x{fe}x{de}", 2004));
+assertEquals(null, res[734].exec("x{10a}x{10a}", 2005));
+assertEquals(null, res[734].exec("x{10a}x{10b}", 2006));
+assertEquals(null, res[734].exec("x{10b}x{10b}", 2007));
+assertEquals(null, res[734].exec("x{10b}x{10a}", 2008));
+assertEquals("abc", res[736].exec("abc"), 2009);
+assertEquals("abc", res[737].exec("abc"), 2010);
+assertEquals("abbbbc", res[737].exec("abbbbc"), 2011);
+assertEquals("ac", res[737].exec("ac"), 2012);
+assertEquals("abc", res[738].exec("abc"), 2013);
+assertEquals("abbbbbbc", res[738].exec("abbbbbbc"), 2014);
+assertEquals(null, res[738].exec("*** Failers ", 2015));
+assertEquals(null, res[738].exec("ac", 2016));
+assertEquals(null, res[738].exec("ab", 2017));
+assertEquals("a", res[739].exec("a"), 2018);
+assertEquals("aaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaa"), 2019);
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "), 2020);
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaF "), 2021);
+assertEquals("a,a", res[740].exec("a"), 2022);
+assertEquals("a,a", res[740].exec("abcd"), 2023);
+assertEquals("a,a", res[740].exec("african"), 2024);
+assertEquals("abc", res[741].exec("abcdef"), 2025);
+assertEquals(null, res[741].exec("*** Failers", 2026));
+assertEquals(null, res[741].exec("xyzabc", 2027));
+assertEquals(null, res[741].exec("xyz\nabc    ", 2028));
+assertEquals("abc", res[742].exec("abcdef"), 2029);
+assertEquals("abc", res[742].exec("xyz\nabc    "), 2030);
+assertEquals(null, res[742].exec("*** Failers", 2031));
+assertEquals(null, res[742].exec("xyzabc", 2032));
+assertEquals(null, res[743].exec("abcdef", 2033));
+assertEquals(null, res[743].exec("*** Failers", 2034));
+assertEquals(null, res[743].exec("xyzabc", 2035));
+assertEquals(null, res[743].exec("xyz\nabc    ", 2036));
+assertEquals(null, res[744].exec("abcdef", 2037));
+assertEquals(null, res[744].exec("*** Failers", 2038));
+assertEquals(null, res[744].exec("xyzabc", 2039));
+assertEquals(null, res[744].exec("xyz\nabc    ", 2040));
+assertEquals(null, res[745].exec("abcdef", 2041));
+assertEquals(null, res[745].exec("xyzabc>3", 2042));
+assertEquals(null, res[745].exec("*** Failers", 2043));
+assertEquals(null, res[745].exec("xyzabc    ", 2044));
+assertEquals(null, res[745].exec("xyzabc>2 ", 2045));
+assertEquals("x9yzz", res[746].exec("x9yzz"), 2046);
+assertEquals("x0y+z", res[746].exec("x0y+z"), 2047);
+assertEquals(null, res[746].exec("*** Failers", 2048));
+assertEquals(null, res[746].exec("xyz", 2049));
+assertEquals(null, res[746].exec("xxy0z     ", 2050));
+assertEquals("x yzz", res[747].exec("x yzz"), 2051);
+assertEquals("x y+z", res[747].exec("x y+z"), 2052);
+assertEquals(null, res[747].exec("*** Failers", 2053));
+assertEquals(null, res[747].exec("xyz", 2054));
+assertEquals(null, res[747].exec("xxyyz", 2055));
+assertEquals("xxy+z", res[748].exec("xxy+z"), 2056);
+assertEquals(null, res[748].exec("*** Failers", 2057));
+assertEquals(null, res[748].exec("xxy0z", 2058));
+assertEquals(null, res[748].exec("x+y+z         ", 2059));
+assertEquals("x+y", res[749].exec("x+y"), 2060);
+assertEquals("x-y", res[749].exec("x-y"), 2061);
+assertEquals(null, res[749].exec("*** Failers", 2062));
+assertEquals(null, res[749].exec("x\ny", 2063));
+assertEquals("x+y", res[750].exec("x+y"), 2064);
+assertEquals("x-y", res[750].exec("x-y"), 2065);
+assertEquals(null, res[750].exec("x\ny", 2066));
+assertEquals(null, res[750].exec("a+bc+dp+q", 2067));
+assertEquals(null, res[750].exec("a+bc\ndp+q", 2068));
+assertEquals(null, res[750].exec("x\nyp+q ", 2069));
+assertEquals(null, res[750].exec("*** Failers ", 2070));
+assertEquals(null, res[750].exec("a\nbc\ndp+q", 2071));
+assertEquals(null, res[750].exec("a+bc\ndp\nq", 2072));
+assertEquals(null, res[750].exec("x\nyp\nq ", 2073));
+assertEquals(null, res[751].exec("ba0", 2074));
+assertEquals(null, res[751].exec("*** Failers", 2075));
+assertEquals(null, res[751].exec("ba0\n", 2076));
+assertEquals(null, res[751].exec("ba0\ncd   ", 2077));
+assertEquals(null, res[752].exec("ba0", 2078));
+assertEquals(null, res[752].exec("*** Failers", 2079));
+assertEquals(null, res[752].exec("ba0\n", 2080));
+assertEquals(null, res[752].exec("ba0\ncd   ", 2081));
+assertEquals(null, res[753].exec("ba0", 2082));
+assertEquals(null, res[753].exec("ba0\n", 2083));
+assertEquals(null, res[753].exec("*** Failers", 2084));
+assertEquals(null, res[753].exec("ba0\ncd   ", 2085));
+assertEquals(null, res[754].exec("ba0", 2086));
+assertEquals(null, res[754].exec("ba0\n", 2087));
+assertEquals(null, res[754].exec("*** Failers", 2088));
+assertEquals(null, res[754].exec("ba0\ncd   ", 2089));
+assertEquals("a0", res[755].exec("ba0"), 2090);
+assertEquals(null, res[755].exec("ba0\n", 2091));
+assertEquals(null, res[755].exec("*** Failers", 2092));
+assertEquals(null, res[755].exec("ba0\ncd   ", 2093));
+assertEquals("a0", res[756].exec("ba0"), 2094);
+assertEquals("a0", res[756].exec("ba0\n"), 2095);
+assertEquals("a0", res[756].exec("ba0\ncd   "), 2096);
+assertEquals(null, res[756].exec("*** Failers", 2097));
+assertEquals("abc", res[757].exec("abc"), 2098);
+assertEquals("aBc", res[757].exec("aBc"), 2099);
+assertEquals("ABC", res[757].exec("ABC"), 2100);
+assertEquals("b", res[758].exec("abcd"), 2101);
+assertEquals("abz", res[759].exec("abz"), 2102);
+assertEquals("abb", res[759].exec("abbz"), 2103);
+assertEquals("az", res[759].exec("azz  "), 2104);
+assertEquals("yz", res[760].exec("ayzq"), 2105);
+assertEquals("xyz", res[760].exec("axyzq"), 2106);
+assertEquals("xxyz", res[760].exec("axxyz"), 2107);
+assertEquals("xxxyz", res[760].exec("axxxyzq"), 2108);
+assertEquals("xxxyz", res[760].exec("axxxxyzq"), 2109);
+assertEquals(null, res[760].exec("*** Failers", 2110));
+assertEquals(null, res[760].exec("ax", 2111));
+assertEquals(null, res[760].exec("axx     ", 2112));
+assertEquals(null, res[760].exec("  ", 2113));
+assertEquals("xxxyz", res[761].exec("axxxyzq"), 2114);
+assertEquals("xxxyz", res[761].exec("axxxxyzq"), 2115);
+assertEquals(null, res[761].exec("*** Failers", 2116));
+assertEquals(null, res[761].exec("ax", 2117));
+assertEquals(null, res[761].exec("axx     ", 2118));
+assertEquals(null, res[761].exec("ayzq", 2119));
+assertEquals(null, res[761].exec("axyzq", 2120));
+assertEquals(null, res[761].exec("axxyz", 2121));
+assertEquals(null, res[761].exec("  ", 2122));
+assertEquals("xxyz", res[762].exec("axxyz"), 2123);
+assertEquals("xxxyz", res[762].exec("axxxyzq"), 2124);
+assertEquals("xxxyz", res[762].exec("axxxxyzq"), 2125);
+assertEquals(null, res[762].exec("*** Failers", 2126));
+assertEquals(null, res[762].exec("ax", 2127));
+assertEquals(null, res[762].exec("axx     ", 2128));
+assertEquals(null, res[762].exec("ayzq", 2129));
+assertEquals(null, res[762].exec("axyzq", 2130));
+assertEquals(null, res[762].exec("  ", 2131));
+assertEquals("b", res[763].exec("bac"), 2132);
+assertEquals("bcdef", res[763].exec("bcdefax"), 2133);
+assertEquals("*** F", res[763].exec("*** Failers"), 2134);
+assertEquals("   ", res[763].exec("aaaaa   "), 2135);
+assertEquals("b", res[764].exec("bac"), 2136);
+assertEquals("bcdef", res[764].exec("bcdefax"), 2137);
+assertEquals("*** F", res[764].exec("*** Failers"), 2138);
+assertEquals("", res[764].exec("aaaaa   "), 2139);
+assertEquals("xyz", res[765].exec("xyz"), 2140);
+assertEquals("wxyz", res[765].exec("awxyza"), 2141);
+assertEquals("bcdef", res[765].exec("abcdefa"), 2142);
+assertEquals("bcdef", res[765].exec("abcdefghijk"), 2143);
+assertEquals("*** F", res[765].exec("*** Failers"), 2144);
+assertEquals(null, res[765].exec("axya", 2145));
+assertEquals(null, res[765].exec("axa", 2146));
+assertEquals("     ", res[765].exec("aaaaa         "), 2147);
+assertEquals("1234", res[766].exec("1234b567"), 2148);
+assertEquals("", res[766].exec("xyz"), 2149);
+assertEquals("a", res[767].exec("a1234b567"), 2150);
+assertEquals("xyz", res[767].exec("xyz"), 2151);
+assertEquals(" ", res[767].exec(" "), 2152);
+assertEquals("1234", res[768].exec("ab1234c56"), 2153);
+assertEquals(null, res[768].exec("*** Failers", 2154));
+assertEquals(null, res[768].exec("xyz", 2155));
+assertEquals("ab", res[769].exec("ab123c56"), 2156);
+assertEquals("*** Failers", res[769].exec("*** Failers"), 2157);
+assertEquals(null, res[769].exec("789", 2158));
+assertEquals("5A", res[770].exec("045ABC"), 2159);
+assertEquals("A", res[770].exec("ABC"), 2160);
+assertEquals(null, res[770].exec("*** Failers", 2161));
+assertEquals(null, res[770].exec("XYZ", 2162));
+assertEquals("A", res[771].exec("ABC"), 2163);
+assertEquals("BA", res[771].exec("BAC"), 2164);
+assertEquals("A", res[771].exec("9ABC             "), 2165);
+assertEquals(null, res[771].exec("*** Failers", 2166));
+assertEquals("aaaa", res[772].exec("aaaa"), 2167);
+assertEquals("xyz", res[773].exec("xyz"), 2168);
+assertEquals("ggggggggxyz", res[773].exec("ggggggggxyz"), 2169);
+assertEquals("abcdxyz", res[774].exec("abcdxyz"), 2170);
+assertEquals("axyz", res[774].exec("axyz"), 2171);
+assertEquals(null, res[774].exec("*** Failers", 2172));
+assertEquals(null, res[774].exec("xyz", 2173));
+assertEquals("xyz", res[775].exec("xyz"), 2174);
+assertEquals("cxyz", res[775].exec("cxyz       "), 2175);
+assertEquals("12X", res[776].exec("12X"), 2176);
+assertEquals("123X", res[776].exec("123X"), 2177);
+assertEquals(null, res[776].exec("*** Failers", 2178));
+assertEquals(null, res[776].exec("X", 2179));
+assertEquals(null, res[776].exec("1X", 2180));
+assertEquals(null, res[776].exec("1234X     ", 2181));
+assertEquals("a4", res[777].exec("a45"), 2182);
+assertEquals("b9", res[777].exec("b93"), 2183);
+assertEquals("c9", res[777].exec("c99z"), 2184);
+assertEquals("d0", res[777].exec("d04"), 2185);
+assertEquals(null, res[777].exec("*** Failers", 2186));
+assertEquals(null, res[777].exec("e45", 2187));
+assertEquals(null, res[777].exec("abcd      ", 2188));
+assertEquals(null, res[777].exec("abcd1234", 2189));
+assertEquals(null, res[777].exec("1234  ", 2190));
+assertEquals("a4", res[778].exec("a45"), 2191);
+assertEquals("b9", res[778].exec("b93"), 2192);
+assertEquals("c9", res[778].exec("c99z"), 2193);
+assertEquals("d0", res[778].exec("d04"), 2194);
+assertEquals("abcd1", res[778].exec("abcd1234"), 2195);
+assertEquals("1", res[778].exec("1234  "), 2196);
+assertEquals(null, res[778].exec("*** Failers", 2197));
+assertEquals(null, res[778].exec("e45", 2198));
+assertEquals(null, res[778].exec("abcd      ", 2199));
+assertEquals("a4", res[779].exec("a45"), 2200);
+assertEquals("b9", res[779].exec("b93"), 2201);
+assertEquals("c9", res[779].exec("c99z"), 2202);
+assertEquals("d0", res[779].exec("d04"), 2203);
+assertEquals("abcd1", res[779].exec("abcd1234"), 2204);
+assertEquals(null, res[779].exec("*** Failers", 2205));
+assertEquals(null, res[779].exec("1234  ", 2206));
+assertEquals(null, res[779].exec("e45", 2207));
+assertEquals(null, res[779].exec("abcd      ", 2208));
+assertEquals("aX", res[780].exec("aX"), 2209);
+assertEquals("aaX", res[780].exec("aaX "), 2210);
+assertEquals("a4", res[781].exec("a45"), 2211);
+assertEquals("b9", res[781].exec("b93"), 2212);
+assertEquals("c9", res[781].exec("c99z"), 2213);
+assertEquals("d0", res[781].exec("d04"), 2214);
+assertEquals("1", res[781].exec("1234  "), 2215);
+assertEquals(null, res[781].exec("*** Failers", 2216));
+assertEquals(null, res[781].exec("abcd1234", 2217));
+assertEquals(null, res[781].exec("e45", 2218));
+assertEquals("ab4", res[782].exec("ab45"), 2219);
+assertEquals("bcd9", res[782].exec("bcd93"), 2220);
+assertEquals(null, res[782].exec("*** Failers", 2221));
+assertEquals(null, res[782].exec("1234 ", 2222));
+assertEquals(null, res[782].exec("a36 ", 2223));
+assertEquals(null, res[782].exec("abcd1234", 2224));
+assertEquals(null, res[782].exec("ee45", 2225));
+assertEquals("abc4,abc", res[783].exec("abc45"), 2226);
+assertEquals("abcabcabc4,abc", res[783].exec("abcabcabc45"), 2227);
+assertEquals("4,", res[783].exec("42xyz "), 2228);
+assertEquals(null, res[783].exec("*** Failers", 2229));
+assertEquals("abc4,abc", res[784].exec("abc45"), 2230);
+assertEquals("abcabcabc4,abc", res[784].exec("abcabcabc45"), 2231);
+assertEquals(null, res[784].exec("*** Failers", 2232));
+assertEquals(null, res[784].exec("42xyz ", 2233));
+assertEquals("abc4,abc", res[785].exec("abc45"), 2234);
+assertEquals("4,", res[785].exec("42xyz "), 2235);
+assertEquals(null, res[785].exec("*** Failers", 2236));
+assertEquals(null, res[785].exec("abcabcabc45", 2237));
+assertEquals("abcabc4,abc", res[786].exec("abcabc45"), 2238);
+assertEquals("abcabcabc4,abc", res[786].exec("abcabcabc45"), 2239);
+assertEquals(null, res[786].exec("*** Failers", 2240));
+assertEquals(null, res[786].exec("abcabcabcabc45", 2241));
+assertEquals(null, res[786].exec("abc45", 2242));
+assertEquals(null, res[786].exec("42xyz ", 2243));
+assertEquals(null, res[786].exec("1abc2abc3456", 2244));
+assertEquals(null, res[786].exec("1abc2xyz3456 ", 2245));
+assertEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2246);
+assertEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2247);
+assertEquals(null, res[787].exec("abc", 2248));
+assertEquals(null, res[787].exec("a(b)c", 2249));
+assertEquals(null, res[787].exec("a(b(c))d  ", 2250));
+assertEquals(null, res[787].exec("*** Failers)", 2251));
+assertEquals(null, res[787].exec("a(b(c)d  ", 2252));
+assertEquals(null, res[787].exec(">abc>123<xyz<", 2253));
+assertEquals(null, res[787].exec(">abc>1(2)3<xyz<", 2254));
+assertEquals(null, res[787].exec(">abc>(1(2)3)<xyz<", 2255));
+assertEquals(null, res[787].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9876", 2256));
+assertEquals(null, res[787].exec("*** Failers ", 2257));
+assertEquals(null, res[787].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 2258));
+assertEquals(null, res[787].exec("<>", 2259));
+assertEquals(null, res[787].exec("<abcd>", 2260));
+assertEquals(null, res[787].exec("<abc <123> hij>", 2261));
+assertEquals(null, res[787].exec("<abc <def> hij>", 2262));
+assertEquals(null, res[787].exec("<abc<>def> ", 2263));
+assertEquals(null, res[787].exec("<abc<>      ", 2264));
+assertEquals(null, res[787].exec("*** Failers", 2265));
+assertEquals(null, res[787].exec("<abc", 2266));
+assertEquals(null, res[787].exec("abc:                          ", 2267));
+assertEquals(null, res[787].exec("12                             ", 2268));
+assertEquals(null, res[787].exec("*** Failers                     ", 2269));
+assertEquals(null, res[787].exec("123                       ", 2270));
+assertEquals(null, res[787].exec("xyz                        ", 2271));
+assertEquals(null, res[787].exec("                            ", 2272));
+assertEquals(null, res[787].exec("abc:                        ", 2273));
+assertEquals(null, res[787].exec("12         ", 2274));
+assertEquals(null, res[787].exec("*** Failers", 2275));
+assertEquals(null, res[787].exec("123", 2276));
+assertEquals(null, res[787].exec("xyz    ", 2277));
+assertEquals(null, res[788].exec("abcde:                          ", 2278));
+assertEquals(null, res[788].exec("*** Failers                     ", 2279));
+assertEquals(null, res[788].exec("abc.. ", 2280));
+assertEquals(null, res[788].exec("123                       ", 2281));
+assertEquals(null, res[788].exec("vwxyz                        ", 2282));
+assertEquals(null, res[788].exec("                            ", 2283));
+assertEquals(null, res[789].exec("12         ", 2284));
+assertEquals(null, res[789].exec("*** Failers", 2285));
+assertEquals(null, res[789].exec("abcde:", 2286));
+assertEquals(null, res[789].exec("abc..  ", 2287));
+assertEquals(null, res[789].exec("123", 2288));
+assertEquals(null, res[789].exec("vwxyz    ", 2289));
+assertEquals(null, res[789].exec("abc12345", 2290));
+assertEquals(null, res[789].exec("wxy123z", 2291));
+assertEquals(null, res[789].exec("*** Failers", 2292));
+assertEquals(null, res[789].exec("123abc", 2293));
+assertEquals(null, res[789].exec("123abc", 2294));
+assertEquals(null, res[789].exec("mno123456 ", 2295));
+assertEquals(null, res[789].exec("*** Failers", 2296));
+assertEquals(null, res[789].exec("abc12345", 2297));
+assertEquals(null, res[789].exec("wxy123z", 2298));
+assertEquals(null, res[789].exec("abcxyz", 2299));
+assertEquals(null, res[789].exec("123abcxyz999 ", 2300));
+assertEquals("abc", res[791].exec("abcdef"), 2301);
+assertEquals(null, res[791].exec("*** Failers", 2302));
+assertEquals("abc", res[791].exec("abcdefB  "), 2303);
+assertEquals(",", res[792].exec("bcd"), 2304);
+assertEquals("aaa,aaa", res[792].exec("aaabcd"), 2305);
+assertEquals(",", res[792].exec("xyz"), 2306);
+assertEquals(",", res[792].exec("xyzN  "), 2307);
+assertEquals(",", res[792].exec("*** Failers"), 2308);
+assertEquals(",", res[792].exec("bcdN   "), 2309);
+assertEquals("xyz", res[793].exec("xyz"), 2310);
+assertEquals(null, res[793].exec("xyz\n", 2311));
+assertEquals(null, res[793].exec("*** Failers", 2312));
+assertEquals(null, res[793].exec("xyzZ", 2313));
+assertEquals(null, res[793].exec("xyz\nZ    ", 2314));
+assertEquals("xyz", res[794].exec("xyz"), 2315);
+assertEquals("xyz", res[794].exec("xyz\n "), 2316);
+assertEquals("xyz", res[794].exec("abcxyz\npqr "), 2317);
+assertEquals("xyz", res[794].exec("abcxyz\npqrZ "), 2318);
+assertEquals("xyz", res[794].exec("xyz\nZ    "), 2319);
+assertEquals(null, res[794].exec("*** Failers", 2320));
+assertEquals(null, res[794].exec("xyzZ", 2321));
+assertEquals(null, res[795].exec("abcdef", 2322));
+assertEquals(null, res[795].exec("defabcxyz>3 ", 2323));
+assertEquals(null, res[795].exec("*** Failers ", 2324));
+assertEquals(null, res[795].exec("defabcxyz", 2325));
+assertEquals(null, res[796].exec("abP", 2326));
+assertEquals(null, res[796].exec("abcdeP", 2327));
+assertEquals("abcdef", res[796].exec("abcdefP"), 2328);
+assertEquals(null, res[796].exec("*** Failers", 2329));
+assertEquals(null, res[796].exec("abxP    ", 2330));
+assertEquals(null, res[797].exec("aP", 2331));
+assertEquals(null, res[797].exec("aaP", 2332));
+assertEquals(null, res[797].exec("aa2P ", 2333));
+assertEquals(null, res[797].exec("aaaP", 2334));
+assertEquals(null, res[797].exec("aaa23P ", 2335));
+assertEquals(null, res[797].exec("aaaa12345P", 2336));
+assertEquals("aa0z", res[797].exec("aa0zP"), 2337);
+assertEquals("aaaa4444444444444z", res[797].exec("aaaa4444444444444zP "), 2338);
+assertEquals(null, res[797].exec("*** Failers", 2339));
+assertEquals(null, res[797].exec("azP ", 2340));
+assertEquals(null, res[797].exec("aaaaaP ", 2341));
+assertEquals(null, res[797].exec("a56P ", 2342));
+assertEquals(null, res[799].exec("adfadadaklhlkalkajhlkjahdfasdfasdfladsfjkjPZ", 2343));
+assertEquals(null, res[799].exec("lkjhlkjhlkjhlkjhabbbbbbcdaefabbbbbbbefaPBZ", 2344));
+assertEquals(null, res[799].exec("cdabbbbbbbbPRBZ", 2345));
+assertEquals(null, res[799].exec("efabbbbbbbbbbbbbbbbPRBZ", 2346));
+assertEquals(null, res[799].exec("bbbbbbbbbbbbcdXyasdfadfPRBZ    ", 2347));
+assertEquals(null, res[799].exec("abc", 2348));
+assertEquals(null, res[799].exec("** Failers", 2349));
+assertEquals(null, res[799].exec("def  ", 2350));
+assertEquals("the quick brown fox", res[800].exec("the quick brown fox"), 2351);
+assertEquals(null, res[800].exec("The quick brown FOX", 2352));
+assertEquals("the quick brown fox", res[800].exec("What do you know about the quick brown fox?"), 2353);
+assertEquals(null, res[800].exec("What do you know about THE QUICK BROWN FOX?", 2354));
+assertEquals("the quick brown fox", res[801].exec("the quick brown fox"), 2355);
+assertEquals("The quick brown FOX", res[801].exec("The quick brown FOX"), 2356);
+assertEquals("the quick brown fox", res[801].exec("What do you know about the quick brown fox?"), 2357);
+assertEquals("THE QUICK BROWN FOX", res[801].exec("What do you know about THE QUICK BROWN FOX?"), 2358);
+assertEquals("abcd\x09\n\x0d\x0cae9;$\\?caxyz", res[802].exec("abcd\x09\n\x0d\x0cae9;$\\?caxyz"), 2359);
+assertEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2360);
+assertEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2361);
+assertEquals("aabxyzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzpqrrrabbxyyyypqAzz"), 2362);
+assertEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzpqrrrabbxyyyypqAzz"), 2363);
+assertEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzpqrrrabbxyyyypqAzz"), 2364);
+assertEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzpqrrrabbxyyyypqAzz"), 2365);
+assertEquals("aabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzpqrrrabbxyyyypqAzz"), 2366);
+assertEquals("aaabcxyzpqrrrabbxyyyypAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypAzz"), 2367);
+assertEquals("aaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqAzz"), 2368);
+assertEquals("aaabcxyzpqrrrabbxyyyypqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqAzz"), 2369);
+assertEquals("aaabcxyzpqrrrabbxyyyypqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqAzz"), 2370);
+assertEquals("aaabcxyzpqrrrabbxyyyypqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqAzz"), 2371);
+assertEquals("aaabcxyzpqrrrabbxyyyypqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqAzz"), 2372);
+assertEquals("aaabcxyzpqrrrabbxyyyypqqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqAzz"), 2373);
+assertEquals("aaaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzpqrrrabbxyyyypqAzz"), 2374);
+assertEquals("abxyzzpqrrrabbxyyyypqAzz", res[803].exec("abxyzzpqrrrabbxyyyypqAzz"), 2375);
+assertEquals("aabxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzzzpqrrrabbxyyyypqAzz"), 2376);
+assertEquals("aaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzzzzpqrrrabbxyyyypqAzz"), 2377);
+assertEquals("aaaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzzzzpqrrrabbxyyyypqAzz"), 2378);
+assertEquals("abcxyzzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzzpqrrrabbxyyyypqAzz"), 2379);
+assertEquals("aabcxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzzzpqrrrabbxyyyypqAzz"), 2380);
+assertEquals("aaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzzzzpqrrrabbxyyyypqAzz"), 2381);
+assertEquals("aaaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbxyyyypqAzz"), 2382);
+assertEquals("aaaabcxyzzzzpqrrrabbbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyypqAzz"), 2383);
+assertEquals("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz"), 2384);
+assertEquals("aaabcxyzpqrrrabbxyyyypABzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABzz"), 2385);
+assertEquals("aaabcxyzpqrrrabbxyyyypABBzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABBzz"), 2386);
+assertEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>aaabxyzpqrrrabbxyyyypqAzz"), 2387);
+assertEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">aaaabxyzpqrrrabbxyyyypqAzz"), 2388);
+assertEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>>abcxyzpqrrrabbxyyyypqAzz"), 2389);
+assertEquals(null, res[803].exec("*** Failers", 2390));
+assertEquals(null, res[803].exec("abxyzpqrrabbxyyyypqAzz", 2391));
+assertEquals(null, res[803].exec("abxyzpqrrrrabbxyyyypqAzz", 2392));
+assertEquals(null, res[803].exec("abxyzpqrrrabxyyyypqAzz", 2393));
+assertEquals(null, res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz", 2394));
+assertEquals(null, res[803].exec("aaaabcxyzzzzpqrrrabbbxyyypqAzz", 2395));
+assertEquals(null, res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqqAzz", 2396));
+assertEquals("abczz,abc", res[804].exec("abczz"), 2397);
+assertEquals("abcabczz,abc", res[804].exec("abcabczz"), 2398);
+assertEquals(null, res[804].exec("*** Failers", 2399));
+assertEquals(null, res[804].exec("zz", 2400));
+assertEquals(null, res[804].exec("abcabcabczz", 2401));
+assertEquals(null, res[804].exec(">>abczz", 2402));
+assertEquals("bc,b", res[805].exec("bc"), 2403);
+assertEquals("bbc,b", res[805].exec("bbc"), 2404);
+assertEquals("bbbc,bb", res[805].exec("bbbc"), 2405);
+assertEquals("bac,a", res[805].exec("bac"), 2406);
+assertEquals("bbac,a", res[805].exec("bbac"), 2407);
+assertEquals("aac,a", res[805].exec("aac"), 2408);
+assertEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[805].exec("abbbbbbbbbbbc"), 2409);
+assertEquals("bbbbbbbbbbbac,a", res[805].exec("bbbbbbbbbbbac"), 2410);
+assertEquals(null, res[805].exec("*** Failers", 2411));
+assertEquals(null, res[805].exec("aaac", 2412));
+assertEquals(null, res[805].exec("abbbbbbbbbbbac", 2413));
+assertEquals("bc,b", res[806].exec("bc"), 2414);
+assertEquals("bbc,bb", res[806].exec("bbc"), 2415);
+assertEquals("bbbc,bbb", res[806].exec("bbbc"), 2416);
+assertEquals("bac,a", res[806].exec("bac"), 2417);
+assertEquals("bbac,a", res[806].exec("bbac"), 2418);
+assertEquals("aac,a", res[806].exec("aac"), 2419);
+assertEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[806].exec("abbbbbbbbbbbc"), 2420);
+assertEquals("bbbbbbbbbbbac,a", res[806].exec("bbbbbbbbbbbac"), 2421);
+assertEquals(null, res[806].exec("*** Failers", 2422));
+assertEquals(null, res[806].exec("aaac", 2423));
+assertEquals(null, res[806].exec("abbbbbbbbbbbac", 2424));
+assertEquals("bbc,bb", res[806].exec("bbc"), 2425);
+assertEquals("babc,ba", res[807].exec("babc"), 2426);
+assertEquals("bbabc,ba", res[807].exec("bbabc"), 2427);
+assertEquals("bababc,ba", res[807].exec("bababc"), 2428);
+assertEquals(null, res[807].exec("*** Failers", 2429));
+assertEquals(null, res[807].exec("bababbc", 2430));
+assertEquals(null, res[807].exec("babababc", 2431));
+assertEquals("babc,ba", res[808].exec("babc"), 2432);
+assertEquals("bbabc,ba", res[808].exec("bbabc"), 2433);
+assertEquals("bababc,ba", res[808].exec("bababc"), 2434);
+assertEquals(null, res[808].exec("*** Failers", 2435));
+assertEquals(null, res[808].exec("bababbc", 2436));
+assertEquals(null, res[808].exec("babababc", 2437));
 assertThrows("var re = /^\\ca\\cA\\c[\\c{\\c:/;", 2438);
-assertNull(res[808].exec("\x01\x01e;z", 2439));
-assertToStringEquals("a", res[809].exec("athing"), 2440);
-assertToStringEquals("b", res[809].exec("bthing"), 2441);
-assertToStringEquals("]", res[809].exec("]thing"), 2442);
-assertToStringEquals("c", res[809].exec("cthing"), 2443);
-assertToStringEquals("d", res[809].exec("dthing"), 2444);
-assertToStringEquals("e", res[809].exec("ething"), 2445);
-assertNull(res[809].exec("*** Failers", 2446));
-assertNull(res[809].exec("fthing", 2447));
-assertNull(res[809].exec("[thing", 2448));
-assertNull(res[809].exec("\\thing", 2449));
-assertNull(res[810].exec("]thing", 2450));
-assertNull(res[810].exec("cthing", 2451));
-assertNull(res[810].exec("dthing", 2452));
-assertNull(res[810].exec("ething", 2453));
-assertNull(res[810].exec("*** Failers", 2454));
-assertNull(res[810].exec("athing", 2455));
-assertNull(res[810].exec("fthing", 2456));
-assertToStringEquals("f", res[811].exec("fthing"), 2457);
-assertToStringEquals("[", res[811].exec("[thing"), 2458);
-assertToStringEquals("\\", res[811].exec("\\thing"), 2459);
-assertToStringEquals("*", res[811].exec("*** Failers"), 2460);
-assertNull(res[811].exec("athing", 2461));
-assertNull(res[811].exec("bthing", 2462));
-assertNull(res[811].exec("]thing", 2463));
-assertNull(res[811].exec("cthing", 2464));
-assertNull(res[811].exec("dthing", 2465));
-assertNull(res[811].exec("ething", 2466));
-assertNull(res[812].exec("athing", 2467));
-assertNull(res[812].exec("fthing", 2468));
-assertNull(res[812].exec("*** Failers", 2469));
-assertNull(res[812].exec("]thing", 2470));
-assertNull(res[812].exec("cthing", 2471));
-assertNull(res[812].exec("dthing", 2472));
-assertNull(res[812].exec("ething", 2473));
-assertNull(res[812].exec("\ufffd", 2474));
-assertNull(res[812].exec("\ufffd", 2475));
-assertToStringEquals("0", res[813].exec("0"), 2476);
-assertToStringEquals("1", res[813].exec("1"), 2477);
-assertToStringEquals("2", res[813].exec("2"), 2478);
-assertToStringEquals("3", res[813].exec("3"), 2479);
-assertToStringEquals("4", res[813].exec("4"), 2480);
-assertToStringEquals("5", res[813].exec("5"), 2481);
-assertToStringEquals("6", res[813].exec("6"), 2482);
-assertToStringEquals("7", res[813].exec("7"), 2483);
-assertToStringEquals("8", res[813].exec("8"), 2484);
-assertToStringEquals("9", res[813].exec("9"), 2485);
-assertToStringEquals("10", res[813].exec("10"), 2486);
-assertToStringEquals("100", res[813].exec("100"), 2487);
-assertNull(res[813].exec("*** Failers", 2488));
-assertNull(res[813].exec("abc", 2489));
-assertToStringEquals("enter", res[814].exec("enter"), 2490);
-assertToStringEquals("inter", res[814].exec("inter"), 2491);
-assertToStringEquals("uponter", res[814].exec("uponter"), 2492);
-assertToStringEquals("xxx0", res[815].exec("xxx0"), 2493);
-assertToStringEquals("xxx1234", res[815].exec("xxx1234"), 2494);
-assertNull(res[815].exec("*** Failers", 2495));
-assertNull(res[815].exec("xxx", 2496));
-assertToStringEquals("x123", res[816].exec("x123"), 2497);
-assertToStringEquals("xx123", res[816].exec("xx123"), 2498);
-assertToStringEquals("123456", res[816].exec("123456"), 2499);
-assertNull(res[816].exec("*** Failers", 2500));
-assertNull(res[816].exec("123", 2501));
-assertToStringEquals("x1234", res[816].exec("x1234"), 2502);
-assertToStringEquals("x123", res[817].exec("x123"), 2503);
-assertToStringEquals("xx123", res[817].exec("xx123"), 2504);
-assertToStringEquals("123456", res[817].exec("123456"), 2505);
-assertNull(res[817].exec("*** Failers", 2506));
-assertNull(res[817].exec("123", 2507));
-assertToStringEquals("x1234", res[817].exec("x1234"), 2508);
-assertToStringEquals("abc!pqr=apquxz.ixr.zzz.ac.uk,abc,pqr", res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.uk"), 2509);
-assertNull(res[818].exec("*** Failers", 2510));
-assertNull(res[818].exec("!pqr=apquxz.ixr.zzz.ac.uk", 2511));
-assertNull(res[818].exec("abc!=apquxz.ixr.zzz.ac.uk", 2512));
-assertNull(res[818].exec("abc!pqr=apquxz:ixr.zzz.ac.uk", 2513));
-assertNull(res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.ukk", 2514));
-assertToStringEquals(":", res[819].exec("Well, we need a colon: somewhere"), 2515);
-assertNull(res[819].exec("*** Fail if we don't", 2516));
-assertToStringEquals("0abc,0abc", res[820].exec("0abc"), 2517);
-assertToStringEquals("abc,abc", res[820].exec("abc"), 2518);
-assertToStringEquals("fed,fed", res[820].exec("fed"), 2519);
-assertToStringEquals("E,E", res[820].exec("E"), 2520);
-assertToStringEquals("::,::", res[820].exec("::"), 2521);
-assertToStringEquals("5f03:12C0::932e,5f03:12C0::932e", res[820].exec("5f03:12C0::932e"), 2522);
-assertToStringEquals("def,def", res[820].exec("fed def"), 2523);
-assertToStringEquals("ff,ff", res[820].exec("Any old stuff"), 2524);
-assertNull(res[820].exec("*** Failers", 2525));
-assertNull(res[820].exec("0zzz", 2526));
-assertNull(res[820].exec("gzzz", 2527));
-assertNull(res[820].exec("fed ", 2528));
-assertNull(res[820].exec("Any old rubbish", 2529));
-assertToStringEquals(".1.2.3,1,2,3", res[821].exec(".1.2.3"), 2530);
-assertToStringEquals("A.12.123.0,12,123,0", res[821].exec("A.12.123.0"), 2531);
-assertNull(res[821].exec("*** Failers", 2532));
-assertNull(res[821].exec(".1.2.3333", 2533));
-assertNull(res[821].exec("1.2.3", 2534));
-assertNull(res[821].exec("1234.2.3", 2535));
-assertToStringEquals("1 IN SOA non-sp1 non-sp2(,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2("), 2536);
-assertToStringEquals("1    IN    SOA    non-sp1    non-sp2   (,1,non-sp1,non-sp2", res[822].exec("1    IN    SOA    non-sp1    non-sp2   ("), 2537);
-assertNull(res[822].exec("*** Failers", 2538));
-assertNull(res[822].exec("1IN SOA non-sp1 non-sp2(", 2539));
-assertToStringEquals("a.,", res[823].exec("a."), 2540);
-assertToStringEquals("Z.,", res[823].exec("Z."), 2541);
-assertToStringEquals("2.,", res[823].exec("2."), 2542);
-assertToStringEquals("ab-c.pq-r.,.pq-r", res[823].exec("ab-c.pq-r."), 2543);
-assertToStringEquals("sxk.zzz.ac.uk.,.uk", res[823].exec("sxk.zzz.ac.uk."), 2544);
-assertToStringEquals("x-.y-.,.y-", res[823].exec("x-.y-."), 2545);
-assertNull(res[823].exec("*** Failers", 2546));
-assertNull(res[823].exec("-abc.peq.", 2547));
-assertToStringEquals("*.a,,,", res[824].exec("*.a"), 2548);
-assertToStringEquals("*.b0-a,0-a,,", res[824].exec("*.b0-a"), 2549);
-assertToStringEquals("*.c3-b.c,3-b,.c,", res[824].exec("*.c3-b.c"), 2550);
-assertToStringEquals("*.c-a.b-c,-a,.b-c,-c", res[824].exec("*.c-a.b-c"), 2551);
-assertNull(res[824].exec("*** Failers", 2552));
-assertNull(res[824].exec("*.0", 2553));
-assertNull(res[824].exec("*.a-", 2554));
-assertNull(res[824].exec("*.a-b.c-", 2555));
-assertNull(res[824].exec("*.c-a.0-c", 2556));
-assertToStringEquals("abde,de,abd,e", res[825].exec("abde"), 2557);
-assertToStringEquals("abdf,,abd,f", res[826].exec("abdf"), 2558);
-assertToStringEquals("ab,abcd,cd,ab", res[827].exec("abcd"), 2559);
-assertToStringEquals("a.b.c.d,.d", res[828].exec("a.b.c.d"), 2560);
-assertToStringEquals("A.B.C.D,.D", res[828].exec("A.B.C.D"), 2561);
-assertToStringEquals("a.b.c.1.2.3.C,.C", res[828].exec("a.b.c.1.2.3.C"), 2562);
-assertToStringEquals("\"1234\",", res[829].exec("\"1234\""), 2563);
-assertToStringEquals("\"abcd\" ;,;", res[829].exec("\"abcd\" ;"), 2564);
-assertToStringEquals("\"\" ; rhubarb,; rhubarb", res[829].exec("\"\" ; rhubarb"), 2565);
-assertNull(res[829].exec("*** Failers", 2566));
-assertNull(res[829].exec("\"1234\" : things", 2567));
-assertNull(res[830].exec("\\", 2568));
-assertNull(res[830].exec("*** Failers", 2569));
-assertToStringEquals("ab c", res[831].exec("ab c"), 2570);
-assertNull(res[831].exec("*** Failers", 2571));
-assertNull(res[831].exec("abc", 2572));
-assertNull(res[831].exec("ab cde", 2573));
-assertToStringEquals("ab c", res[831].exec("ab c"), 2574);
-assertNull(res[831].exec("*** Failers", 2575));
-assertNull(res[831].exec("abc", 2576));
-assertNull(res[831].exec("ab cde", 2577));
-assertToStringEquals("a bcd", res[832].exec("a bcd"), 2578);
-assertNull(res[832].exec("a b d", 2579));
-assertNull(res[832].exec("*** Failers", 2580));
-assertNull(res[832].exec("abcd", 2581));
-assertNull(res[832].exec("ab d", 2582));
-assertToStringEquals("abcdefhijklm,abc,bc,c,def,ef,f,hij,ij,j,klm,lm,m", res[833].exec("abcdefhijklm"), 2583);
-assertToStringEquals("abcdefhijklm,bc,c,ef,f,ij,j,lm,m", res[834].exec("abcdefhijklm"), 2584);
-assertNull(res[835].exec("a+ Z0+\x08\n\x1d\x12", 2585));
-assertNull(res[835].exec(".^$(*+)|{?,?}", 2586));
-assertToStringEquals("z", res[836].exec("z"), 2587);
-assertToStringEquals("az", res[836].exec("az"), 2588);
-assertToStringEquals("aaaz", res[836].exec("aaaz"), 2589);
-assertToStringEquals("a", res[836].exec("a"), 2590);
-assertToStringEquals("aa", res[836].exec("aa"), 2591);
-assertToStringEquals("aaaa", res[836].exec("aaaa"), 2592);
-assertToStringEquals("a", res[836].exec("a+"), 2593);
-assertToStringEquals("aa", res[836].exec("aa+"), 2594);
-assertToStringEquals("z", res[837].exec("z"), 2595);
-assertToStringEquals("a", res[837].exec("az"), 2596);
-assertToStringEquals("a", res[837].exec("aaaz"), 2597);
-assertToStringEquals("a", res[837].exec("a"), 2598);
-assertToStringEquals("a", res[837].exec("aa"), 2599);
-assertToStringEquals("a", res[837].exec("aaaa"), 2600);
-assertToStringEquals("a", res[837].exec("a+"), 2601);
-assertToStringEquals("a", res[837].exec("aa+"), 2602);
-assertToStringEquals("az", res[838].exec("az"), 2603);
-assertToStringEquals("aaaz", res[838].exec("aaaz"), 2604);
-assertToStringEquals("aa", res[838].exec("aa"), 2605);
-assertToStringEquals("aaaa", res[838].exec("aaaa"), 2606);
-assertToStringEquals("aa", res[838].exec("aa+"), 2607);
-assertToStringEquals("az", res[839].exec("az"), 2608);
-assertToStringEquals("aa", res[839].exec("aaaz"), 2609);
-assertToStringEquals("aa", res[839].exec("aa"), 2610);
-assertToStringEquals("aa", res[839].exec("aaaa"), 2611);
-assertToStringEquals("aa", res[839].exec("aa+"), 2612);
-assertToStringEquals("1234567890", res[840].exec("1234567890"), 2613);
-assertToStringEquals("12345678ab", res[840].exec("12345678ab"), 2614);
-assertToStringEquals("12345678__", res[840].exec("12345678__"), 2615);
-assertNull(res[840].exec("*** Failers", 2616));
-assertNull(res[840].exec("1234567", 2617));
-assertToStringEquals("uoie", res[841].exec("uoie"), 2618);
-assertToStringEquals("1234", res[841].exec("1234"), 2619);
-assertToStringEquals("12345", res[841].exec("12345"), 2620);
-assertToStringEquals("aaaaa", res[841].exec("aaaaa"), 2621);
-assertNull(res[841].exec("*** Failers", 2622));
-assertNull(res[841].exec("123456", 2623));
-assertToStringEquals("uoie", res[842].exec("uoie"), 2624);
-assertToStringEquals("1234", res[842].exec("1234"), 2625);
-assertToStringEquals("1234", res[842].exec("12345"), 2626);
-assertToStringEquals("aaaa", res[842].exec("aaaaa"), 2627);
-assertToStringEquals("1234", res[842].exec("123456"), 2628);
-assertToStringEquals("From abcd  Mon Sep 01 12:33,abcd", res[843].exec("From abcd  Mon Sep 01 12:33:02 1997"), 2629);
-assertToStringEquals("From abcd  Mon Sep 01 12:33,Sep ", res[844].exec("From abcd  Mon Sep 01 12:33:02 1997"), 2630);
-assertToStringEquals("From abcd  Mon Sep  1 12:33,Sep  ", res[844].exec("From abcd  Mon Sep  1 12:33:02 1997"), 2631);
-assertNull(res[844].exec("*** Failers", 2632));
-assertNull(res[844].exec("From abcd  Sep 01 12:33:02 1997", 2633));
-assertNull(res[845].exec("12\n34", 2634));
-assertNull(res[845].exec("12\x0d34", 2635));
-assertToStringEquals("brown", res[846].exec("the quick brown\x09 fox"), 2636);
-assertToStringEquals("foolish see?,lish see?", res[847].exec("foobar is foolish see?"), 2637);
-assertToStringEquals("rowbar etc, etc", res[848].exec("foobar crowbar etc"), 2638);
-assertToStringEquals("barrel,rel", res[848].exec("barrel"), 2639);
-assertToStringEquals("2barrel,rel", res[848].exec("2barrel"), 2640);
-assertToStringEquals("A barrel,rel", res[848].exec("A barrel"), 2641);
-assertToStringEquals("abc,abc", res[849].exec("abc456"), 2642);
-assertNull(res[849].exec("*** Failers", 2643));
-assertNull(res[849].exec("abc123", 2644));
-assertToStringEquals("1234", res[850].exec("1234"), 2645);
-assertToStringEquals("1234", res[851].exec("1234"), 2646);
-assertToStringEquals("abcd", res[852].exec("abcd"), 2647);
-assertToStringEquals("abcd", res[853].exec("abcd"), 2648);
-assertToStringEquals("abc", res[854].exec("the abc"), 2649);
-assertNull(res[854].exec("*** Failers", 2650));
-assertNull(res[854].exec("abc", 2651));
-assertToStringEquals("abc", res[855].exec("abc"), 2652);
-assertNull(res[855].exec("*** Failers", 2653));
-assertNull(res[855].exec("the abc", 2654));
-assertToStringEquals("aabb,b", res[856].exec("aabbbbb"), 2655);
-assertToStringEquals("aabbbbb,abbbbb", res[857].exec("aabbbbb"), 2656);
-assertToStringEquals("aa,a", res[858].exec("aabbbbb"), 2657);
-assertToStringEquals("aabb,b", res[859].exec("aabbbbb"), 2658);
-assertToStringEquals("Alan Other <user@dom.ain>", res[860].exec("Alan Other <user@dom.ain>"), 2659);
-assertToStringEquals("user@dom.ain", res[860].exec("<user@dom.ain>"), 2660);
-assertToStringEquals("user@dom.ain", res[860].exec("user@dom.ain"), 2661);
-assertToStringEquals("\"A. Other\" <user.1234@dom.ain> (a comment)", res[860].exec("\"A. Other\" <user.1234@dom.ain> (a comment)"), 2662);
-assertToStringEquals(" Other <user.1234@dom.ain> (a comment)", res[860].exec("A. Other <user.1234@dom.ain> (a comment)"), 2663);
-assertToStringEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[860].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2664);
-assertToStringEquals("user@some.where", res[860].exec("A missing angle <user@some.where"), 2665);
-assertNull(res[860].exec("*** Failers", 2666));
-assertNull(res[860].exec("The quick brown fox", 2667));
-assertToStringEquals("Alan Other <user@dom.ain>", res[861].exec("Alan Other <user@dom.ain>"), 2668);
-assertToStringEquals("user@dom.ain", res[861].exec("<user@dom.ain>"), 2669);
-assertToStringEquals("user@dom.ain", res[861].exec("user@dom.ain"), 2670);
-assertToStringEquals("\"A. Other\" <user.1234@dom.ain>", res[861].exec("\"A. Other\" <user.1234@dom.ain> (a comment)"), 2671);
-assertToStringEquals(" Other <user.1234@dom.ain>", res[861].exec("A. Other <user.1234@dom.ain> (a comment)"), 2672);
-assertToStringEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[861].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2673);
-assertToStringEquals("user@some.where", res[861].exec("A missing angle <user@some.where"), 2674);
-assertNull(res[861].exec("*** Failers", 2675));
-assertNull(res[861].exec("The quick brown fox", 2676));
-assertNull(res[861].exec("abc\x00def\x00pqr\x00xyz\x000AB", 2677));
-assertNull(res[861].exec("abc456 abc\x00def\x00pqr\x00xyz\x000ABCDE", 2678));
-assertToStringEquals("abc\x0def\x00pqr\x000xyz\x0000AB", res[862].exec("abc\x0def\x00pqr\x000xyz\x0000AB"), 2679);
-assertToStringEquals("abc\x0def\x00pqr\x000xyz\x0000AB", res[862].exec("abc456 abc\x0def\x00pqr\x000xyz\x0000ABCDE"), 2680);
-assertToStringEquals("\x00", res[863].exec("\x00A"), 2681);
-assertToStringEquals("\x01", res[863].exec("\x01B"), 2682);
-assertToStringEquals("\x1f", res[863].exec("\x1fC"), 2683);
-assertToStringEquals("\x00\x00\x00\x00", res[864].exec("\x00\x00\x00\x00"), 2684);
-assertNull(res[865].exec("The Ax0x0Z", 2685));
-assertNull(res[865].exec("An A\x00x0\x00Z", 2686));
-assertNull(res[865].exec("*** Failers", 2687));
-assertNull(res[865].exec("A\x00Z", 2688));
-assertNull(res[865].exec("A\x00x0\x00x0Z", 2689));
-assertToStringEquals(" ", res[866].exec(" abc"), 2690);
-assertToStringEquals("\x0c", res[866].exec("\x0cabc"), 2691);
-assertToStringEquals("\n", res[866].exec("\nabc"), 2692);
-assertToStringEquals("\x0d", res[866].exec("\x0dabc"), 2693);
-assertToStringEquals("\x09", res[866].exec("\x09abc"), 2694);
-assertNull(res[866].exec("*** Failers", 2695));
-assertNull(res[866].exec("abc", 2696));
-assertToStringEquals("abc", res[867].exec("abc"), 2697);
-assertToStringEquals("abbbbc", res[868].exec("abbbbc"), 2698);
-assertToStringEquals("abbbc", res[868].exec("abbbc"), 2699);
-assertToStringEquals("abbc", res[868].exec("abbc"), 2700);
-assertNull(res[868].exec("*** Failers", 2701));
-assertNull(res[868].exec("abc", 2702));
-assertNull(res[868].exec("abbbbbc", 2703));
-assertToStringEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[869].exec("track1.title:TBlah blah blah"), 2704);
-assertToStringEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[870].exec("track1.title:TBlah blah blah"), 2705);
-assertToStringEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[871].exec("track1.title:TBlah blah blah"), 2706);
-assertToStringEquals("WXY_^abc", res[872].exec("WXY_^abc"), 2707);
-assertNull(res[872].exec("*** Failers", 2708));
-assertNull(res[872].exec("wxy", 2709));
-assertToStringEquals("WXY_^abc", res[873].exec("WXY_^abc"), 2710);
-assertToStringEquals("wxy_^ABC", res[873].exec("wxy_^ABC"), 2711);
-assertToStringEquals("WXY_^abc", res[874].exec("WXY_^abc"), 2712);
-assertToStringEquals("wxy_^ABC", res[874].exec("wxy_^ABC"), 2713);
-assertToStringEquals("abc", res[875].exec("abc"), 2714);
-assertToStringEquals("abc", res[875].exec("qqq\nabc"), 2715);
-assertToStringEquals("abc", res[875].exec("abc\nzzz"), 2716);
-assertToStringEquals("abc", res[875].exec("qqq\nabc\nzzz"), 2717);
-assertToStringEquals("abc", res[876].exec("abc"), 2718);
-assertNull(res[876].exec("*** Failers", 2719));
-assertNull(res[876].exec("qqq\nabc", 2720));
-assertNull(res[876].exec("abc\nzzz", 2721));
-assertNull(res[876].exec("qqq\nabc\nzzz", 2722));
-assertNull(res[877].exec("abc", 2723));
-assertNull(res[877].exec("abc\n ", 2724));
-assertNull(res[877].exec("*** Failers", 2725));
-assertNull(res[877].exec("qqq\nabc", 2726));
-assertNull(res[877].exec("abc\nzzz", 2727));
-assertNull(res[877].exec("qqq\nabc\nzzz", 2728));
-assertNull(res[878].exec("abc\ndef", 2729));
-assertNull(res[879].exec("*** Failers", 2730));
-assertNull(res[879].exec("abc\ndef", 2731));
-assertToStringEquals("b", res[880].exec("b::c"), 2732);
-assertToStringEquals("::", res[880].exec("c::b"), 2733);
-assertToStringEquals("az-", res[881].exec("az-"), 2734);
-assertToStringEquals("a", res[881].exec("*** Failers"), 2735);
-assertNull(res[881].exec("b", 2736));
-assertToStringEquals("za-", res[882].exec("za-"), 2737);
-assertToStringEquals("a", res[882].exec("*** Failers"), 2738);
-assertNull(res[882].exec("b", 2739));
-assertToStringEquals("a-z", res[883].exec("a-z"), 2740);
-assertToStringEquals("a", res[883].exec("*** Failers"), 2741);
-assertNull(res[883].exec("b", 2742));
-assertToStringEquals("abcdxyz", res[884].exec("abcdxyz"), 2743);
-assertToStringEquals("12-34", res[885].exec("12-34"), 2744);
-assertNull(res[885].exec("*** Failers", 2745));
-assertNull(res[885].exec("aaa", 2746));
-assertToStringEquals("12-34z", res[886].exec("12-34z"), 2747);
-assertNull(res[886].exec("*** Failers", 2748));
-assertNull(res[886].exec("aaa", 2749));
-assertToStringEquals("\\", res[887].exec("\\\\"), 2750);
-assertToStringEquals(" Z", res[888].exec("the Zoo"), 2751);
-assertNull(res[888].exec("*** Failers", 2752));
-assertNull(res[888].exec("Zulu", 2753));
-assertToStringEquals("ab{3cd", res[889].exec("ab{3cd"), 2754);
-assertToStringEquals("ab{3,cd", res[890].exec("ab{3,cd"), 2755);
-assertToStringEquals("ab{3,4a}cd", res[891].exec("ab{3,4a}cd"), 2756);
-assertToStringEquals("{4,5a}bc", res[892].exec("{4,5a}bc"), 2757);
-assertNull(res[893].exec("a\x0db", 2758));
-assertNull(res[893].exec("*** Failers", 2759));
-assertNull(res[893].exec("a\nb", 2760));
-assertToStringEquals("abc", res[894].exec("abc"), 2761);
-assertNull(res[894].exec("abc\n", 2762));
-assertNull(res[894].exec("*** Failers", 2763));
-assertNull(res[894].exec("abc\ndef", 2764));
-assertToStringEquals("abcS,abc", res[895].exec("abcS"), 2765);
-assertToStringEquals("abc\x93,abc", res[896].exec("abc\x93"), 2766);
-assertToStringEquals("abc\xd3,abc", res[897].exec("abc\xd3"), 2767);
-assertToStringEquals("abc@,abc", res[898].exec("abc@"), 2768);
-assertToStringEquals("abc@,abc", res[898].exec("abc@"), 2769);
-assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2770);
-assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2771);
-assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2772);
-assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2773);
-assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2774);
-assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2775);
-assertNull(res[899].exec("abc\x0081", 2776));
-assertNull(res[899].exec("abc\x0081", 2777));
-assertNull(res[900].exec("abc\x0091", 2778));
-assertNull(res[900].exec("abc\x0091", 2779));
-assertToStringEquals("abcdefghijk\nS,a,b,c,d,e,f,g,h,i,j,k", res[901].exec("abcdefghijk\nS"), 2780);
-assertToStringEquals("abidef", res[902].exec("abidef"), 2781);
-assertToStringEquals("bc", res[903].exec("bc"), 2782);
-assertToStringEquals("xyz,,", res[904].exec("xyz"), 2783);
-assertToStringEquals("abc\x08de", res[905].exec("abc\x08de"), 2784);
-assertToStringEquals("abc\x01de", res[906].exec("abc\x01de"), 2785);
-assertToStringEquals("abc\x01de,abc", res[907].exec("abc\x01de"), 2786);
-assertNull(res[907].exec("a\nb", 2787));
-assertToStringEquals("baNOTcccc,b,a,NOT,cccc", res[908].exec("baNOTccccd"), 2788);
-assertToStringEquals("baNOTccc,b,a,NOT,ccc", res[908].exec("baNOTcccd"), 2789);
-assertToStringEquals("baNOTcc,b,a,NO,Tcc", res[908].exec("baNOTccd"), 2790);
-assertToStringEquals("baccc,b,a,,ccc", res[908].exec("bacccd"), 2791);
-assertToStringEquals("*** Failers,*,*,* Fail,ers", res[908].exec("*** Failers"), 2792);
-assertNull(res[908].exec("anything", 2793));
-assertNull(res[908].exec("b\x08c   ", 2794));
-assertNull(res[908].exec("baccd", 2795));
-assertToStringEquals("A", res[909].exec("Abc"), 2796);
-assertToStringEquals("b", res[910].exec("Abc "), 2797);
-assertToStringEquals("AAA", res[911].exec("AAAaAbc"), 2798);
-assertToStringEquals("bc ", res[912].exec("AAAaAbc "), 2799);
-assertToStringEquals("bbb\nccc", res[913].exec("bbb\nccc"), 2800);
-assertToStringEquals("c", res[914].exec("abc"), 2801);
-assertToStringEquals("s", res[914].exec("*** Failers"), 2802);
-assertToStringEquals(" ", res[914].exec("abk   "), 2803);
-assertToStringEquals("abc", res[915].exec("abc"), 2804);
-assertToStringEquals("bc", res[915].exec("kbc"), 2805);
-assertToStringEquals("bc ", res[915].exec("kabc "), 2806);
-assertToStringEquals("ers", res[915].exec("*** Failers"), 2807);
-assertNull(res[915].exec("abk", 2808));
-assertNull(res[915].exec("akb", 2809));
-assertNull(res[915].exec("akk ", 2810));
-assertToStringEquals("12345678@a.b.c.d", res[916].exec("12345678@a.b.c.d"), 2811);
-assertToStringEquals("123456789@x.y.z", res[916].exec("123456789@x.y.z"), 2812);
-assertNull(res[916].exec("*** Failers", 2813));
-assertNull(res[916].exec("12345678@x.y.uk", 2814));
-assertNull(res[916].exec("1234567@a.b.c.d       ", 2815));
-assertToStringEquals("b", res[917].exec("aaaabcd"), 2816);
-assertToStringEquals("A", res[917].exec("aaAabcd "), 2817);
-assertToStringEquals("b", res[918].exec("aaaabcd"), 2818);
-assertToStringEquals("b", res[918].exec("aaAabcd "), 2819);
-assertToStringEquals("b", res[919].exec("aaaabcd"), 2820);
-assertToStringEquals("A", res[919].exec("aaAabcd "), 2821);
-assertToStringEquals("b", res[920].exec("aaaabcd"), 2822);
-assertToStringEquals("b", res[920].exec("aaAabcd "), 2823);
-assertToStringEquals("PSTAIREISLL", res[922].exec("xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"), 2824);
-assertToStringEquals("PSTAIREISLL", res[923].exec("xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"), 2825);
-assertToStringEquals(".230003938,.23", res[924].exec("1.230003938"), 2826);
-assertToStringEquals(".875000282,.875", res[924].exec("1.875000282   "), 2827);
-assertToStringEquals(".235,.23", res[924].exec("1.235  "), 2828);
-assertNull(res[924].exec("              ", 2829));
-assertToStringEquals(".23,.23,", res[925].exec("1.230003938      "), 2830);
-assertToStringEquals(".875,.875,5", res[925].exec("1.875000282"), 2831);
-assertNull(res[925].exec("*** Failers ", 2832));
-assertNull(res[925].exec("1.235 ", 2833));
+assertEquals(null, res[808].exec("\x01\x01e;z", 2439));
+assertEquals("a", res[809].exec("athing"), 2440);
+assertEquals("b", res[809].exec("bthing"), 2441);
+assertEquals("]", res[809].exec("]thing"), 2442);
+assertEquals("c", res[809].exec("cthing"), 2443);
+assertEquals("d", res[809].exec("dthing"), 2444);
+assertEquals("e", res[809].exec("ething"), 2445);
+assertEquals(null, res[809].exec("*** Failers", 2446));
+assertEquals(null, res[809].exec("fthing", 2447));
+assertEquals(null, res[809].exec("[thing", 2448));
+assertEquals(null, res[809].exec("\\thing", 2449));
+assertEquals(null, res[810].exec("]thing", 2450));
+assertEquals(null, res[810].exec("cthing", 2451));
+assertEquals(null, res[810].exec("dthing", 2452));
+assertEquals(null, res[810].exec("ething", 2453));
+assertEquals(null, res[810].exec("*** Failers", 2454));
+assertEquals(null, res[810].exec("athing", 2455));
+assertEquals(null, res[810].exec("fthing", 2456));
+assertEquals("f", res[811].exec("fthing"), 2457);
+assertEquals("[", res[811].exec("[thing"), 2458);
+assertEquals("\\", res[811].exec("\\thing"), 2459);
+assertEquals("*", res[811].exec("*** Failers"), 2460);
+assertEquals(null, res[811].exec("athing", 2461));
+assertEquals(null, res[811].exec("bthing", 2462));
+assertEquals(null, res[811].exec("]thing", 2463));
+assertEquals(null, res[811].exec("cthing", 2464));
+assertEquals(null, res[811].exec("dthing", 2465));
+assertEquals(null, res[811].exec("ething", 2466));
+assertEquals(null, res[812].exec("athing", 2467));
+assertEquals(null, res[812].exec("fthing", 2468));
+assertEquals(null, res[812].exec("*** Failers", 2469));
+assertEquals(null, res[812].exec("]thing", 2470));
+assertEquals(null, res[812].exec("cthing", 2471));
+assertEquals(null, res[812].exec("dthing", 2472));
+assertEquals(null, res[812].exec("ething", 2473));
+assertEquals(null, res[812].exec("\ufffd", 2474));
+assertEquals(null, res[812].exec("\ufffd", 2475));
+assertEquals("0", res[813].exec("0"), 2476);
+assertEquals("1", res[813].exec("1"), 2477);
+assertEquals("2", res[813].exec("2"), 2478);
+assertEquals("3", res[813].exec("3"), 2479);
+assertEquals("4", res[813].exec("4"), 2480);
+assertEquals("5", res[813].exec("5"), 2481);
+assertEquals("6", res[813].exec("6"), 2482);
+assertEquals("7", res[813].exec("7"), 2483);
+assertEquals("8", res[813].exec("8"), 2484);
+assertEquals("9", res[813].exec("9"), 2485);
+assertEquals("10", res[813].exec("10"), 2486);
+assertEquals("100", res[813].exec("100"), 2487);
+assertEquals(null, res[813].exec("*** Failers", 2488));
+assertEquals(null, res[813].exec("abc", 2489));
+assertEquals("enter", res[814].exec("enter"), 2490);
+assertEquals("inter", res[814].exec("inter"), 2491);
+assertEquals("uponter", res[814].exec("uponter"), 2492);
+assertEquals("xxx0", res[815].exec("xxx0"), 2493);
+assertEquals("xxx1234", res[815].exec("xxx1234"), 2494);
+assertEquals(null, res[815].exec("*** Failers", 2495));
+assertEquals(null, res[815].exec("xxx", 2496));
+assertEquals("x123", res[816].exec("x123"), 2497);
+assertEquals("xx123", res[816].exec("xx123"), 2498);
+assertEquals("123456", res[816].exec("123456"), 2499);
+assertEquals(null, res[816].exec("*** Failers", 2500));
+assertEquals(null, res[816].exec("123", 2501));
+assertEquals("x1234", res[816].exec("x1234"), 2502);
+assertEquals("x123", res[817].exec("x123"), 2503);
+assertEquals("xx123", res[817].exec("xx123"), 2504);
+assertEquals("123456", res[817].exec("123456"), 2505);
+assertEquals(null, res[817].exec("*** Failers", 2506));
+assertEquals(null, res[817].exec("123", 2507));
+assertEquals("x1234", res[817].exec("x1234"), 2508);
+assertEquals("abc!pqr=apquxz.ixr.zzz.ac.uk,abc,pqr", res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.uk"), 2509);
+assertEquals(null, res[818].exec("*** Failers", 2510));
+assertEquals(null, res[818].exec("!pqr=apquxz.ixr.zzz.ac.uk", 2511));
+assertEquals(null, res[818].exec("abc!=apquxz.ixr.zzz.ac.uk", 2512));
+assertEquals(null, res[818].exec("abc!pqr=apquxz:ixr.zzz.ac.uk", 2513));
+assertEquals(null, res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.ukk", 2514));
+assertEquals(":", res[819].exec("Well, we need a colon: somewhere"), 2515);
+assertEquals(null, res[819].exec("*** Fail if we don't", 2516));
+assertEquals("0abc,0abc", res[820].exec("0abc"), 2517);
+assertEquals("abc,abc", res[820].exec("abc"), 2518);
+assertEquals("fed,fed", res[820].exec("fed"), 2519);
+assertEquals("E,E", res[820].exec("E"), 2520);
+assertEquals("::,::", res[820].exec("::"), 2521);
+assertEquals("5f03:12C0::932e,5f03:12C0::932e", res[820].exec("5f03:12C0::932e"), 2522);
+assertEquals("def,def", res[820].exec("fed def"), 2523);
+assertEquals("ff,ff", res[820].exec("Any old stuff"), 2524);
+assertEquals(null, res[820].exec("*** Failers", 2525));
+assertEquals(null, res[820].exec("0zzz", 2526));
+assertEquals(null, res[820].exec("gzzz", 2527));
+assertEquals(null, res[820].exec("fed ", 2528));
+assertEquals(null, res[820].exec("Any old rubbish", 2529));
+assertEquals(".1.2.3,1,2,3", res[821].exec(".1.2.3"), 2530);
+assertEquals("A.12.123.0,12,123,0", res[821].exec("A.12.123.0"), 2531);
+assertEquals(null, res[821].exec("*** Failers", 2532));
+assertEquals(null, res[821].exec(".1.2.3333", 2533));
+assertEquals(null, res[821].exec("1.2.3", 2534));
+assertEquals(null, res[821].exec("1234.2.3", 2535));
+assertEquals("1 IN SOA non-sp1 non-sp2(,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2("), 2536);
+assertEquals("1    IN    SOA    non-sp1    non-sp2   (,1,non-sp1,non-sp2", res[822].exec("1    IN    SOA    non-sp1    non-sp2   ("), 2537);
+assertEquals(null, res[822].exec("*** Failers", 2538));
+assertEquals(null, res[822].exec("1IN SOA non-sp1 non-sp2(", 2539));
+assertEquals("a.,", res[823].exec("a."), 2540);
+assertEquals("Z.,", res[823].exec("Z."), 2541);
+assertEquals("2.,", res[823].exec("2."), 2542);
+assertEquals("ab-c.pq-r.,.pq-r", res[823].exec("ab-c.pq-r."), 2543);
+assertEquals("sxk.zzz.ac.uk.,.uk", res[823].exec("sxk.zzz.ac.uk."), 2544);
+assertEquals("x-.y-.,.y-", res[823].exec("x-.y-."), 2545);
+assertEquals(null, res[823].exec("*** Failers", 2546));
+assertEquals(null, res[823].exec("-abc.peq.", 2547));
+assertEquals("*.a,,,", res[824].exec("*.a"), 2548);
+assertEquals("*.b0-a,0-a,,", res[824].exec("*.b0-a"), 2549);
+assertEquals("*.c3-b.c,3-b,.c,", res[824].exec("*.c3-b.c"), 2550);
+assertEquals("*.c-a.b-c,-a,.b-c,-c", res[824].exec("*.c-a.b-c"), 2551);
+assertEquals(null, res[824].exec("*** Failers", 2552));
+assertEquals(null, res[824].exec("*.0", 2553));
+assertEquals(null, res[824].exec("*.a-", 2554));
+assertEquals(null, res[824].exec("*.a-b.c-", 2555));
+assertEquals(null, res[824].exec("*.c-a.0-c", 2556));
+assertEquals("abde,de,abd,e", res[825].exec("abde"), 2557);
+assertEquals("abdf,,abd,f", res[826].exec("abdf"), 2558);
+assertEquals("ab,abcd,cd,ab", res[827].exec("abcd"), 2559);
+assertEquals("a.b.c.d,.d", res[828].exec("a.b.c.d"), 2560);
+assertEquals("A.B.C.D,.D", res[828].exec("A.B.C.D"), 2561);
+assertEquals("a.b.c.1.2.3.C,.C", res[828].exec("a.b.c.1.2.3.C"), 2562);
+assertEquals("\"1234\",", res[829].exec("\"1234\""), 2563);
+assertEquals("\"abcd\" ;,;", res[829].exec("\"abcd\" ;"), 2564);
+assertEquals("\"\" ; rhubarb,; rhubarb", res[829].exec("\"\" ; rhubarb"), 2565);
+assertEquals(null, res[829].exec("*** Failers", 2566));
+assertEquals(null, res[829].exec("\"1234\" : things", 2567));
+assertEquals(null, res[830].exec("\\", 2568));
+assertEquals(null, res[830].exec("*** Failers", 2569));
+assertEquals("ab c", res[831].exec("ab c"), 2570);
+assertEquals(null, res[831].exec("*** Failers", 2571));
+assertEquals(null, res[831].exec("abc", 2572));
+assertEquals(null, res[831].exec("ab cde", 2573));
+assertEquals("ab c", res[831].exec("ab c"), 2574);
+assertEquals(null, res[831].exec("*** Failers", 2575));
+assertEquals(null, res[831].exec("abc", 2576));
+assertEquals(null, res[831].exec("ab cde", 2577));
+assertEquals("a bcd", res[832].exec("a bcd"), 2578);
+assertEquals(null, res[832].exec("a b d", 2579));
+assertEquals(null, res[832].exec("*** Failers", 2580));
+assertEquals(null, res[832].exec("abcd", 2581));
+assertEquals(null, res[832].exec("ab d", 2582));
+assertEquals("abcdefhijklm,abc,bc,c,def,ef,f,hij,ij,j,klm,lm,m", res[833].exec("abcdefhijklm"), 2583);
+assertEquals("abcdefhijklm,bc,c,ef,f,ij,j,lm,m", res[834].exec("abcdefhijklm"), 2584);
+assertEquals(null, res[835].exec("a+ Z0+\x08\n\x1d\x12", 2585));
+assertEquals(null, res[835].exec(".^$(*+)|{?,?}", 2586));
+assertEquals("z", res[836].exec("z"), 2587);
+assertEquals("az", res[836].exec("az"), 2588);
+assertEquals("aaaz", res[836].exec("aaaz"), 2589);
+assertEquals("a", res[836].exec("a"), 2590);
+assertEquals("aa", res[836].exec("aa"), 2591);
+assertEquals("aaaa", res[836].exec("aaaa"), 2592);
+assertEquals("a", res[836].exec("a+"), 2593);
+assertEquals("aa", res[836].exec("aa+"), 2594);
+assertEquals("z", res[837].exec("z"), 2595);
+assertEquals("a", res[837].exec("az"), 2596);
+assertEquals("a", res[837].exec("aaaz"), 2597);
+assertEquals("a", res[837].exec("a"), 2598);
+assertEquals("a", res[837].exec("aa"), 2599);
+assertEquals("a", res[837].exec("aaaa"), 2600);
+assertEquals("a", res[837].exec("a+"), 2601);
+assertEquals("a", res[837].exec("aa+"), 2602);
+assertEquals("az", res[838].exec("az"), 2603);
+assertEquals("aaaz", res[838].exec("aaaz"), 2604);
+assertEquals("aa", res[838].exec("aa"), 2605);
+assertEquals("aaaa", res[838].exec("aaaa"), 2606);
+assertEquals("aa", res[838].exec("aa+"), 2607);
+assertEquals("az", res[839].exec("az"), 2608);
+assertEquals("aa", res[839].exec("aaaz"), 2609);
+assertEquals("aa", res[839].exec("aa"), 2610);
+assertEquals("aa", res[839].exec("aaaa"), 2611);
+assertEquals("aa", res[839].exec("aa+"), 2612);
+assertEquals("1234567890", res[840].exec("1234567890"), 2613);
+assertEquals("12345678ab", res[840].exec("12345678ab"), 2614);
+assertEquals("12345678__", res[840].exec("12345678__"), 2615);
+assertEquals(null, res[840].exec("*** Failers", 2616));
+assertEquals(null, res[840].exec("1234567", 2617));
+assertEquals("uoie", res[841].exec("uoie"), 2618);
+assertEquals("1234", res[841].exec("1234"), 2619);
+assertEquals("12345", res[841].exec("12345"), 2620);
+assertEquals("aaaaa", res[841].exec("aaaaa"), 2621);
+assertEquals(null, res[841].exec("*** Failers", 2622));
+assertEquals(null, res[841].exec("123456", 2623));
+assertEquals("uoie", res[842].exec("uoie"), 2624);
+assertEquals("1234", res[842].exec("1234"), 2625);
+assertEquals("1234", res[842].exec("12345"), 2626);
+assertEquals("aaaa", res[842].exec("aaaaa"), 2627);
+assertEquals("1234", res[842].exec("123456"), 2628);
+assertEquals("From abcd  Mon Sep 01 12:33,abcd", res[843].exec("From abcd  Mon Sep 01 12:33:02 1997"), 2629);
+assertEquals("From abcd  Mon Sep 01 12:33,Sep ", res[844].exec("From abcd  Mon Sep 01 12:33:02 1997"), 2630);
+assertEquals("From abcd  Mon Sep  1 12:33,Sep  ", res[844].exec("From abcd  Mon Sep  1 12:33:02 1997"), 2631);
+assertEquals(null, res[844].exec("*** Failers", 2632));
+assertEquals(null, res[844].exec("From abcd  Sep 01 12:33:02 1997", 2633));
+assertEquals(null, res[845].exec("12\n34", 2634));
+assertEquals(null, res[845].exec("12\x0d34", 2635));
+assertEquals("brown", res[846].exec("the quick brown\x09 fox"), 2636);
+assertEquals("foolish see?,lish see?", res[847].exec("foobar is foolish see?"), 2637);
+assertEquals("rowbar etc, etc", res[848].exec("foobar crowbar etc"), 2638);
+assertEquals("barrel,rel", res[848].exec("barrel"), 2639);
+assertEquals("2barrel,rel", res[848].exec("2barrel"), 2640);
+assertEquals("A barrel,rel", res[848].exec("A barrel"), 2641);
+assertEquals("abc,abc", res[849].exec("abc456"), 2642);
+assertEquals(null, res[849].exec("*** Failers", 2643));
+assertEquals(null, res[849].exec("abc123", 2644));
+assertEquals("1234", res[850].exec("1234"), 2645);
+assertEquals("1234", res[851].exec("1234"), 2646);
+assertEquals("abcd", res[852].exec("abcd"), 2647);
+assertEquals("abcd", res[853].exec("abcd"), 2648);
+assertEquals("abc", res[854].exec("the abc"), 2649);
+assertEquals(null, res[854].exec("*** Failers", 2650));
+assertEquals(null, res[854].exec("abc", 2651));
+assertEquals("abc", res[855].exec("abc"), 2652);
+assertEquals(null, res[855].exec("*** Failers", 2653));
+assertEquals(null, res[855].exec("the abc", 2654));
+assertEquals("aabb,b", res[856].exec("aabbbbb"), 2655);
+assertEquals("aabbbbb,abbbbb", res[857].exec("aabbbbb"), 2656);
+assertEquals("aa,a", res[858].exec("aabbbbb"), 2657);
+assertEquals("aabb,b", res[859].exec("aabbbbb"), 2658);
+assertEquals("Alan Other <user@dom.ain>", res[860].exec("Alan Other <user@dom.ain>"), 2659);
+assertEquals("user@dom.ain", res[860].exec("<user@dom.ain>"), 2660);
+assertEquals("user@dom.ain", res[860].exec("user@dom.ain"), 2661);
+assertEquals("\"A. Other\" <user.1234@dom.ain> (a comment)", res[860].exec("\"A. Other\" <user.1234@dom.ain> (a comment)"), 2662);
+assertEquals(" Other <user.1234@dom.ain> (a comment)", res[860].exec("A. Other <user.1234@dom.ain> (a comment)"), 2663);
+assertEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[860].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2664);
+assertEquals("user@some.where", res[860].exec("A missing angle <user@some.where"), 2665);
+assertEquals(null, res[860].exec("*** Failers", 2666));
+assertEquals(null, res[860].exec("The quick brown fox", 2667));
+assertEquals("Alan Other <user@dom.ain>", res[861].exec("Alan Other <user@dom.ain>"), 2668);
+assertEquals("user@dom.ain", res[861].exec("<user@dom.ain>"), 2669);
+assertEquals("user@dom.ain", res[861].exec("user@dom.ain"), 2670);
+assertEquals("\"A. Other\" <user.1234@dom.ain>", res[861].exec("\"A. Other\" <user.1234@dom.ain> (a comment)"), 2671);
+assertEquals(" Other <user.1234@dom.ain>", res[861].exec("A. Other <user.1234@dom.ain> (a comment)"), 2672);
+assertEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[861].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2673);
+assertEquals("user@some.where", res[861].exec("A missing angle <user@some.where"), 2674);
+assertEquals(null, res[861].exec("*** Failers", 2675));
+assertEquals(null, res[861].exec("The quick brown fox", 2676));
+assertEquals(null, res[861].exec("abc\x00def\x00pqr\x00xyz\x000AB", 2677));
+assertEquals(null, res[861].exec("abc456 abc\x00def\x00pqr\x00xyz\x000ABCDE", 2678));
+assertEquals("abc\x0def\x00pqr\x000xyz\x0000AB", res[862].exec("abc\x0def\x00pqr\x000xyz\x0000AB"), 2679);
+assertEquals("abc\x0def\x00pqr\x000xyz\x0000AB", res[862].exec("abc456 abc\x0def\x00pqr\x000xyz\x0000ABCDE"), 2680);
+assertEquals("\x00", res[863].exec("\x00A"), 2681);
+assertEquals("\x01", res[863].exec("\x01B"), 2682);
+assertEquals("\x1f", res[863].exec("\x1fC"), 2683);
+assertEquals("\x00\x00\x00\x00", res[864].exec("\x00\x00\x00\x00"), 2684);
+assertEquals(null, res[865].exec("The Ax0x0Z", 2685));
+assertEquals(null, res[865].exec("An A\x00x0\x00Z", 2686));
+assertEquals(null, res[865].exec("*** Failers", 2687));
+assertEquals(null, res[865].exec("A\x00Z", 2688));
+assertEquals(null, res[865].exec("A\x00x0\x00x0Z", 2689));
+assertEquals(" ", res[866].exec(" abc"), 2690);
+assertEquals("\x0c", res[866].exec("\x0cabc"), 2691);
+assertEquals("\n", res[866].exec("\nabc"), 2692);
+assertEquals("\x0d", res[866].exec("\x0dabc"), 2693);
+assertEquals("\x09", res[866].exec("\x09abc"), 2694);
+assertEquals(null, res[866].exec("*** Failers", 2695));
+assertEquals(null, res[866].exec("abc", 2696));
+assertEquals("abc", res[867].exec("abc"), 2697);
+assertEquals("abbbbc", res[868].exec("abbbbc"), 2698);
+assertEquals("abbbc", res[868].exec("abbbc"), 2699);
+assertEquals("abbc", res[868].exec("abbc"), 2700);
+assertEquals(null, res[868].exec("*** Failers", 2701));
+assertEquals(null, res[868].exec("abc", 2702));
+assertEquals(null, res[868].exec("abbbbbc", 2703));
+assertEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[869].exec("track1.title:TBlah blah blah"), 2704);
+assertEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[870].exec("track1.title:TBlah blah blah"), 2705);
+assertEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[871].exec("track1.title:TBlah blah blah"), 2706);
+assertEquals("WXY_^abc", res[872].exec("WXY_^abc"), 2707);
+assertEquals(null, res[872].exec("*** Failers", 2708));
+assertEquals(null, res[872].exec("wxy", 2709));
+assertEquals("WXY_^abc", res[873].exec("WXY_^abc"), 2710);
+assertEquals("wxy_^ABC", res[873].exec("wxy_^ABC"), 2711);
+assertEquals("WXY_^abc", res[874].exec("WXY_^abc"), 2712);
+assertEquals("wxy_^ABC", res[874].exec("wxy_^ABC"), 2713);
+assertEquals("abc", res[875].exec("abc"), 2714);
+assertEquals("abc", res[875].exec("qqq\nabc"), 2715);
+assertEquals("abc", res[875].exec("abc\nzzz"), 2716);
+assertEquals("abc", res[875].exec("qqq\nabc\nzzz"), 2717);
+assertEquals("abc", res[876].exec("abc"), 2718);
+assertEquals(null, res[876].exec("*** Failers", 2719));
+assertEquals(null, res[876].exec("qqq\nabc", 2720));
+assertEquals(null, res[876].exec("abc\nzzz", 2721));
+assertEquals(null, res[876].exec("qqq\nabc\nzzz", 2722));
+assertEquals(null, res[877].exec("abc", 2723));
+assertEquals(null, res[877].exec("abc\n ", 2724));
+assertEquals(null, res[877].exec("*** Failers", 2725));
+assertEquals(null, res[877].exec("qqq\nabc", 2726));
+assertEquals(null, res[877].exec("abc\nzzz", 2727));
+assertEquals(null, res[877].exec("qqq\nabc\nzzz", 2728));
+assertEquals(null, res[878].exec("abc\ndef", 2729));
+assertEquals(null, res[879].exec("*** Failers", 2730));
+assertEquals(null, res[879].exec("abc\ndef", 2731));
+assertEquals("b", res[880].exec("b::c"), 2732);
+assertEquals("::", res[880].exec("c::b"), 2733);
+assertEquals("az-", res[881].exec("az-"), 2734);
+assertEquals("a", res[881].exec("*** Failers"), 2735);
+assertEquals(null, res[881].exec("b", 2736));
+assertEquals("za-", res[882].exec("za-"), 2737);
+assertEquals("a", res[882].exec("*** Failers"), 2738);
+assertEquals(null, res[882].exec("b", 2739));
+assertEquals("a-z", res[883].exec("a-z"), 2740);
+assertEquals("a", res[883].exec("*** Failers"), 2741);
+assertEquals(null, res[883].exec("b", 2742));
+assertEquals("abcdxyz", res[884].exec("abcdxyz"), 2743);
+assertEquals("12-34", res[885].exec("12-34"), 2744);
+assertEquals(null, res[885].exec("*** Failers", 2745));
+assertEquals(null, res[885].exec("aaa", 2746));
+assertEquals("12-34z", res[886].exec("12-34z"), 2747);
+assertEquals(null, res[886].exec("*** Failers", 2748));
+assertEquals(null, res[886].exec("aaa", 2749));
+assertEquals("\\", res[887].exec("\\\\"), 2750);
+assertEquals(" Z", res[888].exec("the Zoo"), 2751);
+assertEquals(null, res[888].exec("*** Failers", 2752));
+assertEquals(null, res[888].exec("Zulu", 2753));
+assertEquals("ab{3cd", res[889].exec("ab{3cd"), 2754);
+assertEquals("ab{3,cd", res[890].exec("ab{3,cd"), 2755);
+assertEquals("ab{3,4a}cd", res[891].exec("ab{3,4a}cd"), 2756);
+assertEquals("{4,5a}bc", res[892].exec("{4,5a}bc"), 2757);
+assertEquals(null, res[893].exec("a\x0db", 2758));
+assertEquals(null, res[893].exec("*** Failers", 2759));
+assertEquals(null, res[893].exec("a\nb", 2760));
+assertEquals("abc", res[894].exec("abc"), 2761);
+assertEquals(null, res[894].exec("abc\n", 2762));
+assertEquals(null, res[894].exec("*** Failers", 2763));
+assertEquals(null, res[894].exec("abc\ndef", 2764));
+assertEquals("abcS,abc", res[895].exec("abcS"), 2765);
+assertEquals("abc\x93,abc", res[896].exec("abc\x93"), 2766);
+assertEquals("abc\xd3,abc", res[897].exec("abc\xd3"), 2767);
+assertEquals("abc@,abc", res[898].exec("abc@"), 2768);
+assertEquals("abc@,abc", res[898].exec("abc@"), 2769);
+assertEquals("abc@,abc", res[898].exec("abc@0"), 2770);
+assertEquals("abc@,abc", res[898].exec("abc@0"), 2771);
+assertEquals("abc@,abc", res[898].exec("abc@0"), 2772);
+assertEquals("abc@,abc", res[898].exec("abc@0"), 2773);
+assertEquals("abc@,abc", res[898].exec("abc@0"), 2774);
+assertEquals("abc@,abc", res[898].exec("abc@0"), 2775);
+assertEquals(null, res[899].exec("abc\x0081", 2776));
+assertEquals(null, res[899].exec("abc\x0081", 2777));
+assertEquals(null, res[900].exec("abc\x0091", 2778));
+assertEquals(null, res[900].exec("abc\x0091", 2779));
+assertEquals("abcdefghijk\nS,a,b,c,d,e,f,g,h,i,j,k", res[901].exec("abcdefghijk\nS"), 2780);
+assertEquals("abidef", res[902].exec("abidef"), 2781);
+assertEquals("bc", res[903].exec("bc"), 2782);
+assertEquals("xyz,,", res[904].exec("xyz"), 2783);
+assertEquals("abc\x08de", res[905].exec("abc\x08de"), 2784);
+assertEquals("abc\x01de", res[906].exec("abc\x01de"), 2785);
+assertEquals("abc\x01de,abc", res[907].exec("abc\x01de"), 2786);
+assertEquals(null, res[907].exec("a\nb", 2787));
+assertEquals("baNOTcccc,b,a,NOT,cccc", res[908].exec("baNOTccccd"), 2788);
+assertEquals("baNOTccc,b,a,NOT,ccc", res[908].exec("baNOTcccd"), 2789);
+assertEquals("baNOTcc,b,a,NO,Tcc", res[908].exec("baNOTccd"), 2790);
+assertEquals("baccc,b,a,,ccc", res[908].exec("bacccd"), 2791);
+assertEquals("*** Failers,*,*,* Fail,ers", res[908].exec("*** Failers"), 2792);
+assertEquals(null, res[908].exec("anything", 2793));
+assertEquals(null, res[908].exec("b\x08c   ", 2794));
+assertEquals(null, res[908].exec("baccd", 2795));
+assertEquals("A", res[909].exec("Abc"), 2796);
+assertEquals("b", res[910].exec("Abc "), 2797);
+assertEquals("AAA", res[911].exec("AAAaAbc"), 2798);
+assertEquals("bc ", res[912].exec("AAAaAbc "), 2799);
+assertEquals("bbb\nccc", res[913].exec("bbb\nccc"), 2800);
+assertEquals("c", res[914].exec("abc"), 2801);
+assertEquals("s", res[914].exec("*** Failers"), 2802);
+assertEquals(" ", res[914].exec("abk   "), 2803);
+assertEquals("abc", res[915].exec("abc"), 2804);
+assertEquals("bc", res[915].exec("kbc"), 2805);
+assertEquals("bc ", res[915].exec("kabc "), 2806);
+assertEquals("ers", res[915].exec("*** Failers"), 2807);
+assertEquals(null, res[915].exec("abk", 2808));
+assertEquals(null, res[915].exec("akb", 2809));
+assertEquals(null, res[915].exec("akk ", 2810));
+assertEquals("12345678@a.b.c.d", res[916].exec("12345678@a.b.c.d"), 2811);
+assertEquals("123456789@x.y.z", res[916].exec("123456789@x.y.z"), 2812);
+assertEquals(null, res[916].exec("*** Failers", 2813));
+assertEquals(null, res[916].exec("12345678@x.y.uk", 2814));
+assertEquals(null, res[916].exec("1234567@a.b.c.d       ", 2815));
+assertEquals("b", res[917].exec("aaaabcd"), 2816);
+assertEquals("A", res[917].exec("aaAabcd "), 2817);
+assertEquals("b", res[918].exec("aaaabcd"), 2818);
+assertEquals("b", res[918].exec("aaAabcd "), 2819);
+assertEquals("b", res[919].exec("aaaabcd"), 2820);
+assertEquals("A", res[919].exec("aaAabcd "), 2821);
+assertEquals("b", res[920].exec("aaaabcd"), 2822);
+assertEquals("b", res[920].exec("aaAabcd "), 2823);
+assertEquals("PSTAIREISLL", res[922].exec("xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"), 2824);
+assertEquals("PSTAIREISLL", res[923].exec("xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"), 2825);
+assertEquals(".230003938,.23", res[924].exec("1.230003938"), 2826);
+assertEquals(".875000282,.875", res[924].exec("1.875000282   "), 2827);
+assertEquals(".235,.23", res[924].exec("1.235  "), 2828);
+assertEquals(null, res[924].exec("              ", 2829));
+assertEquals(".23,.23,", res[925].exec("1.230003938      "), 2830);
+assertEquals(".875,.875,5", res[925].exec("1.875000282"), 2831);
+assertEquals(null, res[925].exec("*** Failers ", 2832));
+assertEquals(null, res[925].exec("1.235 ", 2833));
 assertThrows("var re = /a(?)b/;", 2834);
-assertNull(res[925].exec("ab ", 2835));
-assertToStringEquals("foo table,foo,table", res[926].exec("Food is on the foo table"), 2836);
-assertToStringEquals("food is under the bar in the bar,d is under the bar in the ", res[927].exec("The food is under the bar in the barn."), 2837);
-assertToStringEquals("food is under the bar,d is under the ", res[928].exec("The food is under the bar in the barn."), 2838);
-assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: 53147,", res[929].exec("I have 2 numbers: 53147"), 2839);
-assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: 5314,7", res[930].exec("I have 2 numbers: 53147"), 2840);
-assertToStringEquals(",,", res[931].exec("I have 2 numbers: 53147"), 2841);
-assertToStringEquals("I have 2,I have ,2", res[932].exec("I have 2 numbers: 53147"), 2842);
-assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: 5314,7", res[933].exec("I have 2 numbers: 53147"), 2843);
-assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[934].exec("I have 2 numbers: 53147"), 2844);
-assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[935].exec("I have 2 numbers: 53147"), 2845);
-assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[936].exec("I have 2 numbers: 53147"), 2846);
-assertToStringEquals("AB", res[937].exec("ABC123"), 2847);
-assertToStringEquals(" ", res[937].exec(" "), 2848);
-assertToStringEquals("ABC,ABC", res[938].exec("ABC445"), 2849);
-assertNull(res[938].exec("*** Failers", 2850));
-assertNull(res[938].exec("ABC123", 2851));
-assertToStringEquals("W46]", res[939].exec("W46]789 "), 2852);
-assertToStringEquals("-46]", res[939].exec("-46]789"), 2853);
-assertNull(res[939].exec("*** Failers", 2854));
-assertNull(res[939].exec("Wall", 2855));
-assertNull(res[939].exec("Zebra", 2856));
-assertNull(res[939].exec("42", 2857));
-assertNull(res[939].exec("[abcd] ", 2858));
-assertNull(res[939].exec("]abcd[", 2859));
-assertNull(res[939].exec("   ", 2860));
-assertToStringEquals("W", res[940].exec("W46]789 "), 2861);
-assertToStringEquals("W", res[940].exec("Wall"), 2862);
-assertToStringEquals("Z", res[940].exec("Zebra"), 2863);
-assertToStringEquals("X", res[940].exec("Xylophone  "), 2864);
-assertToStringEquals("4", res[940].exec("42"), 2865);
-assertToStringEquals("[", res[940].exec("[abcd] "), 2866);
-assertToStringEquals("]", res[940].exec("]abcd["), 2867);
-assertToStringEquals("\\", res[940].exec("\\backslash "), 2868);
-assertNull(res[940].exec("*** Failers", 2869));
-assertNull(res[940].exec("-46]789", 2870));
-assertNull(res[940].exec("well", 2871));
-assertToStringEquals("01/01/2000", res[941].exec("01/01/2000"), 2872);
-assertToStringEquals(",", res[944].exec("bcd"), 2873);
-assertToStringEquals(",", res[944].exec("abc"), 2874);
-assertToStringEquals(",", res[944].exec("aab     "), 2875);
-assertToStringEquals(",", res[945].exec("bcd"), 2876);
-assertToStringEquals("a,a", res[945].exec("abc"), 2877);
-assertToStringEquals("a,a", res[945].exec("aab  "), 2878);
-assertToStringEquals(",", res[946].exec("bcd"), 2879);
-assertToStringEquals("a,a", res[946].exec("abc"), 2880);
-assertToStringEquals("aa,a", res[946].exec("aab  "), 2881);
-assertToStringEquals(",", res[947].exec("bcd"), 2882);
-assertToStringEquals("a,a", res[947].exec("abc"), 2883);
-assertToStringEquals("aa,a", res[947].exec("aab"), 2884);
-assertToStringEquals("aaa,a", res[947].exec("aaa   "), 2885);
-assertToStringEquals(",", res[948].exec("bcd"), 2886);
-assertToStringEquals("a,a", res[948].exec("abc"), 2887);
-assertToStringEquals("aa,a", res[948].exec("aab"), 2888);
-assertToStringEquals("aaa,a", res[948].exec("aaa"), 2889);
-assertToStringEquals("aaaaaaaa,a", res[948].exec("aaaaaaaa    "), 2890);
-assertNull(res[949].exec("bcd", 2891));
-assertToStringEquals("a,a", res[949].exec("abc"), 2892);
-assertToStringEquals("a,a", res[949].exec("aab  "), 2893);
-assertNull(res[950].exec("bcd", 2894));
-assertToStringEquals("a,a", res[950].exec("abc"), 2895);
-assertToStringEquals("aa,a", res[950].exec("aab  "), 2896);
-assertNull(res[951].exec("bcd", 2897));
-assertToStringEquals("a,a", res[951].exec("abc"), 2898);
-assertToStringEquals("aa,a", res[951].exec("aab"), 2899);
-assertToStringEquals("aaa,a", res[951].exec("aaa   "), 2900);
-assertNull(res[952].exec("bcd", 2901));
-assertToStringEquals("a,a", res[952].exec("abc"), 2902);
-assertToStringEquals("aa,a", res[952].exec("aab"), 2903);
-assertToStringEquals("aaa,a", res[952].exec("aaa"), 2904);
-assertToStringEquals("aaaaaaaa,a", res[952].exec("aaaaaaaa    "), 2905);
-assertToStringEquals("bib.gif", res[953].exec("borfle\nbib.gif\nno"), 2906);
-assertToStringEquals("bib.gif", res[954].exec("borfle\nbib.gif\nno"), 2907);
-assertToStringEquals("bib.gif", res[955].exec("borfle\nbib.gif\nno"), 2908);
-assertToStringEquals("bib.gif", res[956].exec("borfle\nbib.gif\nno"), 2909);
-assertToStringEquals("bib.gif", res[957].exec("borfle\nbib.gif\nno"), 2910);
-assertToStringEquals("no", res[958].exec("borfle\nbib.gif\nno"), 2911);
-assertToStringEquals("borfle", res[959].exec("borfle\nbib.gif\nno"), 2912);
-assertToStringEquals("no", res[960].exec("borfle\nbib.gif\nno"), 2913);
-assertToStringEquals("borfle", res[961].exec("borfle\nbib.gif\nno"), 2914);
-assertToStringEquals("", res[962].exec("borfle\nbib.gif\nno\n"), 2915);
-assertToStringEquals("borfle", res[963].exec("borfle\nbib.gif\nno\n"), 2916);
-assertToStringEquals("", res[964].exec("borfle\nbib.gif\nno\n"), 2917);
-assertToStringEquals("borfle", res[965].exec("borfle\nbib.gif\nno\n"), 2918);
-assertToStringEquals("1234X,1234X", res[966].exec("abcde\n1234Xyz"), 2919);
-assertToStringEquals("B,B", res[966].exec("BarFoo "), 2920);
-assertNull(res[966].exec("*** Failers", 2921));
-assertNull(res[966].exec("abcde\nBar  ", 2922));
-assertToStringEquals("1234X,1234X", res[967].exec("abcde\n1234Xyz"), 2923);
-assertToStringEquals("B,B", res[967].exec("BarFoo "), 2924);
-assertToStringEquals("B,B", res[967].exec("abcde\nBar  "), 2925);
-assertToStringEquals("1234X,1234X", res[968].exec("abcde\n1234Xyz"), 2926);
-assertToStringEquals("B,B", res[968].exec("BarFoo "), 2927);
-assertNull(res[968].exec("*** Failers", 2928));
-assertNull(res[968].exec("abcde\nBar  ", 2929));
-assertToStringEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2930);
-assertToStringEquals("B,B", res[969].exec("BarFoo "), 2931);
-assertToStringEquals("B,B", res[969].exec("abcde\nBar  "), 2932);
-assertToStringEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2933);
-assertToStringEquals("B,B", res[969].exec("BarFoo "), 2934);
-assertNull(res[969].exec("*** Failers ", 2935));
-assertToStringEquals("B,B", res[969].exec("abcde\nBar  "), 2936);
-assertToStringEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2937);
-assertToStringEquals("B,B", res[969].exec("BarFoo "), 2938);
-assertNull(res[969].exec("*** Failers ", 2939));
-assertToStringEquals("B,B", res[969].exec("abcde\nBar  "), 2940);
-assertNull(res[970].exec("**** Failers", 2941));
-assertNull(res[970].exec("abc\nB", 2942));
-assertNull(res[970].exec(" ", 2943));
-assertNull(res[970].exec("abc\nB", 2944));
-assertNull(res[970].exec("abc\nB", 2945));
-assertNull(res[970].exec(" ", 2946));
-assertNull(res[970].exec("abc\nB", 2947));
-assertNull(res[970].exec("abc\nB", 2948));
-assertToStringEquals("B", res[970].exec("B\n"), 2949);
-assertToStringEquals("123456654321", res[971].exec("123456654321"), 2950);
-assertToStringEquals("123456654321", res[972].exec("123456654321 "), 2951);
-assertToStringEquals("123456654321", res[973].exec("123456654321"), 2952);
-assertToStringEquals("abcabcabcabc", res[974].exec("abcabcabcabc"), 2953);
-assertToStringEquals("abcabcabcabc", res[975].exec("abcabcabcabc"), 2954);
-assertToStringEquals("abcabcabcabc,c", res[976].exec("abcabcabcabc "), 2955);
-assertToStringEquals("n", res[977].exec("n"), 2956);
-assertNull(res[977].exec("*** Failers ", 2957));
-assertNull(res[977].exec("z ", 2958));
-assertToStringEquals("abcd", res[978].exec("abcd"), 2959);
-assertNull(res[978].exec("*** Failers", 2960));
-assertNull(res[978].exec("abce  ", 2961));
-assertToStringEquals("abe", res[979].exec("abe"), 2962);
-assertNull(res[979].exec("*** Failers", 2963));
-assertNull(res[979].exec("abcde ", 2964));
-assertToStringEquals("abd,", res[980].exec("abd"), 2965);
-assertNull(res[980].exec("*** Failers", 2966));
-assertNull(res[980].exec("abcd   ", 2967));
-assertToStringEquals("a,", res[981].exec("a"), 2968);
-assertToStringEquals("ab,b", res[981].exec("ab"), 2969);
-assertToStringEquals("abbbb,bbbb", res[981].exec("abbbb"), 2970);
-assertToStringEquals("a,", res[981].exec("*** Failers"), 2971);
-assertNull(res[981].exec("bbbbb    ", 2972));
-assertToStringEquals("abe", res[982].exec("abe"), 2973);
-assertNull(res[982].exec("*** Failers", 2974));
-assertNull(res[982].exec("ab1e   ", 2975));
-assertToStringEquals("\"quick\",quick", res[983].exec("the \"quick\" brown fox"), 2976);
-assertToStringEquals("\"the \\\"quick\\\" brown fox\", brown fox", res[983].exec("\"the \\\"quick\\\" brown fox\" "), 2977);
-assertToStringEquals("", res[984].exec("abc"), 2978);
-assertToStringEquals("", res[985].exec("abc "), 2979);
-assertToStringEquals("", res[986].exec("abc "), 2980);
+assertEquals(null, res[925].exec("ab ", 2835));
+assertEquals("foo table,foo,table", res[926].exec("Food is on the foo table"), 2836);
+assertEquals("food is under the bar in the bar,d is under the bar in the ", res[927].exec("The food is under the bar in the barn."), 2837);
+assertEquals("food is under the bar,d is under the ", res[928].exec("The food is under the bar in the barn."), 2838);
+assertEquals("I have 2 numbers: 53147,I have 2 numbers: 53147,", res[929].exec("I have 2 numbers: 53147"), 2839);
+assertEquals("I have 2 numbers: 53147,I have 2 numbers: 5314,7", res[930].exec("I have 2 numbers: 53147"), 2840);
+assertEquals(",,", res[931].exec("I have 2 numbers: 53147"), 2841);
+assertEquals("I have 2,I have ,2", res[932].exec("I have 2 numbers: 53147"), 2842);
+assertEquals("I have 2 numbers: 53147,I have 2 numbers: 5314,7", res[933].exec("I have 2 numbers: 53147"), 2843);
+assertEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[934].exec("I have 2 numbers: 53147"), 2844);
+assertEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[935].exec("I have 2 numbers: 53147"), 2845);
+assertEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[936].exec("I have 2 numbers: 53147"), 2846);
+assertEquals("AB", res[937].exec("ABC123"), 2847);
+assertEquals(" ", res[937].exec(" "), 2848);
+assertEquals("ABC,ABC", res[938].exec("ABC445"), 2849);
+assertEquals(null, res[938].exec("*** Failers", 2850));
+assertEquals(null, res[938].exec("ABC123", 2851));
+assertEquals("W46]", res[939].exec("W46]789 "), 2852);
+assertEquals("-46]", res[939].exec("-46]789"), 2853);
+assertEquals(null, res[939].exec("*** Failers", 2854));
+assertEquals(null, res[939].exec("Wall", 2855));
+assertEquals(null, res[939].exec("Zebra", 2856));
+assertEquals(null, res[939].exec("42", 2857));
+assertEquals(null, res[939].exec("[abcd] ", 2858));
+assertEquals(null, res[939].exec("]abcd[", 2859));
+assertEquals(null, res[939].exec("   ", 2860));
+assertEquals("W", res[940].exec("W46]789 "), 2861);
+assertEquals("W", res[940].exec("Wall"), 2862);
+assertEquals("Z", res[940].exec("Zebra"), 2863);
+assertEquals("X", res[940].exec("Xylophone  "), 2864);
+assertEquals("4", res[940].exec("42"), 2865);
+assertEquals("[", res[940].exec("[abcd] "), 2866);
+assertEquals("]", res[940].exec("]abcd["), 2867);
+assertEquals("\\", res[940].exec("\\backslash "), 2868);
+assertEquals(null, res[940].exec("*** Failers", 2869));
+assertEquals(null, res[940].exec("-46]789", 2870));
+assertEquals(null, res[940].exec("well", 2871));
+assertEquals("01/01/2000", res[941].exec("01/01/2000"), 2872);
+assertEquals(",", res[944].exec("bcd"), 2873);
+assertEquals(",", res[944].exec("abc"), 2874);
+assertEquals(",", res[944].exec("aab     "), 2875);
+assertEquals(",", res[945].exec("bcd"), 2876);
+assertEquals("a,a", res[945].exec("abc"), 2877);
+assertEquals("a,a", res[945].exec("aab  "), 2878);
+assertEquals(",", res[946].exec("bcd"), 2879);
+assertEquals("a,a", res[946].exec("abc"), 2880);
+assertEquals("aa,a", res[946].exec("aab  "), 2881);
+assertEquals(",", res[947].exec("bcd"), 2882);
+assertEquals("a,a", res[947].exec("abc"), 2883);
+assertEquals("aa,a", res[947].exec("aab"), 2884);
+assertEquals("aaa,a", res[947].exec("aaa   "), 2885);
+assertEquals(",", res[948].exec("bcd"), 2886);
+assertEquals("a,a", res[948].exec("abc"), 2887);
+assertEquals("aa,a", res[948].exec("aab"), 2888);
+assertEquals("aaa,a", res[948].exec("aaa"), 2889);
+assertEquals("aaaaaaaa,a", res[948].exec("aaaaaaaa    "), 2890);
+assertEquals(null, res[949].exec("bcd", 2891));
+assertEquals("a,a", res[949].exec("abc"), 2892);
+assertEquals("a,a", res[949].exec("aab  "), 2893);
+assertEquals(null, res[950].exec("bcd", 2894));
+assertEquals("a,a", res[950].exec("abc"), 2895);
+assertEquals("aa,a", res[950].exec("aab  "), 2896);
+assertEquals(null, res[951].exec("bcd", 2897));
+assertEquals("a,a", res[951].exec("abc"), 2898);
+assertEquals("aa,a", res[951].exec("aab"), 2899);
+assertEquals("aaa,a", res[951].exec("aaa   "), 2900);
+assertEquals(null, res[952].exec("bcd", 2901));
+assertEquals("a,a", res[952].exec("abc"), 2902);
+assertEquals("aa,a", res[952].exec("aab"), 2903);
+assertEquals("aaa,a", res[952].exec("aaa"), 2904);
+assertEquals("aaaaaaaa,a", res[952].exec("aaaaaaaa    "), 2905);
+assertEquals("bib.gif", res[953].exec("borfle\nbib.gif\nno"), 2906);
+assertEquals("bib.gif", res[954].exec("borfle\nbib.gif\nno"), 2907);
+assertEquals("bib.gif", res[955].exec("borfle\nbib.gif\nno"), 2908);
+assertEquals("bib.gif", res[956].exec("borfle\nbib.gif\nno"), 2909);
+assertEquals("bib.gif", res[957].exec("borfle\nbib.gif\nno"), 2910);
+assertEquals("no", res[958].exec("borfle\nbib.gif\nno"), 2911);
+assertEquals("borfle", res[959].exec("borfle\nbib.gif\nno"), 2912);
+assertEquals("no", res[960].exec("borfle\nbib.gif\nno"), 2913);
+assertEquals("borfle", res[961].exec("borfle\nbib.gif\nno"), 2914);
+assertEquals("", res[962].exec("borfle\nbib.gif\nno\n"), 2915);
+assertEquals("borfle", res[963].exec("borfle\nbib.gif\nno\n"), 2916);
+assertEquals("", res[964].exec("borfle\nbib.gif\nno\n"), 2917);
+assertEquals("borfle", res[965].exec("borfle\nbib.gif\nno\n"), 2918);
+assertEquals("1234X,1234X", res[966].exec("abcde\n1234Xyz"), 2919);
+assertEquals("B,B", res[966].exec("BarFoo "), 2920);
+assertEquals(null, res[966].exec("*** Failers", 2921));
+assertEquals(null, res[966].exec("abcde\nBar  ", 2922));
+assertEquals("1234X,1234X", res[967].exec("abcde\n1234Xyz"), 2923);
+assertEquals("B,B", res[967].exec("BarFoo "), 2924);
+assertEquals("B,B", res[967].exec("abcde\nBar  "), 2925);
+assertEquals("1234X,1234X", res[968].exec("abcde\n1234Xyz"), 2926);
+assertEquals("B,B", res[968].exec("BarFoo "), 2927);
+assertEquals(null, res[968].exec("*** Failers", 2928));
+assertEquals(null, res[968].exec("abcde\nBar  ", 2929));
+assertEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2930);
+assertEquals("B,B", res[969].exec("BarFoo "), 2931);
+assertEquals("B,B", res[969].exec("abcde\nBar  "), 2932);
+assertEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2933);
+assertEquals("B,B", res[969].exec("BarFoo "), 2934);
+assertEquals(null, res[969].exec("*** Failers ", 2935));
+assertEquals("B,B", res[969].exec("abcde\nBar  "), 2936);
+assertEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2937);
+assertEquals("B,B", res[969].exec("BarFoo "), 2938);
+assertEquals(null, res[969].exec("*** Failers ", 2939));
+assertEquals("B,B", res[969].exec("abcde\nBar  "), 2940);
+assertEquals(null, res[970].exec("**** Failers", 2941));
+assertEquals(null, res[970].exec("abc\nB", 2942));
+assertEquals(null, res[970].exec(" ", 2943));
+assertEquals(null, res[970].exec("abc\nB", 2944));
+assertEquals(null, res[970].exec("abc\nB", 2945));
+assertEquals(null, res[970].exec(" ", 2946));
+assertEquals(null, res[970].exec("abc\nB", 2947));
+assertEquals(null, res[970].exec("abc\nB", 2948));
+assertEquals("B", res[970].exec("B\n"), 2949);
+assertEquals("123456654321", res[971].exec("123456654321"), 2950);
+assertEquals("123456654321", res[972].exec("123456654321 "), 2951);
+assertEquals("123456654321", res[973].exec("123456654321"), 2952);
+assertEquals("abcabcabcabc", res[974].exec("abcabcabcabc"), 2953);
+assertEquals("abcabcabcabc", res[975].exec("abcabcabcabc"), 2954);
+assertEquals("abcabcabcabc,c", res[976].exec("abcabcabcabc "), 2955);
+assertEquals("n", res[977].exec("n"), 2956);
+assertEquals(null, res[977].exec("*** Failers ", 2957));
+assertEquals(null, res[977].exec("z ", 2958));
+assertEquals("abcd", res[978].exec("abcd"), 2959);
+assertEquals(null, res[978].exec("*** Failers", 2960));
+assertEquals(null, res[978].exec("abce  ", 2961));
+assertEquals("abe", res[979].exec("abe"), 2962);
+assertEquals(null, res[979].exec("*** Failers", 2963));
+assertEquals(null, res[979].exec("abcde ", 2964));
+assertEquals("abd,", res[980].exec("abd"), 2965);
+assertEquals(null, res[980].exec("*** Failers", 2966));
+assertEquals(null, res[980].exec("abcd   ", 2967));
+assertEquals("a,", res[981].exec("a"), 2968);
+assertEquals("ab,b", res[981].exec("ab"), 2969);
+assertEquals("abbbb,bbbb", res[981].exec("abbbb"), 2970);
+assertEquals("a,", res[981].exec("*** Failers"), 2971);
+assertEquals(null, res[981].exec("bbbbb    ", 2972));
+assertEquals("abe", res[982].exec("abe"), 2973);
+assertEquals(null, res[982].exec("*** Failers", 2974));
+assertEquals(null, res[982].exec("ab1e   ", 2975));
+assertEquals("\"quick\",quick", res[983].exec("the \"quick\" brown fox"), 2976);
+assertEquals("\"the \\\"quick\\\" brown fox\", brown fox", res[983].exec("\"the \\\"quick\\\" brown fox\" "), 2977);
+assertEquals("", res[984].exec("abc"), 2978);
+assertEquals("", res[985].exec("abc "), 2979);
+assertEquals("", res[986].exec("abc "), 2980);
 assertThrows("var re = //;", 2981);
-assertToStringEquals("", res[986].exec("abc"), 2982);
-assertToStringEquals("acb", res[988].exec("acb"), 2983);
-assertToStringEquals("a\nb", res[988].exec("a\nb"), 2984);
-assertToStringEquals("acb", res[989].exec("acb"), 2985);
-assertNull(res[989].exec("*** Failers ", 2986));
-assertNull(res[989].exec("a\nb   ", 2987));
-assertToStringEquals("acb", res[990].exec("acb"), 2988);
-assertToStringEquals("a\nb", res[990].exec("a\nb  "), 2989);
-assertToStringEquals("acb", res[991].exec("acb"), 2990);
-assertNull(res[991].exec("a\nb  ", 2991));
-assertToStringEquals("bac,a", res[992].exec("bac"), 2992);
-assertToStringEquals("bbac,a", res[992].exec("bbac"), 2993);
-assertToStringEquals("bbbac,a", res[992].exec("bbbac"), 2994);
-assertToStringEquals("bbbbac,a", res[992].exec("bbbbac"), 2995);
-assertToStringEquals("bbbbbac,a", res[992].exec("bbbbbac "), 2996);
-assertToStringEquals("bac,a", res[993].exec("bac"), 2997);
-assertToStringEquals("bbac,a", res[993].exec("bbac"), 2998);
-assertToStringEquals("bbbac,a", res[993].exec("bbbac"), 2999);
-assertToStringEquals("bbbbac,a", res[993].exec("bbbbac"), 3000);
-assertToStringEquals("bbbbbac,a", res[993].exec("bbbbbac "), 3001);
-assertToStringEquals("x", res[994].exec("x\nb\n"), 3002);
-assertToStringEquals("x", res[994].exec("a\x08x\n  "), 3003);
-assertNull(res[995].exec("\x00{ab} ", 3004));
-assertToStringEquals("CD,", res[996].exec("CD "), 3005);
-assertToStringEquals("CD,", res[997].exec("CD "), 3006);
-assertNull(res[997].exec("foo", 3007));
-assertNull(res[997].exec("catfood", 3008));
-assertNull(res[997].exec("arfootle", 3009));
-assertNull(res[997].exec("rfoosh", 3010));
-assertNull(res[997].exec("*** Failers", 3011));
-assertNull(res[997].exec("barfoo", 3012));
-assertNull(res[997].exec("towbarfoo", 3013));
-assertNull(res[997].exec("catfood", 3014));
-assertNull(res[997].exec("*** Failers", 3015));
-assertNull(res[997].exec("foo", 3016));
-assertNull(res[997].exec("barfoo", 3017));
-assertNull(res[997].exec("towbarfoo", 3018));
-assertNull(res[997].exec("fooabar", 3019));
-assertNull(res[997].exec("*** Failers", 3020));
-assertNull(res[997].exec("bar", 3021));
-assertNull(res[997].exec("foobbar", 3022));
-assertNull(res[997].exec("  ", 3023));
-assertNull(res[998].exec("abc", 3024));
-assertNull(res[998].exec("*** Failers", 3025));
-assertNull(res[998].exec("abc\n   ", 3026));
-assertNull(res[998].exec("qqq\nabc", 3027));
-assertNull(res[998].exec("abc\nzzz", 3028));
-assertNull(res[998].exec("qqq\nabc\nzzz", 3029));
-assertNull(res[998].exec("/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/", 3030));
-assertNull(res[998].exec("/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo", 3031));
-assertNull(res[998].exec("1.230003938", 3032));
-assertNull(res[998].exec("1.875000282", 3033));
-assertNull(res[998].exec("*** Failers ", 3034));
-assertNull(res[998].exec("1.235 ", 3035));
-assertNull(res[998].exec("now is the time for all good men to come to the aid of the party", 3036));
-assertNull(res[998].exec("*** Failers", 3037));
-assertNull(res[998].exec("this is not a line with only words and spaces!", 3038));
-assertToStringEquals("12345a,12345,a", res[999].exec("12345a"), 3039);
-assertToStringEquals("12345,1234,5", res[999].exec("12345+ "), 3040);
-assertToStringEquals("12345a,12345,a", res[999].exec("12345a"), 3041);
-assertNull(res[999].exec("*** Failers", 3042));
-assertToStringEquals("12345,1234,5", res[999].exec("12345+ "), 3043);
-assertNull(res[999].exec("aaab", 3044));
-assertNull(res[999].exec("aaab", 3045));
-assertNull(res[999].exec("aaab", 3046));
-assertNull(res[999].exec("aaabbbccc", 3047));
-assertNull(res[999].exec("aaabbbbccccd", 3048));
-assertToStringEquals("aaabbbbcccc,ccc", res[1000].exec("aaabbbbccccd"), 3049);
-assertToStringEquals("abc,b", res[1000].exec("((abc(ade)ufh()()x"), 3050);
-assertNull(res[1000].exec("", 3051));
-assertToStringEquals("abc,b", res[1000].exec("(abc)"), 3052);
-assertToStringEquals("abc,b", res[1000].exec("(abc(def)xyz)"), 3053);
-assertNull(res[1000].exec("*** Failers", 3054));
-assertNull(res[1000].exec("ab", 3055));
-assertNull(res[1000].exec("Ab", 3056));
-assertNull(res[1000].exec("*** Failers ", 3057));
-assertNull(res[1000].exec("aB", 3058));
-assertNull(res[1000].exec("AB", 3059));
-assertNull(res[1000].exec("    ", 3060));
-assertToStringEquals("bc,b", res[1000].exec("a bcd e"), 3061);
-assertNull(res[1000].exec("*** Failers", 3062));
-assertToStringEquals("c,", res[1000].exec("a b cd e"), 3063);
-assertToStringEquals("abc,b", res[1000].exec("abcd e   "), 3064);
-assertToStringEquals("bc,b", res[1000].exec("a bcde "), 3065);
-assertToStringEquals("bc,b", res[1000].exec("a bcde f"), 3066);
-assertNull(res[1000].exec("*** Failers", 3067));
-assertToStringEquals("abc,b", res[1000].exec("abcdef  "), 3068);
-assertToStringEquals("abc,b", res[1000].exec("abc"), 3069);
-assertToStringEquals("c,", res[1000].exec("aBc"), 3070);
-assertNull(res[1000].exec("*** Failers", 3071));
-assertNull(res[1000].exec("abC", 3072));
-assertNull(res[1000].exec("aBC  ", 3073));
-assertToStringEquals("bc,b", res[1000].exec("Abc"), 3074);
-assertToStringEquals("c,", res[1000].exec("ABc"), 3075);
-assertNull(res[1000].exec("ABC", 3076));
-assertNull(res[1000].exec("AbC", 3077));
-assertNull(res[1000].exec("", 3078));
-assertToStringEquals("abc,b", res[1000].exec("abc"), 3079);
-assertToStringEquals("c,", res[1000].exec("aBc"), 3080);
-assertNull(res[1000].exec("*** Failers ", 3081));
-assertNull(res[1000].exec("ABC", 3082));
-assertNull(res[1000].exec("abC", 3083));
-assertNull(res[1000].exec("aBC", 3084));
-assertNull(res[1000].exec("", 3085));
-assertToStringEquals("c,", res[1000].exec("aBc"), 3086);
-assertToStringEquals("c,", res[1000].exec("aBBc"), 3087);
-assertNull(res[1000].exec("*** Failers ", 3088));
-assertNull(res[1000].exec("aBC", 3089));
-assertNull(res[1000].exec("aBBC", 3090));
-assertNull(res[1000].exec("", 3091));
-assertToStringEquals("abc,b", res[1000].exec("abcd"), 3092);
-assertNull(res[1000].exec("abCd", 3093));
-assertNull(res[1000].exec("*** Failers", 3094));
-assertNull(res[1000].exec("aBCd", 3095));
-assertToStringEquals("abc,b", res[1000].exec("abcD     "), 3096);
-assertNull(res[1000].exec("", 3097));
-assertNull(res[1000].exec("more than million", 3098));
-assertNull(res[1000].exec("more than MILLION", 3099));
-assertNull(res[1000].exec("more \n than Million ", 3100));
-assertNull(res[1000].exec("*** Failers", 3101));
-assertNull(res[1000].exec("MORE THAN MILLION    ", 3102));
-assertNull(res[1000].exec("more \n than \n million ", 3103));
-assertNull(res[1000].exec("more than million", 3104));
-assertNull(res[1000].exec("more than MILLION", 3105));
-assertNull(res[1000].exec("more \n than Million ", 3106));
-assertNull(res[1000].exec("*** Failers", 3107));
-assertNull(res[1000].exec("MORE THAN MILLION    ", 3108));
-assertNull(res[1000].exec("more \n than \n million ", 3109));
-assertNull(res[1000].exec("", 3110));
-assertToStringEquals("abc,b", res[1000].exec("abc"), 3111);
-assertToStringEquals("bc,b", res[1000].exec("aBbc"), 3112);
-assertToStringEquals("c,", res[1000].exec("aBBc "), 3113);
-assertNull(res[1000].exec("*** Failers", 3114));
-assertToStringEquals("bc,b", res[1000].exec("Abc"), 3115);
-assertNull(res[1000].exec("abAb    ", 3116));
-assertNull(res[1000].exec("abbC ", 3117));
-assertNull(res[1000].exec("", 3118));
-assertToStringEquals("abc,b", res[1000].exec("abc"), 3119);
-assertToStringEquals("c,", res[1000].exec("aBc"), 3120);
-assertNull(res[1000].exec("*** Failers", 3121));
-assertNull(res[1000].exec("Ab ", 3122));
-assertNull(res[1000].exec("abC", 3123));
-assertNull(res[1000].exec("aBC     ", 3124));
-assertNull(res[1000].exec("", 3125));
-assertToStringEquals("c,", res[1000].exec("abxxc"), 3126);
-assertToStringEquals("c,", res[1000].exec("aBxxc"), 3127);
-assertNull(res[1000].exec("*** Failers", 3128));
-assertToStringEquals("c,", res[1000].exec("Abxxc"), 3129);
-assertToStringEquals("c,", res[1000].exec("ABxxc"), 3130);
-assertNull(res[1000].exec("abxxC      ", 3131));
-assertToStringEquals("abc,b", res[1000].exec("abc:"), 3132);
-assertNull(res[1000].exec("12", 3133));
-assertNull(res[1000].exec("*** Failers", 3134));
-assertNull(res[1000].exec("123", 3135));
-assertNull(res[1000].exec("xyz    ", 3136));
-assertToStringEquals("abc,b", res[1000].exec("abc:"), 3137);
-assertNull(res[1000].exec("12", 3138));
-assertNull(res[1000].exec("*** Failers", 3139));
-assertNull(res[1000].exec("123", 3140));
-assertNull(res[1000].exec("xyz    ", 3141));
-assertNull(res[1000].exec("", 3142));
-assertNull(res[1000].exec("foobar", 3143));
-assertToStringEquals("c,", res[1000].exec("cat"), 3144);
-assertToStringEquals("c,", res[1000].exec("fcat"), 3145);
-assertToStringEquals("c,", res[1000].exec("focat   "), 3146);
-assertNull(res[1000].exec("*** Failers", 3147));
-assertToStringEquals("c,", res[1000].exec("foocat  "), 3148);
-assertNull(res[1000].exec("foobar", 3149));
-assertToStringEquals("c,", res[1000].exec("cat"), 3150);
-assertToStringEquals("c,", res[1000].exec("fcat"), 3151);
-assertToStringEquals("c,", res[1000].exec("focat   "), 3152);
-assertNull(res[1000].exec("*** Failers", 3153));
-assertToStringEquals("c,", res[1000].exec("foocat  "), 3154);
-assertNull(res[1000].exec("a", 3155));
-assertNull(res[1000].exec("aa", 3156));
-assertNull(res[1000].exec("aaaa", 3157));
-assertNull(res[1000].exec("", 3158));
-assertToStringEquals("abc,abc", res[1001].exec("abc"), 3159);
-assertToStringEquals("abcabc,abc", res[1001].exec("abcabc"), 3160);
-assertToStringEquals("abcabcabc,abc", res[1001].exec("abcabcabc"), 3161);
-assertToStringEquals(",", res[1001].exec("xyz      "), 3162);
-assertToStringEquals("a,a", res[1002].exec("a"), 3163);
-assertToStringEquals("aaaaa,aaaaa", res[1002].exec("aaaaa "), 3164);
-assertToStringEquals("a,a", res[1003].exec("a"), 3165);
-assertToStringEquals("b,b", res[1003].exec("b"), 3166);
-assertToStringEquals("ababab,ababab", res[1003].exec("ababab"), 3167);
-assertToStringEquals("aaaab,aaaab", res[1003].exec("aaaabcde"), 3168);
-assertToStringEquals("bbbb,bbbb", res[1003].exec("bbbb    "), 3169);
-assertToStringEquals("b,b", res[1004].exec("b"), 3170);
-assertToStringEquals("bbbb,bbbb", res[1004].exec("bbbb"), 3171);
-assertToStringEquals(",", res[1004].exec("aaa   "), 3172);
-assertToStringEquals("cccc,cccc", res[1005].exec("cccc"), 3173);
-assertToStringEquals(",", res[1005].exec("abab  "), 3174);
-assertToStringEquals("a,a", res[1006].exec("a"), 3175);
-assertToStringEquals("aaaa,a", res[1006].exec("aaaa "), 3176);
-assertToStringEquals("a,a", res[1007].exec("a"), 3177);
-assertToStringEquals("b,b", res[1007].exec("b"), 3178);
-assertToStringEquals("abab,b", res[1007].exec("abab"), 3179);
-assertToStringEquals("baba,a", res[1007].exec("baba   "), 3180);
-assertToStringEquals("b,b", res[1008].exec("b"), 3181);
-assertToStringEquals("bbbb,b", res[1008].exec("bbbb"), 3182);
-assertToStringEquals(",", res[1008].exec("aaa   "), 3183);
-assertToStringEquals("c,c", res[1009].exec("c"), 3184);
-assertToStringEquals("cccc,c", res[1009].exec("cccc"), 3185);
-assertToStringEquals(",", res[1009].exec("baba   "), 3186);
-assertToStringEquals(",", res[1009].exec("a"), 3187);
-assertToStringEquals(",", res[1009].exec("aaabcde "), 3188);
-assertToStringEquals(",", res[1009].exec("aaaaa"), 3189);
-assertToStringEquals(",", res[1009].exec("aabbaa "), 3190);
-assertToStringEquals(",", res[1009].exec("aaaaa"), 3191);
-assertToStringEquals(",", res[1009].exec("aabbaa "), 3192);
-assertToStringEquals("12-sep-98,8", res[1009].exec("12-sep-98"), 3193);
-assertToStringEquals("12-09-98,8", res[1009].exec("12-09-98"), 3194);
-assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3195);
-assertToStringEquals("sep-12-98,8", res[1009].exec("sep-12-98"), 3196);
-assertToStringEquals("    , ", res[1009].exec("    "), 3197);
-assertToStringEquals("s,s", res[1009].exec("saturday"), 3198);
-assertToStringEquals("sund,d", res[1009].exec("sunday"), 3199);
-assertToStringEquals("S,S", res[1009].exec("Saturday"), 3200);
-assertToStringEquals("Sund,d", res[1009].exec("Sunday"), 3201);
-assertToStringEquals("SATURDAY,Y", res[1009].exec("SATURDAY"), 3202);
-assertToStringEquals("SUNDAY,Y", res[1009].exec("SUNDAY"), 3203);
-assertToStringEquals("SunD,D", res[1009].exec("SunDay"), 3204);
-assertToStringEquals(",", res[1009].exec("abcx"), 3205);
-assertToStringEquals(",", res[1009].exec("aBCx"), 3206);
-assertToStringEquals(",", res[1009].exec("bbx"), 3207);
-assertToStringEquals("BBx,x", res[1009].exec("BBx"), 3208);
-assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3209);
-assertToStringEquals(",", res[1009].exec("abcX"), 3210);
-assertToStringEquals(",", res[1009].exec("aBCX"), 3211);
-assertToStringEquals(",", res[1009].exec("bbX"), 3212);
-assertToStringEquals("BBX               , ", res[1009].exec("BBX               "), 3213);
-assertToStringEquals(",", res[1009].exec("ac"), 3214);
-assertToStringEquals(",", res[1009].exec("aC"), 3215);
-assertToStringEquals(",", res[1009].exec("bD"), 3216);
-assertToStringEquals("eleph,h", res[1009].exec("elephant"), 3217);
-assertToStringEquals("Europe , ", res[1009].exec("Europe "), 3218);
-assertToStringEquals("frog,g", res[1009].exec("frog"), 3219);
-assertToStringEquals("Fr,r", res[1009].exec("France"), 3220);
-assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3221);
-assertToStringEquals("Afric,c", res[1009].exec("Africa     "), 3222);
-assertToStringEquals(",", res[1009].exec("ab"), 3223);
-assertToStringEquals(",", res[1009].exec("aBd"), 3224);
-assertToStringEquals("xy,y", res[1009].exec("xy"), 3225);
-assertToStringEquals("xY,Y", res[1009].exec("xY"), 3226);
-assertToStringEquals("ze,e", res[1009].exec("zebra"), 3227);
-assertToStringEquals("Z,Z", res[1009].exec("Zambesi"), 3228);
-assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3229);
-assertToStringEquals(",", res[1009].exec("aCD  "), 3230);
-assertToStringEquals("XY  , ", res[1009].exec("XY  "), 3231);
-assertToStringEquals("foo\n,\n", res[1009].exec("foo\nbar"), 3232);
-assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3233);
-assertToStringEquals(",", res[1009].exec("bar"), 3234);
-assertToStringEquals(",", res[1009].exec("baz\nbar   "), 3235);
-assertToStringEquals(",", res[1009].exec("barbaz"), 3236);
-assertToStringEquals(",", res[1009].exec("barbarbaz "), 3237);
-assertToStringEquals("koo,o", res[1009].exec("koobarbaz "), 3238);
-assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3239);
-assertToStringEquals(",", res[1009].exec("baz"), 3240);
-assertToStringEquals("foo,o", res[1009].exec("foobarbaz "), 3241);
-assertToStringEquals("abc", res[1012].exec("abc"), 3242);
-assertToStringEquals("abc", res[1012].exec("xabcy"), 3243);
-assertToStringEquals("abc", res[1012].exec("ababc"), 3244);
-assertNull(res[1012].exec("*** Failers", 3245));
-assertNull(res[1012].exec("xbc", 3246));
-assertNull(res[1012].exec("axc", 3247));
-assertNull(res[1012].exec("abx", 3248));
-assertToStringEquals("abc", res[1013].exec("abc"), 3249);
-assertToStringEquals("abc", res[1014].exec("abc"), 3250);
-assertToStringEquals("abbc", res[1014].exec("abbc"), 3251);
-assertToStringEquals("abbbbc", res[1014].exec("abbbbc"), 3252);
-assertToStringEquals("a", res[1015].exec("abbbbc"), 3253);
-assertToStringEquals("abbb", res[1016].exec("abbbbc"), 3254);
-assertToStringEquals("abbbbc", res[1017].exec("abbbbc"), 3255);
-assertToStringEquals("abbc", res[1018].exec("abbc"), 3256);
-assertNull(res[1018].exec("*** Failers", 3257));
-assertNull(res[1018].exec("abc", 3258));
-assertNull(res[1018].exec("abq", 3259));
-assertToStringEquals("abbbbc", res[1020].exec("abbbbc"), 3260);
-assertToStringEquals("abbbbc", res[1021].exec("abbbbc"), 3261);
-assertToStringEquals("abbbbc", res[1022].exec("abbbbc"), 3262);
-assertToStringEquals("abbbbc", res[1023].exec("abbbbc"), 3263);
-assertNull(res[1024].exec("*** Failers", 3264));
-assertNull(res[1024].exec("abq", 3265));
-assertNull(res[1024].exec("abbbbc", 3266));
-assertToStringEquals("abbc", res[1025].exec("abbc"), 3267);
-assertToStringEquals("abc", res[1025].exec("abc"), 3268);
-assertToStringEquals("abc", res[1026].exec("abc"), 3269);
-assertToStringEquals("abc", res[1028].exec("abc"), 3270);
-assertToStringEquals("abc", res[1029].exec("abc"), 3271);
-assertToStringEquals("abc", res[1030].exec("abc"), 3272);
-assertNull(res[1030].exec("*** Failers", 3273));
-assertNull(res[1030].exec("abbbbc", 3274));
-assertNull(res[1030].exec("abcc", 3275));
-assertToStringEquals("abc", res[1031].exec("abcc"), 3276);
-assertToStringEquals("abc", res[1033].exec("aabc"), 3277);
-assertNull(res[1033].exec("*** Failers", 3278));
-assertToStringEquals("abc", res[1033].exec("aabc"), 3279);
-assertNull(res[1033].exec("aabcd", 3280));
-assertToStringEquals("", res[1034].exec("abc"), 3281);
-assertToStringEquals("", res[1035].exec("abc"), 3282);
-assertToStringEquals("abc", res[1036].exec("abc"), 3283);
-assertToStringEquals("axc", res[1036].exec("axc"), 3284);
-assertToStringEquals("axyzc", res[1037].exec("axyzc"), 3285);
-assertToStringEquals("abd", res[1038].exec("abd"), 3286);
-assertNull(res[1038].exec("*** Failers", 3287));
-assertNull(res[1038].exec("axyzd", 3288));
-assertNull(res[1038].exec("abc", 3289));
-assertToStringEquals("ace", res[1039].exec("ace"), 3290);
-assertToStringEquals("ac", res[1040].exec("aac"), 3291);
-assertToStringEquals("a-", res[1041].exec("a-"), 3292);
-assertToStringEquals("a-", res[1042].exec("a-"), 3293);
-assertToStringEquals("a]", res[1043].exec("a]"), 3294);
-assertNull(res[1044].exec("a]b", 3295));
-assertToStringEquals("aed", res[1045].exec("aed"), 3296);
-assertNull(res[1045].exec("*** Failers", 3297));
-assertNull(res[1045].exec("abd", 3298));
-assertNull(res[1045].exec("abd", 3299));
-assertToStringEquals("adc", res[1046].exec("adc"), 3300);
-assertNull(res[1047].exec("adc", 3301));
-assertNull(res[1047].exec("*** Failers", 3302));
-assertNull(res[1047].exec("a-c", 3303));
-assertNull(res[1047].exec("a]c", 3304));
-assertToStringEquals("a", res[1048].exec("a-"), 3305);
-assertToStringEquals("a", res[1048].exec("-a"), 3306);
-assertToStringEquals("a", res[1048].exec("-a-"), 3307);
-assertNull(res[1049].exec("*** Failers", 3308));
-assertNull(res[1049].exec("xy", 3309));
-assertNull(res[1049].exec("yz", 3310));
-assertNull(res[1049].exec("xyz", 3311));
-assertToStringEquals("a", res[1050].exec("*** Failers"), 3312);
-assertNull(res[1050].exec("a-", 3313));
-assertNull(res[1050].exec("-a", 3314));
-assertNull(res[1050].exec("-a-", 3315));
-assertToStringEquals("y", res[1051].exec("xy"), 3316);
-assertToStringEquals("y", res[1052].exec("yz"), 3317);
-assertToStringEquals("y", res[1053].exec("xyz"), 3318);
-assertToStringEquals("a", res[1054].exec("a"), 3319);
-assertToStringEquals("-", res[1055].exec("-"), 3320);
-assertToStringEquals("*", res[1055].exec("*** Failers"), 3321);
-assertToStringEquals("-", res[1055].exec("-"), 3322);
-assertNull(res[1055].exec("a", 3323));
-assertToStringEquals("a b", res[1056].exec("a b"), 3324);
-assertToStringEquals("a-b", res[1057].exec("a-b"), 3325);
-assertNull(res[1057].exec("*** Failers", 3326));
-assertToStringEquals("a-b", res[1057].exec("a-b"), 3327);
-assertNull(res[1057].exec("a b", 3328));
-assertToStringEquals("1", res[1058].exec("1"), 3329);
-assertToStringEquals("-", res[1059].exec("-"), 3330);
-assertToStringEquals("*", res[1059].exec("*** Failers"), 3331);
-assertToStringEquals("-", res[1059].exec("-"), 3332);
-assertNull(res[1059].exec("1", 3333));
-assertToStringEquals("a", res[1060].exec("a"), 3334);
-assertToStringEquals("-", res[1061].exec("-"), 3335);
-assertToStringEquals("*", res[1061].exec("*** Failers"), 3336);
-assertToStringEquals("-", res[1061].exec("-"), 3337);
-assertNull(res[1061].exec("a", 3338));
-assertToStringEquals("a b", res[1062].exec("a b"), 3339);
-assertToStringEquals("a-b", res[1063].exec("a-b"), 3340);
-assertNull(res[1063].exec("*** Failers", 3341));
-assertToStringEquals("a-b", res[1063].exec("a-b"), 3342);
-assertNull(res[1063].exec("a b", 3343));
-assertToStringEquals("1", res[1064].exec("1"), 3344);
-assertToStringEquals("-", res[1065].exec("-"), 3345);
-assertToStringEquals("*", res[1065].exec("*** Failers"), 3346);
-assertToStringEquals("-", res[1065].exec("-"), 3347);
-assertNull(res[1065].exec("1", 3348));
-assertToStringEquals("ab", res[1066].exec("abc"), 3349);
-assertToStringEquals("ab", res[1066].exec("abcd"), 3350);
-assertToStringEquals("ef,", res[1067].exec("def"), 3351);
-assertToStringEquals("a(b", res[1069].exec("a(b"), 3352);
-assertNull(res[1069].exec("ab", 3353));
-assertNull(res[1069].exec("a((b", 3354));
-assertNull(res[1070].exec("a\x08", 3355));
-assertToStringEquals("a,a,a", res[1071].exec("abc"), 3356);
-assertToStringEquals("abc,a,c", res[1072].exec("abc"), 3357);
-assertToStringEquals("abc", res[1073].exec("aabbabc"), 3358);
-assertToStringEquals("abc", res[1074].exec("aabbabc"), 3359);
-assertToStringEquals("abc", res[1075].exec("abcabc"), 3360);
-assertToStringEquals("ab,b", res[1076].exec("ab"), 3361);
-assertToStringEquals("ab,b", res[1077].exec("ab"), 3362);
-assertToStringEquals("ab,b", res[1078].exec("ab"), 3363);
-assertToStringEquals("ab,b", res[1079].exec("ab"), 3364);
-assertToStringEquals("a,a", res[1080].exec("ab"), 3365);
-assertToStringEquals("a,a", res[1081].exec("ab"), 3366);
-assertToStringEquals("cde", res[1082].exec("cde"), 3367);
-assertNull(res[1083].exec("*** Failers", 3368));
-assertNull(res[1083].exec("b", 3369));
-assertToStringEquals("abbbcd,c", res[1085].exec("abbbcd"), 3370);
-assertToStringEquals("abcd,a", res[1086].exec("abcd"), 3371);
-assertToStringEquals("e", res[1087].exec("e"), 3372);
-assertToStringEquals("ef,e", res[1088].exec("ef"), 3373);
-assertToStringEquals("abcdefg", res[1089].exec("abcdefg"), 3374);
-assertToStringEquals("ab", res[1090].exec("xabyabbbz"), 3375);
-assertToStringEquals("a", res[1090].exec("xayabbbz"), 3376);
-assertToStringEquals("cde,cd", res[1091].exec("abcde"), 3377);
-assertToStringEquals("hij", res[1092].exec("hij"), 3378);
-assertToStringEquals("ef,", res[1094].exec("abcdef"), 3379);
-assertToStringEquals("bcd,b", res[1095].exec("abcd"), 3380);
-assertToStringEquals("abc,a", res[1096].exec("abc"), 3381);
-assertToStringEquals("abc,bc", res[1097].exec("abc"), 3382);
-assertToStringEquals("abcd,bc,d", res[1098].exec("abcd"), 3383);
-assertToStringEquals("abcd,bc,d", res[1099].exec("abcd"), 3384);
-assertToStringEquals("abcd,b,cd", res[1100].exec("abcd"), 3385);
-assertToStringEquals("adcdcde", res[1101].exec("adcdcde"), 3386);
-assertNull(res[1102].exec("*** Failers", 3387));
-assertNull(res[1102].exec("abcde", 3388));
-assertNull(res[1102].exec("adcdcde", 3389));
-assertToStringEquals("abc,ab", res[1103].exec("abc"), 3390);
-assertToStringEquals("abcd,abc,a,b,d", res[1104].exec("abcd"), 3391);
-assertToStringEquals("alpha", res[1105].exec("alpha"), 3392);
-assertToStringEquals("bh,", res[1106].exec("abh"), 3393);
-assertToStringEquals("effgz,effgz,", res[1107].exec("effgz"), 3394);
-assertToStringEquals("ij,ij,j", res[1107].exec("ij"), 3395);
-assertToStringEquals("effgz,effgz,", res[1107].exec("reffgz"), 3396);
-assertNull(res[1107].exec("*** Failers", 3397));
-assertNull(res[1107].exec("effg", 3398));
-assertNull(res[1107].exec("bcdd", 3399));
-assertToStringEquals("a,a,a,a,a,a,a,a,a,a,a", res[1108].exec("a"), 3400);
-assertToStringEquals("a,a,a,a,a,a,a,a,a,a", res[1109].exec("a"), 3401);
-assertNull(res[1110].exec("*** Failers", 3402));
-assertNull(res[1110].exec("aa", 3403));
-assertNull(res[1110].exec("uh-uh", 3404));
-assertToStringEquals("multiple words", res[1111].exec("multiple words, yeah"), 3405);
-assertToStringEquals("abcde,ab,de", res[1112].exec("abcde"), 3406);
-assertToStringEquals("(a, b),a,b", res[1113].exec("(a, b)"), 3407);
-assertToStringEquals("abcd", res[1115].exec("abcd"), 3408);
-assertToStringEquals("abcd,bc", res[1116].exec("abcd"), 3409);
-assertToStringEquals("ac", res[1117].exec("ac"), 3410);
-assertToStringEquals("ABC", res[1118].exec("ABC"), 3411);
-assertToStringEquals("ABC", res[1118].exec("XABCY"), 3412);
-assertToStringEquals("ABC", res[1118].exec("ABABC"), 3413);
-assertNull(res[1118].exec("*** Failers", 3414));
-assertNull(res[1118].exec("aaxabxbaxbbx", 3415));
-assertNull(res[1118].exec("XBC", 3416));
-assertNull(res[1118].exec("AXC", 3417));
-assertNull(res[1118].exec("ABX", 3418));
-assertToStringEquals("ABC", res[1119].exec("ABC"), 3419);
-assertToStringEquals("ABC", res[1120].exec("ABC"), 3420);
-assertToStringEquals("ABBC", res[1120].exec("ABBC"), 3421);
-assertToStringEquals("ABBBBC", res[1121].exec("ABBBBC"), 3422);
-assertToStringEquals("ABBBBC", res[1122].exec("ABBBBC"), 3423);
-assertToStringEquals("ABBC", res[1123].exec("ABBC"), 3424);
-assertNull(res[1124].exec("*** Failers", 3425));
-assertNull(res[1124].exec("ABC", 3426));
-assertNull(res[1124].exec("ABQ", 3427));
-assertToStringEquals("ABBBBC", res[1126].exec("ABBBBC"), 3428);
-assertToStringEquals("ABBBBC", res[1127].exec("ABBBBC"), 3429);
-assertToStringEquals("ABBBBC", res[1128].exec("ABBBBC"), 3430);
-assertToStringEquals("ABBBBC", res[1129].exec("ABBBBC"), 3431);
-assertNull(res[1130].exec("*** Failers", 3432));
-assertNull(res[1130].exec("ABQ", 3433));
-assertNull(res[1130].exec("ABBBBC", 3434));
-assertToStringEquals("ABBC", res[1131].exec("ABBC"), 3435);
-assertToStringEquals("ABC", res[1131].exec("ABC"), 3436);
-assertToStringEquals("ABC", res[1132].exec("ABC"), 3437);
-assertToStringEquals("ABC", res[1134].exec("ABC"), 3438);
-assertToStringEquals("ABC", res[1135].exec("ABC"), 3439);
-assertToStringEquals("ABC", res[1136].exec("ABC"), 3440);
-assertNull(res[1136].exec("*** Failers", 3441));
-assertNull(res[1136].exec("ABBBBC", 3442));
-assertNull(res[1136].exec("ABCC", 3443));
-assertToStringEquals("ABC", res[1137].exec("ABCC"), 3444);
-assertToStringEquals("ABC", res[1139].exec("AABC"), 3445);
-assertToStringEquals("", res[1140].exec("ABC"), 3446);
-assertToStringEquals("", res[1141].exec("ABC"), 3447);
-assertToStringEquals("ABC", res[1142].exec("ABC"), 3448);
-assertToStringEquals("AXC", res[1142].exec("AXC"), 3449);
-assertToStringEquals("AXYZC", res[1143].exec("AXYZC"), 3450);
-assertNull(res[1144].exec("*** Failers", 3451));
-assertToStringEquals("AABC", res[1144].exec("AABC"), 3452);
-assertNull(res[1144].exec("AXYZD", 3453));
-assertToStringEquals("ABD", res[1145].exec("ABD"), 3454);
-assertToStringEquals("ACE", res[1146].exec("ACE"), 3455);
-assertNull(res[1146].exec("*** Failers", 3456));
-assertNull(res[1146].exec("ABC", 3457));
-assertNull(res[1146].exec("ABD", 3458));
-assertToStringEquals("AC", res[1147].exec("AAC"), 3459);
-assertToStringEquals("A-", res[1148].exec("A-"), 3460);
-assertToStringEquals("A-", res[1149].exec("A-"), 3461);
-assertToStringEquals("A]", res[1150].exec("A]"), 3462);
-assertNull(res[1151].exec("A]B", 3463));
-assertToStringEquals("AED", res[1152].exec("AED"), 3464);
-assertToStringEquals("ADC", res[1153].exec("ADC"), 3465);
-assertNull(res[1153].exec("*** Failers", 3466));
-assertNull(res[1153].exec("ABD", 3467));
-assertNull(res[1153].exec("A-C", 3468));
-assertNull(res[1154].exec("ADC", 3469));
-assertToStringEquals("AB", res[1155].exec("ABC"), 3470);
-assertToStringEquals("AB", res[1155].exec("ABCD"), 3471);
-assertToStringEquals("EF,", res[1156].exec("DEF"), 3472);
-assertNull(res[1157].exec("*** Failers", 3473));
-assertNull(res[1157].exec("A]C", 3474));
-assertNull(res[1157].exec("B", 3475));
-assertToStringEquals("A(B", res[1158].exec("A(B"), 3476);
-assertNull(res[1158].exec("AB", 3477));
-assertNull(res[1158].exec("A((B", 3478));
-assertNull(res[1159].exec("AB", 3479));
-assertToStringEquals("A,A,A", res[1160].exec("ABC"), 3480);
-assertToStringEquals("ABC,A,C", res[1161].exec("ABC"), 3481);
-assertToStringEquals("ABC", res[1162].exec("AABBABC"), 3482);
-assertToStringEquals("ABC", res[1163].exec("AABBABC"), 3483);
-assertToStringEquals("ABC", res[1164].exec("ABCABC"), 3484);
-assertToStringEquals("ABC", res[1165].exec("ABCABC"), 3485);
-assertToStringEquals("ABC", res[1166].exec("ABCABC"), 3486);
-assertToStringEquals("AB,B", res[1167].exec("AB"), 3487);
-assertToStringEquals("AB,B", res[1168].exec("AB"), 3488);
-assertToStringEquals("AB,B", res[1169].exec("AB"), 3489);
-assertToStringEquals("AB,B", res[1170].exec("AB"), 3490);
-assertToStringEquals("A,A", res[1171].exec("AB"), 3491);
-assertToStringEquals("A,A", res[1172].exec("AB"), 3492);
-assertToStringEquals(",", res[1173].exec("AB"), 3493);
-assertToStringEquals("CDE", res[1174].exec("CDE"), 3494);
-assertToStringEquals("ABBBCD,C", res[1177].exec("ABBBCD"), 3495);
-assertToStringEquals("ABCD,A", res[1178].exec("ABCD"), 3496);
-assertToStringEquals("E", res[1179].exec("E"), 3497);
-assertToStringEquals("EF,E", res[1180].exec("EF"), 3498);
-assertToStringEquals("ABCDEFG", res[1181].exec("ABCDEFG"), 3499);
-assertToStringEquals("AB", res[1182].exec("XABYABBBZ"), 3500);
-assertToStringEquals("A", res[1182].exec("XAYABBBZ"), 3501);
-assertToStringEquals("CDE,CD", res[1183].exec("ABCDE"), 3502);
-assertToStringEquals("HIJ", res[1184].exec("HIJ"), 3503);
-assertNull(res[1185].exec("ABCDE", 3504));
-assertToStringEquals("EF,", res[1186].exec("ABCDEF"), 3505);
-assertToStringEquals("BCD,B", res[1187].exec("ABCD"), 3506);
-assertToStringEquals("ABC,A", res[1188].exec("ABC"), 3507);
-assertToStringEquals("ABC,BC", res[1189].exec("ABC"), 3508);
-assertToStringEquals("ABCD,BC,D", res[1190].exec("ABCD"), 3509);
-assertToStringEquals("ABCD,BC,D", res[1191].exec("ABCD"), 3510);
-assertToStringEquals("ABCD,B,CD", res[1192].exec("ABCD"), 3511);
-assertToStringEquals("ADCDCDE", res[1193].exec("ADCDCDE"), 3512);
-assertToStringEquals("ABC,AB", res[1195].exec("ABC"), 3513);
-assertToStringEquals("ABCD,ABC,A,B,D", res[1196].exec("ABCD"), 3514);
-assertToStringEquals("ALPHA", res[1197].exec("ALPHA"), 3515);
-assertToStringEquals("BH,", res[1198].exec("ABH"), 3516);
-assertToStringEquals("EFFGZ,EFFGZ,", res[1199].exec("EFFGZ"), 3517);
-assertToStringEquals("IJ,IJ,J", res[1199].exec("IJ"), 3518);
-assertToStringEquals("EFFGZ,EFFGZ,", res[1199].exec("REFFGZ"), 3519);
-assertNull(res[1199].exec("*** Failers", 3520));
-assertNull(res[1199].exec("ADCDCDE", 3521));
-assertNull(res[1199].exec("EFFG", 3522));
-assertNull(res[1199].exec("BCDD", 3523));
-assertToStringEquals("A,A,A,A,A,A,A,A,A,A,A", res[1200].exec("A"), 3524);
-assertToStringEquals("A,A,A,A,A,A,A,A,A,A", res[1201].exec("A"), 3525);
-assertToStringEquals("A,A", res[1202].exec("A"), 3526);
-assertToStringEquals("C,C", res[1203].exec("C"), 3527);
-assertNull(res[1204].exec("*** Failers", 3528));
-assertNull(res[1204].exec("AA", 3529));
-assertNull(res[1204].exec("UH-UH", 3530));
-assertToStringEquals("MULTIPLE WORDS", res[1205].exec("MULTIPLE WORDS, YEAH"), 3531);
-assertToStringEquals("ABCDE,AB,DE", res[1206].exec("ABCDE"), 3532);
-assertToStringEquals("(A, B),A,B", res[1207].exec("(A, B)"), 3533);
-assertToStringEquals("ABCD", res[1209].exec("ABCD"), 3534);
-assertToStringEquals("ABCD,BC", res[1210].exec("ABCD"), 3535);
-assertToStringEquals("AC", res[1211].exec("AC"), 3536);
-assertToStringEquals("ad", res[1212].exec("abad"), 3537);
-assertToStringEquals("ad", res[1213].exec("abad"), 3538);
-assertToStringEquals("ad", res[1214].exec("abad"), 3539);
-assertToStringEquals("ace,e", res[1215].exec("ace"), 3540);
-assertToStringEquals("ace,e", res[1216].exec("ace"), 3541);
-assertToStringEquals("ace,e", res[1217].exec("ace"), 3542);
-assertToStringEquals("acd,d", res[1217].exec("acdbcdbe"), 3543);
-assertToStringEquals("acdbcdbe,e", res[1218].exec("acdbcdbe"), 3544);
-assertToStringEquals("acdb,b", res[1219].exec("acdbcdbe"), 3545);
-assertToStringEquals("acdbcdb,b", res[1220].exec("acdbcdbe"), 3546);
-assertToStringEquals("acdbcd,d", res[1221].exec("acdbcdbe"), 3547);
-assertToStringEquals("foobar,bar,,bar", res[1222].exec("foobar"), 3548);
-assertToStringEquals("acdbcdbe,e", res[1223].exec("acdbcdbe"), 3549);
-assertToStringEquals("acdbcdbe,e", res[1224].exec("acdbcdbe"), 3550);
-assertToStringEquals("acdbcdbe,e", res[1225].exec("acdbcdbe"), 3551);
-assertToStringEquals("acdbcdb,b", res[1226].exec("acdbcdbe"), 3552);
-assertToStringEquals("acdbcdbe,e", res[1227].exec("acdbcdbe"), 3553);
-assertToStringEquals("acdbcdb,b", res[1228].exec("acdbcdbe"), 3554);
-assertToStringEquals("ace,c,e", res[1229].exec("ace"), 3555);
-assertToStringEquals("AB,A", res[1230].exec("AB"), 3556);
-assertToStringEquals(".,.,", res[1231].exec("."), 3557);
-assertToStringEquals("<&", res[1232].exec("<&OUT"), 3558);
-assertToStringEquals("foobar,,,,b,a,r", res[1233].exec("foobar"), 3559);
-assertToStringEquals(",,,,,,", res[1233].exec("ab"), 3560);
-assertToStringEquals(",,,,,,", res[1233].exec("*** Failers"), 3561);
-assertToStringEquals(",,,,,,", res[1233].exec("cb"), 3562);
-assertToStringEquals(",,,,,,", res[1233].exec("b"), 3563);
-assertToStringEquals(",,,,,,", res[1233].exec("ab"), 3564);
-assertToStringEquals(",,,,,,", res[1233].exec("b"), 3565);
-assertToStringEquals(",,,,,,", res[1233].exec("b"), 3566);
-assertToStringEquals("aba", res[1234].exec("aba"), 3567);
-assertToStringEquals("a", res[1235].exec("aba"), 3568);
-assertToStringEquals(",", res[1236].exec("abc"), 3569);
-assertToStringEquals("aax,a", res[1237].exec("aax"), 3570);
-assertToStringEquals("aax,a,a", res[1238].exec("aax"), 3571);
-assertToStringEquals("aax,a,a", res[1239].exec("aax"), 3572);
-assertToStringEquals("ab,", res[1240].exec("cab"), 3573);
-assertToStringEquals("ab,", res[1241].exec("cab"), 3574);
-assertToStringEquals("ab,", res[1241].exec("ab"), 3575);
-assertToStringEquals("ab,", res[1241].exec("ab"), 3576);
-assertNull(res[1241].exec("Ab", 3577));
-assertNull(res[1241].exec("Ab", 3578));
-assertNull(res[1241].exec("*** Failers", 3579));
-assertNull(res[1241].exec("cb", 3580));
-assertNull(res[1241].exec("aB", 3581));
-assertToStringEquals("ab,", res[1241].exec("ab"), 3582);
-assertToStringEquals("ab,", res[1241].exec("ab"), 3583);
-assertNull(res[1241].exec("Ab", 3584));
-assertNull(res[1241].exec("Ab", 3585));
-assertNull(res[1241].exec("*** Failers", 3586));
-assertNull(res[1241].exec("aB", 3587));
-assertNull(res[1241].exec("aB", 3588));
-assertToStringEquals("ab,", res[1241].exec("ab"), 3589);
-assertToStringEquals("ab,", res[1241].exec("ab"), 3590);
-assertNull(res[1241].exec("aB", 3591));
-assertNull(res[1241].exec("aB", 3592));
-assertNull(res[1241].exec("*** Failers", 3593));
-assertNull(res[1241].exec("aB", 3594));
-assertNull(res[1241].exec("Ab", 3595));
-assertNull(res[1241].exec("aB", 3596));
-assertNull(res[1241].exec("aB", 3597));
-assertNull(res[1241].exec("*** Failers", 3598));
-assertNull(res[1241].exec("Ab", 3599));
-assertNull(res[1241].exec("AB", 3600));
-assertToStringEquals("ab,", res[1241].exec("ab"), 3601);
-assertToStringEquals("ab,", res[1241].exec("ab"), 3602);
-assertNull(res[1241].exec("aB", 3603));
-assertNull(res[1241].exec("aB", 3604));
-assertNull(res[1241].exec("*** Failers", 3605));
-assertNull(res[1241].exec("AB", 3606));
-assertNull(res[1241].exec("Ab", 3607));
-assertNull(res[1241].exec("aB", 3608));
-assertNull(res[1241].exec("aB", 3609));
-assertNull(res[1241].exec("*** Failers", 3610));
-assertNull(res[1241].exec("Ab", 3611));
-assertNull(res[1241].exec("AB", 3612));
-assertNull(res[1241].exec("*** Failers", 3613));
-assertNull(res[1241].exec("AB", 3614));
-assertNull(res[1241].exec("a\nB", 3615));
-assertNull(res[1241].exec("a\nB", 3616));
-assertToStringEquals("cabbbb", res[1242].exec("cabbbb"), 3617);
-assertToStringEquals("caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", res[1243].exec("caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), 3618);
-assertToStringEquals("foobar1234baz", res[1244].exec("foobar1234baz"), 3619);
-assertToStringEquals("x~~,~~", res[1245].exec("x~~"), 3620);
-assertToStringEquals("aaac", res[1246].exec("aaac"), 3621);
-assertToStringEquals("aaac", res[1247].exec("aaac"), 3622);
-assertNull(res[1247].exec("*** Failers", 3623));
-assertNull(res[1247].exec("B\nB", 3624));
-assertNull(res[1247].exec("dbcb", 3625));
-assertNull(res[1247].exec("dbaacb", 3626));
-assertNull(res[1247].exec("dbaacb", 3627));
-assertNull(res[1247].exec("cdaccb", 3628));
-assertNull(res[1248].exec("*** Failers", 3629));
-assertNull(res[1248].exec("dbcb", 3630));
-assertNull(res[1248].exec("a--", 3631));
-assertNull(res[1248].exec("a\nb\nc\n", 3632));
-assertNull(res[1248].exec("a\nb\nc\n", 3633));
-assertNull(res[1248].exec("a\nb\n", 3634));
-assertNull(res[1248].exec("a\nb\n", 3635));
-assertNull(res[1248].exec("a\nb\n", 3636));
-assertNull(res[1248].exec("a\nb\n", 3637));
-assertNull(res[1248].exec("a\nb\nc\n", 3638));
-assertNull(res[1248].exec("a\nb\nc\n", 3639));
-assertNull(res[1248].exec("a\nb\nc\n", 3640));
-assertNull(res[1248].exec("a\nb\nc\n", 3641));
-assertNull(res[1250].exec("*** Failers", 3642));
-assertNull(res[1250].exec("a\nb\nc\n", 3643));
-assertNull(res[1250].exec("a\nb\nc\n", 3644));
-assertNull(res[1250].exec("a\nb\nc\n", 3645));
-assertNull(res[1250].exec("a", 3646));
-assertNull(res[1250].exec("*** Failers", 3647));
-assertNull(res[1250].exec("a", 3648));
-assertNull(res[1250].exec("a", 3649));
-assertNull(res[1250].exec("a", 3650));
-assertToStringEquals("one:,one:", res[1251].exec("one:"), 3651);
-assertNull(res[1251].exec("a", 3652));
-assertToStringEquals("abcd,,abcd", res[1252].exec("abcd"), 3653);
-assertToStringEquals("xy:z:::abcd,xy:z:::,abcd", res[1252].exec("xy:z:::abcd"), 3654);
-assertToStringEquals("aexyc,c", res[1253].exec("aexycd"), 3655);
-assertToStringEquals("aab,aa", res[1254].exec("caab"), 3656);
-assertToStringEquals("abcd,,abcd", res[1255].exec("abcd"), 3657);
-assertToStringEquals("xy:z:::abcd,xy:z:::,abcd", res[1255].exec("xy:z:::abcd"), 3658);
-assertToStringEquals("Failers,,Failers", res[1255].exec("*** Failers"), 3659);
-assertNull(res[1255].exec("abcd:", 3660));
-assertNull(res[1255].exec("abcd:", 3661));
-assertToStringEquals("aexyc,c", res[1256].exec("aexycd"), 3662);
-assertNull(res[1257].exec("aaab", 3663));
-assertToStringEquals(":[,:[", res[1258].exec("a:[b]:"), 3664);
-assertToStringEquals("=[,=[", res[1259].exec("a=[b]="), 3665);
-assertToStringEquals(".[,.[", res[1260].exec("a.[b]."), 3666);
-assertNull(res[1260].exec("aaab", 3667));
-assertNull(res[1260].exec("aaab", 3668));
-assertNull(res[1260].exec("((abc(ade)ufh()()x", 3669));
-assertNull(res[1261].exec("*** Failers", 3670));
-assertNull(res[1261].exec("aaab", 3671));
-assertNull(res[1261].exec("a\nb\n", 3672));
-assertNull(res[1262].exec("a\nb\n", 3673));
-assertNull(res[1264].exec("a\nb", 3674));
-assertNull(res[1265].exec("a\nb", 3675));
-assertNull(res[1265].exec("*** Failers", 3676));
-assertNull(res[1265].exec("alphabetabcd", 3677));
-assertNull(res[1265].exec("endingwxyz", 3678));
-assertNull(res[1265].exec("*** Failers", 3679));
-assertNull(res[1265].exec("a rather long string that doesn't end with one of them", 3680));
-assertNull(res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark otherword", 3681));
-assertNull(res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark", 3682));
-assertNull(res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope", 3683));
-assertNull(res[1265].exec("999foo", 3684));
-assertNull(res[1265].exec("123999foo ", 3685));
-assertNull(res[1265].exec("*** Failers", 3686));
-assertNull(res[1265].exec("123abcfoo", 3687));
-assertNull(res[1265].exec("999foo", 3688));
-assertNull(res[1265].exec("123999foo ", 3689));
-assertNull(res[1265].exec("*** Failers", 3690));
-assertNull(res[1265].exec("123abcfoo", 3691));
-assertNull(res[1265].exec("123abcfoo", 3692));
-assertNull(res[1265].exec("123456foo ", 3693));
-assertNull(res[1265].exec("*** Failers", 3694));
-assertNull(res[1265].exec("123999foo  ", 3695));
-assertNull(res[1265].exec("123abcfoo   ", 3696));
-assertNull(res[1265].exec("123456foo ", 3697));
-assertNull(res[1265].exec("*** Failers", 3698));
-assertNull(res[1265].exec("123999foo  ", 3699));
-assertToStringEquals("ZA,A,", res[1266].exec("ZABCDEFG"), 3700);
-assertToStringEquals("ZA,A,", res[1267].exec("ZABCDEFG"), 3701);
-assertToStringEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3702);
-assertToStringEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3703);
-assertToStringEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3704);
-assertToStringEquals("a", res[1269].exec("abbab"), 3705);
-assertToStringEquals("", res[1269].exec("abcde"), 3706);
-assertToStringEquals("", res[1269].exec("-things"), 3707);
-assertToStringEquals("", res[1269].exec("0digit"), 3708);
-assertToStringEquals("", res[1269].exec("*** Failers"), 3709);
-assertToStringEquals("", res[1269].exec("bcdef    "), 3710);
-assertToStringEquals("a", res[1270].exec("abcde"), 3711);
-assertToStringEquals("-", res[1270].exec("-things"), 3712);
-assertToStringEquals("0", res[1270].exec("0digit"), 3713);
-assertNull(res[1270].exec("*** Failers", 3714));
-assertNull(res[1270].exec("bcdef    ", 3715));
-assertNull(res[1271].exec("> \x09\n\x0c\x0d\x0b<", 3716));
-assertNull(res[1271].exec(" ", 3717));
-assertNull(res[1272].exec("> \x09\n\x0c\x0d\x0b<", 3718));
-assertNull(res[1272].exec(" ", 3719));
-assertToStringEquals(" \x09\n\x0c\x0d\x0b", res[1273].exec("> \x09\n\x0c\x0d\x0b<"), 3720);
-assertToStringEquals(" ", res[1273].exec(" "), 3721);
-assertToStringEquals(" \x09\n\x0c\x0d\x0b", res[1274].exec("> \x09\n\x0c\x0d\x0b<"), 3722);
-assertToStringEquals(" ", res[1274].exec(" "), 3723);
-assertNull(res[1275].exec("ab", 3724));
-assertNull(res[1278].exec("abcabcabc", 3725));
-assertNull(res[1278].exec("abc(*+|abc ", 3726));
-assertNull(res[1279].exec("abc abcabc", 3727));
-assertNull(res[1279].exec("*** Failers", 3728));
-assertNull(res[1279].exec("abcabcabc  ", 3729));
-assertNull(res[1280].exec("abc#not comment\n    literal     ", 3730));
-assertNull(res[1281].exec("abc#not comment\n    literal     ", 3731));
-assertNull(res[1282].exec("abc#not comment\n    literal     ", 3732));
-assertNull(res[1283].exec("abc#not comment\n    literal     ", 3733));
-assertNull(res[1284].exec("abc\\$xyz", 3734));
-assertNull(res[1285].exec("abc$xyz", 3735));
-assertNull(res[1286].exec("abc", 3736));
-assertNull(res[1286].exec("*** Failers", 3737));
-assertNull(res[1286].exec("xyzabc  ", 3738));
-assertNull(res[1287].exec("abc1abc2xyzabc3", 3739));
-assertToStringEquals("abc1", res[1288].exec("abc1abc2xyzabc3 "), 3740);
-assertNull(res[1288].exec("XabcdY", 3741));
-assertNull(res[1288].exec("*** Failers ", 3742));
-assertNull(res[1288].exec("Xa b c d Y ", 3743));
-assertToStringEquals("abcY", res[1288].exec("XabcY"), 3744);
-assertNull(res[1288].exec("AxyzB ", 3745));
-assertNull(res[1288].exec("XabCY", 3746));
-assertNull(res[1288].exec("*** Failers", 3747));
-assertToStringEquals("abcY", res[1288].exec("XabcY  "), 3748);
-assertNull(res[1288].exec("abCE", 3749));
-assertNull(res[1288].exec("DE", 3750));
-assertNull(res[1288].exec("*** Failers", 3751));
-assertToStringEquals("abcE", res[1288].exec("abcE"), 3752);
-assertNull(res[1288].exec("abCe  ", 3753));
-assertNull(res[1288].exec("dE", 3754));
-assertNull(res[1288].exec("De    ", 3755));
-assertNull(res[1289].exec("z", 3756));
-assertNull(res[1289].exec("a", 3757));
-assertNull(res[1289].exec("-", 3758));
-assertNull(res[1289].exec("d", 3759));
-assertNull(res[1289].exec("] ", 3760));
-assertNull(res[1289].exec("*** Failers", 3761));
-assertNull(res[1289].exec("b     ", 3762));
-assertToStringEquals("z", res[1290].exec("z"), 3763);
-assertToStringEquals("C", res[1290].exec("C "), 3764);
-assertToStringEquals("M", res[1291].exec("M "), 3765);
-assertNull(res[1292].exec("", 3766));
-assertNull(res[1292].exec("REGular", 3767));
-assertNull(res[1292].exec("regulaer", 3768));
-assertNull(res[1292].exec("Regex  ", 3769));
-assertNull(res[1292].exec("regul\ufffdr ", 3770));
-assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3771));
-assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3772));
-assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3773));
-assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3774));
-assertNull(res[1292].exec("\x84XAZXB", 3775));
-assertNull(res[1292].exec("123a", 3776));
-assertNull(res[1292].exec("ac", 3777));
-assertToStringEquals("b,", res[1292].exec("bbbbc"), 3778);
-assertToStringEquals("ab,a", res[1292].exec("abc"), 3779);
-assertNull(res[1292].exec("*** Failers", 3780));
-assertToStringEquals("b,", res[1292].exec("bca"), 3781);
-assertNull(res[1292].exec("", 3782));
-assertToStringEquals("ab,a", res[1292].exec("abc"), 3783);
-assertNull(res[1292].exec("*** Failers", 3784));
-assertToStringEquals("b,", res[1292].exec("bca"), 3785);
-assertToStringEquals("ab,a", res[1292].exec("abc"), 3786);
-assertNull(res[1292].exec("*** Failers", 3787));
-assertNull(res[1292].exec("def  ", 3788));
-assertNull(res[1292].exec("", 3789));
-assertToStringEquals("ab,a", res[1292].exec("abc"), 3790);
-assertNull(res[1292].exec("*** Failers", 3791));
-assertNull(res[1292].exec("def  ", 3792));
-assertNull(res[1292].exec("", 3793));
-assertToStringEquals("line\nbreak", res[1293].exec("this is a line\nbreak"), 3794);
-assertToStringEquals("line\nbreak", res[1293].exec("line one\nthis is a line\nbreak in the second line "), 3795);
-assertToStringEquals("line\nbreak", res[1294].exec("this is a line\nbreak"), 3796);
-assertNull(res[1294].exec("** Failers ", 3797));
-assertToStringEquals("line\nbreak", res[1294].exec("line one\nthis is a line\nbreak in the second line "), 3798);
-assertToStringEquals("line\nbreak", res[1295].exec("this is a line\nbreak"), 3799);
-assertNull(res[1295].exec("** Failers ", 3800));
-assertToStringEquals("line\nbreak", res[1295].exec("line one\nthis is a line\nbreak in the second line "), 3801);
-assertNull(res[1296].exec("123P", 3802));
-assertNull(res[1296].exec("a4PR", 3803));
-assertNull(res[1297].exec("123P", 3804));
-assertNull(res[1297].exec("4PR", 3805));
-assertToStringEquals("", res[1298].exec("a\nb\nc\n"), 3806);
-assertToStringEquals("", res[1298].exec(" "), 3807);
-assertToStringEquals("", res[1298].exec("A\nC\nC\n "), 3808);
-assertToStringEquals("", res[1298].exec("AB"), 3809);
-assertToStringEquals("", res[1298].exec("aB  "), 3810);
-assertToStringEquals("", res[1298].exec("AB"), 3811);
-assertToStringEquals("", res[1298].exec("aB  "), 3812);
-assertToStringEquals("", res[1298].exec("AB"), 3813);
-assertToStringEquals("", res[1298].exec("aB  "), 3814);
-assertToStringEquals("", res[1298].exec("AB"), 3815);
-assertToStringEquals("", res[1298].exec("aB  "), 3816);
-assertToStringEquals("Content-Type:xxxxxyyy ", res[1299].exec("Content-Type:xxxxxyyy "), 3817);
-assertToStringEquals("Content-Type:xxxxxyyyz", res[1300].exec("Content-Type:xxxxxyyyz"), 3818);
-assertToStringEquals("Content-Type:xxxyyy ", res[1301].exec("Content-Type:xxxyyy "), 3819);
-assertToStringEquals("Content-Type:xxxyyyz", res[1302].exec("Content-Type:xxxyyyz"), 3820);
-assertToStringEquals("abc", res[1303].exec("xyz\nabc"), 3821);
-assertToStringEquals("abc", res[1303].exec("xyz\nabc<lf>"), 3822);
-assertToStringEquals("abc", res[1303].exec("xyz\x0d\nabc<lf>"), 3823);
-assertToStringEquals("abc", res[1303].exec("xyz\x0dabc<cr>"), 3824);
-assertToStringEquals("abc", res[1303].exec("xyz\x0d\nabc<crlf>"), 3825);
-assertNull(res[1303].exec("** Failers ", 3826));
-assertToStringEquals("abc", res[1303].exec("xyz\nabc<cr>"), 3827);
-assertToStringEquals("abc", res[1303].exec("xyz\x0d\nabc<cr>"), 3828);
-assertToStringEquals("abc", res[1303].exec("xyz\nabc<crlf>"), 3829);
-assertToStringEquals("abc", res[1303].exec("xyz\x0dabc<crlf>"), 3830);
-assertToStringEquals("abc", res[1303].exec("xyz\x0dabc<lf>"), 3831);
-assertToStringEquals("abc", res[1304].exec("xyzabc"), 3832);
-assertToStringEquals("abc", res[1304].exec("xyzabc\n "), 3833);
-assertToStringEquals("abc", res[1304].exec("xyzabc\npqr "), 3834);
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0d<cr> "), 3835);
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0dpqr<cr> "), 3836);
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\n<crlf> "), 3837);
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\npqr<crlf> "), 3838);
-assertNull(res[1304].exec("** Failers", 3839));
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0d "), 3840);
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0dpqr "), 3841);
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\n "), 3842);
-assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\npqr "), 3843);
-assertToStringEquals("abc", res[1305].exec("xyz\x0dabcdef"), 3844);
-assertToStringEquals("abc", res[1305].exec("xyz\nabcdef<lf>"), 3845);
-assertNull(res[1305].exec("** Failers  ", 3846));
-assertToStringEquals("abc", res[1305].exec("xyz\nabcdef"), 3847);
-assertNull(res[1305].exec("   ", 3848));
-assertToStringEquals("abc", res[1306].exec("xyz\nabcdef"), 3849);
-assertToStringEquals("abc", res[1306].exec("xyz\x0dabcdef<cr>"), 3850);
-assertNull(res[1306].exec("** Failers  ", 3851));
-assertToStringEquals("abc", res[1306].exec("xyz\x0dabcdef"), 3852);
-assertNull(res[1306].exec("   ", 3853));
-assertToStringEquals("abc", res[1307].exec("xyz\x0d\nabcdef"), 3854);
-assertToStringEquals("abc", res[1307].exec("xyz\x0dabcdef<cr>"), 3855);
-assertNull(res[1307].exec("** Failers  ", 3856));
-assertToStringEquals("abc", res[1307].exec("xyz\x0dabcdef"), 3857);
-assertToStringEquals("abc", res[1308].exec("abc\ndef"), 3858);
-assertToStringEquals("abc", res[1308].exec("abc\x0ddef"), 3859);
-assertToStringEquals("abc", res[1308].exec("abc\x0d\ndef"), 3860);
-assertToStringEquals("<cr>abc", res[1308].exec("<cr>abc\ndef"), 3861);
-assertToStringEquals("<cr>abc", res[1308].exec("<cr>abc\x0ddef"), 3862);
-assertToStringEquals("<cr>abc", res[1308].exec("<cr>abc\x0d\ndef"), 3863);
-assertToStringEquals("<crlf>abc", res[1308].exec("<crlf>abc\ndef"), 3864);
-assertToStringEquals("<crlf>abc", res[1308].exec("<crlf>abc\x0ddef"), 3865);
-assertToStringEquals("<crlf>abc", res[1308].exec("<crlf>abc\x0d\ndef"), 3866);
-assertNull(res[1309].exec("abc\ndef", 3867));
-assertNull(res[1309].exec("abc\x0ddef", 3868));
-assertNull(res[1309].exec("abc\x0d\ndef", 3869));
-assertToStringEquals("abc=xyz\\,", res[1310].exec("abc=xyz\\\npqr"), 3870);
-assertToStringEquals("aaaa,a,", res[1311].exec("aaaa"), 3871);
-assertToStringEquals("aaaa", res[1312].exec("aaaa"), 3872);
-assertToStringEquals("aaaa,a,", res[1313].exec("aaaa"), 3873);
-assertToStringEquals("aaaa", res[1314].exec("aaaa"), 3874);
-assertNull(res[1317].exec("a\x0db", 3875));
-assertNull(res[1317].exec("a\nb<cr> ", 3876));
-assertNull(res[1317].exec("** Failers", 3877));
-assertNull(res[1317].exec("a\nb", 3878));
-assertNull(res[1317].exec("a\nb<any>", 3879));
-assertNull(res[1317].exec("a\x0db<cr>   ", 3880));
-assertNull(res[1317].exec("a\x0db<any>   ", 3881));
-assertToStringEquals("abc1", res[1318].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 3882);
-assertToStringEquals("abc1", res[1319].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 3883);
-assertNull(res[1320].exec("a\nb", 3884));
-assertNull(res[1320].exec("a\x0db", 3885));
-assertNull(res[1320].exec("a\x0d\nb", 3886));
-assertNull(res[1320].exec("a\x0bb", 3887));
-assertNull(res[1320].exec("a\x0cb", 3888));
-assertNull(res[1320].exec("a\x85b   ", 3889));
-assertNull(res[1320].exec("** Failers", 3890));
-assertNull(res[1320].exec("a\n\x0db    ", 3891));
-assertToStringEquals("ab", res[1321].exec("ab"), 3892);
-assertNull(res[1321].exec("a\nb", 3893));
-assertNull(res[1321].exec("a\x0db", 3894));
-assertNull(res[1321].exec("a\x0d\nb", 3895));
-assertNull(res[1321].exec("a\x0bb", 3896));
-assertNull(res[1321].exec("a\x0cb", 3897));
-assertNull(res[1321].exec("a\x85b   ", 3898));
-assertNull(res[1321].exec("a\n\x0db    ", 3899));
-assertNull(res[1321].exec("a\n\x0d\x85\x0cb ", 3900));
-assertNull(res[1322].exec("a\nb", 3901));
-assertNull(res[1322].exec("a\x0db", 3902));
-assertNull(res[1322].exec("a\x0d\nb", 3903));
-assertNull(res[1322].exec("a\x0bb", 3904));
-assertNull(res[1322].exec("a\x0cb", 3905));
-assertNull(res[1322].exec("a\x85b   ", 3906));
-assertNull(res[1322].exec("a\n\x0db    ", 3907));
-assertNull(res[1322].exec("a\n\x0d\x85\x0cb ", 3908));
-assertNull(res[1322].exec("** Failers", 3909));
-assertNull(res[1322].exec("ab  ", 3910));
-assertNull(res[1323].exec("a\nb", 3911));
-assertNull(res[1323].exec("a\n\x0db", 3912));
-assertNull(res[1323].exec("a\n\x0d\x85b", 3913));
-assertNull(res[1323].exec("a\x0d\n\x0d\nb ", 3914));
-assertNull(res[1323].exec("a\x0d\n\x0d\n\x0d\nb ", 3915));
-assertNull(res[1323].exec("a\n\x0d\n\x0db", 3916));
-assertNull(res[1323].exec("a\n\n\x0d\nb ", 3917));
-assertNull(res[1323].exec("** Failers", 3918));
-assertNull(res[1323].exec("a\n\n\n\x0db", 3919));
-assertNull(res[1323].exec("a\x0d", 3920));
-assertToStringEquals("aRb", res[1324].exec("aRb"), 3921);
-assertNull(res[1324].exec("** Failers", 3922));
-assertNull(res[1324].exec("a\nb  ", 3923));
-assertToStringEquals("afoo", res[1325].exec("afoo"), 3924);
-assertNull(res[1325].exec("** Failers ", 3925));
-assertNull(res[1325].exec("\x0d\nfoo ", 3926));
-assertNull(res[1325].exec("\nfoo ", 3927));
-assertToStringEquals("afoo", res[1326].exec("afoo"), 3928);
-assertNull(res[1326].exec("\nfoo ", 3929));
-assertNull(res[1326].exec("** Failers ", 3930));
-assertNull(res[1326].exec("\x0d\nfoo ", 3931));
-assertToStringEquals("afoo", res[1327].exec("afoo"), 3932);
-assertNull(res[1327].exec("** Failers ", 3933));
-assertNull(res[1327].exec("\nfoo ", 3934));
-assertNull(res[1327].exec("\x0d\nfoo ", 3935));
-assertToStringEquals("afoo", res[1328].exec("afoo"), 3936);
-assertNull(res[1328].exec("\x0d\nfoo ", 3937));
-assertNull(res[1328].exec("\nfoo ", 3938));
-assertToStringEquals("", res[1329].exec("abc\x0d\x0dxyz"), 3939);
-assertToStringEquals("", res[1329].exec("abc\n\x0dxyz  "), 3940);
-assertNull(res[1329].exec("** Failers ", 3941));
-assertToStringEquals("", res[1329].exec("abc\x0d\nxyz"), 3942);
-assertToStringEquals("X", res[1330].exec("XABC"), 3943);
-assertNull(res[1330].exec("** Failers ", 3944));
-assertToStringEquals("X", res[1330].exec("XABCB"), 3945);
-assertNull(res[1330].exec("abc\x0d\n\x0d\n", 3946));
-assertNull(res[1330].exec("abc\x0d\n\x0d\n", 3947));
-assertNull(res[1330].exec("abc\x0d\n\x0d\n", 3948));
+assertEquals("", res[986].exec("abc"), 2982);
+assertEquals("acb", res[988].exec("acb"), 2983);
+assertEquals("a\nb", res[988].exec("a\nb"), 2984);
+assertEquals("acb", res[989].exec("acb"), 2985);
+assertEquals(null, res[989].exec("*** Failers ", 2986));
+assertEquals(null, res[989].exec("a\nb   ", 2987));
+assertEquals("acb", res[990].exec("acb"), 2988);
+assertEquals("a\nb", res[990].exec("a\nb  "), 2989);
+assertEquals("acb", res[991].exec("acb"), 2990);
+assertEquals(null, res[991].exec("a\nb  ", 2991));
+assertEquals("bac,a", res[992].exec("bac"), 2992);
+assertEquals("bbac,a", res[992].exec("bbac"), 2993);
+assertEquals("bbbac,a", res[992].exec("bbbac"), 2994);
+assertEquals("bbbbac,a", res[992].exec("bbbbac"), 2995);
+assertEquals("bbbbbac,a", res[992].exec("bbbbbac "), 2996);
+assertEquals("bac,a", res[993].exec("bac"), 2997);
+assertEquals("bbac,a", res[993].exec("bbac"), 2998);
+assertEquals("bbbac,a", res[993].exec("bbbac"), 2999);
+assertEquals("bbbbac,a", res[993].exec("bbbbac"), 3000);
+assertEquals("bbbbbac,a", res[993].exec("bbbbbac "), 3001);
+assertEquals("x", res[994].exec("x\nb\n"), 3002);
+assertEquals("x", res[994].exec("a\x08x\n  "), 3003);
+assertEquals(null, res[995].exec("\x00{ab} ", 3004));
+assertEquals("CD,", res[996].exec("CD "), 3005);
+assertEquals("CD,", res[997].exec("CD "), 3006);
+assertEquals(null, res[997].exec("foo", 3007));
+assertEquals(null, res[997].exec("catfood", 3008));
+assertEquals(null, res[997].exec("arfootle", 3009));
+assertEquals(null, res[997].exec("rfoosh", 3010));
+assertEquals(null, res[997].exec("*** Failers", 3011));
+assertEquals(null, res[997].exec("barfoo", 3012));
+assertEquals(null, res[997].exec("towbarfoo", 3013));
+assertEquals(null, res[997].exec("catfood", 3014));
+assertEquals(null, res[997].exec("*** Failers", 3015));
+assertEquals(null, res[997].exec("foo", 3016));
+assertEquals(null, res[997].exec("barfoo", 3017));
+assertEquals(null, res[997].exec("towbarfoo", 3018));
+assertEquals(null, res[997].exec("fooabar", 3019));
+assertEquals(null, res[997].exec("*** Failers", 3020));
+assertEquals(null, res[997].exec("bar", 3021));
+assertEquals(null, res[997].exec("foobbar", 3022));
+assertEquals(null, res[997].exec("  ", 3023));
+assertEquals(null, res[998].exec("abc", 3024));
+assertEquals(null, res[998].exec("*** Failers", 3025));
+assertEquals(null, res[998].exec("abc\n   ", 3026));
+assertEquals(null, res[998].exec("qqq\nabc", 3027));
+assertEquals(null, res[998].exec("abc\nzzz", 3028));
+assertEquals(null, res[998].exec("qqq\nabc\nzzz", 3029));
+assertEquals(null, res[998].exec("/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/", 3030));
+assertEquals(null, res[998].exec("/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo", 3031));
+assertEquals(null, res[998].exec("1.230003938", 3032));
+assertEquals(null, res[998].exec("1.875000282", 3033));
+assertEquals(null, res[998].exec("*** Failers ", 3034));
+assertEquals(null, res[998].exec("1.235 ", 3035));
+assertEquals(null, res[998].exec("now is the time for all good men to come to the aid of the party", 3036));
+assertEquals(null, res[998].exec("*** Failers", 3037));
+assertEquals(null, res[998].exec("this is not a line with only words and spaces!", 3038));
+assertEquals("12345a,12345,a", res[999].exec("12345a"), 3039);
+assertEquals("12345,1234,5", res[999].exec("12345+ "), 3040);
+assertEquals("12345a,12345,a", res[999].exec("12345a"), 3041);
+assertEquals(null, res[999].exec("*** Failers", 3042));
+assertEquals("12345,1234,5", res[999].exec("12345+ "), 3043);
+assertEquals(null, res[999].exec("aaab", 3044));
+assertEquals(null, res[999].exec("aaab", 3045));
+assertEquals(null, res[999].exec("aaab", 3046));
+assertEquals(null, res[999].exec("aaabbbccc", 3047));
+assertEquals(null, res[999].exec("aaabbbbccccd", 3048));
+assertEquals("aaabbbbcccc,ccc", res[1000].exec("aaabbbbccccd"), 3049);
+assertEquals("abc,b", res[1000].exec("((abc(ade)ufh()()x"), 3050);
+assertEquals(null, res[1000].exec("", 3051));
+assertEquals("abc,b", res[1000].exec("(abc)"), 3052);
+assertEquals("abc,b", res[1000].exec("(abc(def)xyz)"), 3053);
+assertEquals(null, res[1000].exec("*** Failers", 3054));
+assertEquals(null, res[1000].exec("ab", 3055));
+assertEquals(null, res[1000].exec("Ab", 3056));
+assertEquals(null, res[1000].exec("*** Failers ", 3057));
+assertEquals(null, res[1000].exec("aB", 3058));
+assertEquals(null, res[1000].exec("AB", 3059));
+assertEquals(null, res[1000].exec("    ", 3060));
+assertEquals("bc,b", res[1000].exec("a bcd e"), 3061);
+assertEquals(null, res[1000].exec("*** Failers", 3062));
+assertEquals("c,", res[1000].exec("a b cd e"), 3063);
+assertEquals("abc,b", res[1000].exec("abcd e   "), 3064);
+assertEquals("bc,b", res[1000].exec("a bcde "), 3065);
+assertEquals("bc,b", res[1000].exec("a bcde f"), 3066);
+assertEquals(null, res[1000].exec("*** Failers", 3067));
+assertEquals("abc,b", res[1000].exec("abcdef  "), 3068);
+assertEquals("abc,b", res[1000].exec("abc"), 3069);
+assertEquals("c,", res[1000].exec("aBc"), 3070);
+assertEquals(null, res[1000].exec("*** Failers", 3071));
+assertEquals(null, res[1000].exec("abC", 3072));
+assertEquals(null, res[1000].exec("aBC  ", 3073));
+assertEquals("bc,b", res[1000].exec("Abc"), 3074);
+assertEquals("c,", res[1000].exec("ABc"), 3075);
+assertEquals(null, res[1000].exec("ABC", 3076));
+assertEquals(null, res[1000].exec("AbC", 3077));
+assertEquals(null, res[1000].exec("", 3078));
+assertEquals("abc,b", res[1000].exec("abc"), 3079);
+assertEquals("c,", res[1000].exec("aBc"), 3080);
+assertEquals(null, res[1000].exec("*** Failers ", 3081));
+assertEquals(null, res[1000].exec("ABC", 3082));
+assertEquals(null, res[1000].exec("abC", 3083));
+assertEquals(null, res[1000].exec("aBC", 3084));
+assertEquals(null, res[1000].exec("", 3085));
+assertEquals("c,", res[1000].exec("aBc"), 3086);
+assertEquals("c,", res[1000].exec("aBBc"), 3087);
+assertEquals(null, res[1000].exec("*** Failers ", 3088));
+assertEquals(null, res[1000].exec("aBC", 3089));
+assertEquals(null, res[1000].exec("aBBC", 3090));
+assertEquals(null, res[1000].exec("", 3091));
+assertEquals("abc,b", res[1000].exec("abcd"), 3092);
+assertEquals(null, res[1000].exec("abCd", 3093));
+assertEquals(null, res[1000].exec("*** Failers", 3094));
+assertEquals(null, res[1000].exec("aBCd", 3095));
+assertEquals("abc,b", res[1000].exec("abcD     "), 3096);
+assertEquals(null, res[1000].exec("", 3097));
+assertEquals(null, res[1000].exec("more than million", 3098));
+assertEquals(null, res[1000].exec("more than MILLION", 3099));
+assertEquals(null, res[1000].exec("more \n than Million ", 3100));
+assertEquals(null, res[1000].exec("*** Failers", 3101));
+assertEquals(null, res[1000].exec("MORE THAN MILLION    ", 3102));
+assertEquals(null, res[1000].exec("more \n than \n million ", 3103));
+assertEquals(null, res[1000].exec("more than million", 3104));
+assertEquals(null, res[1000].exec("more than MILLION", 3105));
+assertEquals(null, res[1000].exec("more \n than Million ", 3106));
+assertEquals(null, res[1000].exec("*** Failers", 3107));
+assertEquals(null, res[1000].exec("MORE THAN MILLION    ", 3108));
+assertEquals(null, res[1000].exec("more \n than \n million ", 3109));
+assertEquals(null, res[1000].exec("", 3110));
+assertEquals("abc,b", res[1000].exec("abc"), 3111);
+assertEquals("bc,b", res[1000].exec("aBbc"), 3112);
+assertEquals("c,", res[1000].exec("aBBc "), 3113);
+assertEquals(null, res[1000].exec("*** Failers", 3114));
+assertEquals("bc,b", res[1000].exec("Abc"), 3115);
+assertEquals(null, res[1000].exec("abAb    ", 3116));
+assertEquals(null, res[1000].exec("abbC ", 3117));
+assertEquals(null, res[1000].exec("", 3118));
+assertEquals("abc,b", res[1000].exec("abc"), 3119);
+assertEquals("c,", res[1000].exec("aBc"), 3120);
+assertEquals(null, res[1000].exec("*** Failers", 3121));
+assertEquals(null, res[1000].exec("Ab ", 3122));
+assertEquals(null, res[1000].exec("abC", 3123));
+assertEquals(null, res[1000].exec("aBC     ", 3124));
+assertEquals(null, res[1000].exec("", 3125));
+assertEquals("c,", res[1000].exec("abxxc"), 3126);
+assertEquals("c,", res[1000].exec("aBxxc"), 3127);
+assertEquals(null, res[1000].exec("*** Failers", 3128));
+assertEquals("c,", res[1000].exec("Abxxc"), 3129);
+assertEquals("c,", res[1000].exec("ABxxc"), 3130);
+assertEquals(null, res[1000].exec("abxxC      ", 3131));
+assertEquals("abc,b", res[1000].exec("abc:"), 3132);
+assertEquals(null, res[1000].exec("12", 3133));
+assertEquals(null, res[1000].exec("*** Failers", 3134));
+assertEquals(null, res[1000].exec("123", 3135));
+assertEquals(null, res[1000].exec("xyz    ", 3136));
+assertEquals("abc,b", res[1000].exec("abc:"), 3137);
+assertEquals(null, res[1000].exec("12", 3138));
+assertEquals(null, res[1000].exec("*** Failers", 3139));
+assertEquals(null, res[1000].exec("123", 3140));
+assertEquals(null, res[1000].exec("xyz    ", 3141));
+assertEquals(null, res[1000].exec("", 3142));
+assertEquals(null, res[1000].exec("foobar", 3143));
+assertEquals("c,", res[1000].exec("cat"), 3144);
+assertEquals("c,", res[1000].exec("fcat"), 3145);
+assertEquals("c,", res[1000].exec("focat   "), 3146);
+assertEquals(null, res[1000].exec("*** Failers", 3147));
+assertEquals("c,", res[1000].exec("foocat  "), 3148);
+assertEquals(null, res[1000].exec("foobar", 3149));
+assertEquals("c,", res[1000].exec("cat"), 3150);
+assertEquals("c,", res[1000].exec("fcat"), 3151);
+assertEquals("c,", res[1000].exec("focat   "), 3152);
+assertEquals(null, res[1000].exec("*** Failers", 3153));
+assertEquals("c,", res[1000].exec("foocat  "), 3154);
+assertEquals(null, res[1000].exec("a", 3155));
+assertEquals(null, res[1000].exec("aa", 3156));
+assertEquals(null, res[1000].exec("aaaa", 3157));
+assertEquals(null, res[1000].exec("", 3158));
+assertEquals("abc,abc", res[1001].exec("abc"), 3159);
+assertEquals("abcabc,abc", res[1001].exec("abcabc"), 3160);
+assertEquals("abcabcabc,abc", res[1001].exec("abcabcabc"), 3161);
+assertEquals(",", res[1001].exec("xyz      "), 3162);
+assertEquals("a,a", res[1002].exec("a"), 3163);
+assertEquals("aaaaa,aaaaa", res[1002].exec("aaaaa "), 3164);
+assertEquals("a,a", res[1003].exec("a"), 3165);
+assertEquals("b,b", res[1003].exec("b"), 3166);
+assertEquals("ababab,ababab", res[1003].exec("ababab"), 3167);
+assertEquals("aaaab,aaaab", res[1003].exec("aaaabcde"), 3168);
+assertEquals("bbbb,bbbb", res[1003].exec("bbbb    "), 3169);
+assertEquals("b,b", res[1004].exec("b"), 3170);
+assertEquals("bbbb,bbbb", res[1004].exec("bbbb"), 3171);
+assertEquals(",", res[1004].exec("aaa   "), 3172);
+assertEquals("cccc,cccc", res[1005].exec("cccc"), 3173);
+assertEquals(",", res[1005].exec("abab  "), 3174);
+assertEquals("a,a", res[1006].exec("a"), 3175);
+assertEquals("aaaa,a", res[1006].exec("aaaa "), 3176);
+assertEquals("a,a", res[1007].exec("a"), 3177);
+assertEquals("b,b", res[1007].exec("b"), 3178);
+assertEquals("abab,b", res[1007].exec("abab"), 3179);
+assertEquals("baba,a", res[1007].exec("baba   "), 3180);
+assertEquals("b,b", res[1008].exec("b"), 3181);
+assertEquals("bbbb,b", res[1008].exec("bbbb"), 3182);
+assertEquals(",", res[1008].exec("aaa   "), 3183);
+assertEquals("c,c", res[1009].exec("c"), 3184);
+assertEquals("cccc,c", res[1009].exec("cccc"), 3185);
+assertEquals(",", res[1009].exec("baba   "), 3186);
+assertEquals(",", res[1009].exec("a"), 3187);
+assertEquals(",", res[1009].exec("aaabcde "), 3188);
+assertEquals(",", res[1009].exec("aaaaa"), 3189);
+assertEquals(",", res[1009].exec("aabbaa "), 3190);
+assertEquals(",", res[1009].exec("aaaaa"), 3191);
+assertEquals(",", res[1009].exec("aabbaa "), 3192);
+assertEquals("12-sep-98,8", res[1009].exec("12-sep-98"), 3193);
+assertEquals("12-09-98,8", res[1009].exec("12-09-98"), 3194);
+assertEquals("*** F,F", res[1009].exec("*** Failers"), 3195);
+assertEquals("sep-12-98,8", res[1009].exec("sep-12-98"), 3196);
+assertEquals("    , ", res[1009].exec("    "), 3197);
+assertEquals("s,s", res[1009].exec("saturday"), 3198);
+assertEquals("sund,d", res[1009].exec("sunday"), 3199);
+assertEquals("S,S", res[1009].exec("Saturday"), 3200);
+assertEquals("Sund,d", res[1009].exec("Sunday"), 3201);
+assertEquals("SATURDAY,Y", res[1009].exec("SATURDAY"), 3202);
+assertEquals("SUNDAY,Y", res[1009].exec("SUNDAY"), 3203);
+assertEquals("SunD,D", res[1009].exec("SunDay"), 3204);
+assertEquals(",", res[1009].exec("abcx"), 3205);
+assertEquals(",", res[1009].exec("aBCx"), 3206);
+assertEquals(",", res[1009].exec("bbx"), 3207);
+assertEquals("BBx,x", res[1009].exec("BBx"), 3208);
+assertEquals("*** F,F", res[1009].exec("*** Failers"), 3209);
+assertEquals(",", res[1009].exec("abcX"), 3210);
+assertEquals(",", res[1009].exec("aBCX"), 3211);
+assertEquals(",", res[1009].exec("bbX"), 3212);
+assertEquals("BBX               , ", res[1009].exec("BBX               "), 3213);
+assertEquals(",", res[1009].exec("ac"), 3214);
+assertEquals(",", res[1009].exec("aC"), 3215);
+assertEquals(",", res[1009].exec("bD"), 3216);
+assertEquals("eleph,h", res[1009].exec("elephant"), 3217);
+assertEquals("Europe , ", res[1009].exec("Europe "), 3218);
+assertEquals("frog,g", res[1009].exec("frog"), 3219);
+assertEquals("Fr,r", res[1009].exec("France"), 3220);
+assertEquals("*** F,F", res[1009].exec("*** Failers"), 3221);
+assertEquals("Afric,c", res[1009].exec("Africa     "), 3222);
+assertEquals(",", res[1009].exec("ab"), 3223);
+assertEquals(",", res[1009].exec("aBd"), 3224);
+assertEquals("xy,y", res[1009].exec("xy"), 3225);
+assertEquals("xY,Y", res[1009].exec("xY"), 3226);
+assertEquals("ze,e", res[1009].exec("zebra"), 3227);
+assertEquals("Z,Z", res[1009].exec("Zambesi"), 3228);
+assertEquals("*** F,F", res[1009].exec("*** Failers"), 3229);
+assertEquals(",", res[1009].exec("aCD  "), 3230);
+assertEquals("XY  , ", res[1009].exec("XY  "), 3231);
+assertEquals("foo\n,\n", res[1009].exec("foo\nbar"), 3232);
+assertEquals("*** F,F", res[1009].exec("*** Failers"), 3233);
+assertEquals(",", res[1009].exec("bar"), 3234);
+assertEquals(",", res[1009].exec("baz\nbar   "), 3235);
+assertEquals(",", res[1009].exec("barbaz"), 3236);
+assertEquals(",", res[1009].exec("barbarbaz "), 3237);
+assertEquals("koo,o", res[1009].exec("koobarbaz "), 3238);
+assertEquals("*** F,F", res[1009].exec("*** Failers"), 3239);
+assertEquals(",", res[1009].exec("baz"), 3240);
+assertEquals("foo,o", res[1009].exec("foobarbaz "), 3241);
+assertEquals("abc", res[1012].exec("abc"), 3242);
+assertEquals("abc", res[1012].exec("xabcy"), 3243);
+assertEquals("abc", res[1012].exec("ababc"), 3244);
+assertEquals(null, res[1012].exec("*** Failers", 3245));
+assertEquals(null, res[1012].exec("xbc", 3246));
+assertEquals(null, res[1012].exec("axc", 3247));
+assertEquals(null, res[1012].exec("abx", 3248));
+assertEquals("abc", res[1013].exec("abc"), 3249);
+assertEquals("abc", res[1014].exec("abc"), 3250);
+assertEquals("abbc", res[1014].exec("abbc"), 3251);
+assertEquals("abbbbc", res[1014].exec("abbbbc"), 3252);
+assertEquals("a", res[1015].exec("abbbbc"), 3253);
+assertEquals("abbb", res[1016].exec("abbbbc"), 3254);
+assertEquals("abbbbc", res[1017].exec("abbbbc"), 3255);
+assertEquals("abbc", res[1018].exec("abbc"), 3256);
+assertEquals(null, res[1018].exec("*** Failers", 3257));
+assertEquals(null, res[1018].exec("abc", 3258));
+assertEquals(null, res[1018].exec("abq", 3259));
+assertEquals("abbbbc", res[1020].exec("abbbbc"), 3260);
+assertEquals("abbbbc", res[1021].exec("abbbbc"), 3261);
+assertEquals("abbbbc", res[1022].exec("abbbbc"), 3262);
+assertEquals("abbbbc", res[1023].exec("abbbbc"), 3263);
+assertEquals(null, res[1024].exec("*** Failers", 3264));
+assertEquals(null, res[1024].exec("abq", 3265));
+assertEquals(null, res[1024].exec("abbbbc", 3266));
+assertEquals("abbc", res[1025].exec("abbc"), 3267);
+assertEquals("abc", res[1025].exec("abc"), 3268);
+assertEquals("abc", res[1026].exec("abc"), 3269);
+assertEquals("abc", res[1028].exec("abc"), 3270);
+assertEquals("abc", res[1029].exec("abc"), 3271);
+assertEquals("abc", res[1030].exec("abc"), 3272);
+assertEquals(null, res[1030].exec("*** Failers", 3273));
+assertEquals(null, res[1030].exec("abbbbc", 3274));
+assertEquals(null, res[1030].exec("abcc", 3275));
+assertEquals("abc", res[1031].exec("abcc"), 3276);
+assertEquals("abc", res[1033].exec("aabc"), 3277);
+assertEquals(null, res[1033].exec("*** Failers", 3278));
+assertEquals("abc", res[1033].exec("aabc"), 3279);
+assertEquals(null, res[1033].exec("aabcd", 3280));
+assertEquals("", res[1034].exec("abc"), 3281);
+assertEquals("", res[1035].exec("abc"), 3282);
+assertEquals("abc", res[1036].exec("abc"), 3283);
+assertEquals("axc", res[1036].exec("axc"), 3284);
+assertEquals("axyzc", res[1037].exec("axyzc"), 3285);
+assertEquals("abd", res[1038].exec("abd"), 3286);
+assertEquals(null, res[1038].exec("*** Failers", 3287));
+assertEquals(null, res[1038].exec("axyzd", 3288));
+assertEquals(null, res[1038].exec("abc", 3289));
+assertEquals("ace", res[1039].exec("ace"), 3290);
+assertEquals("ac", res[1040].exec("aac"), 3291);
+assertEquals("a-", res[1041].exec("a-"), 3292);
+assertEquals("a-", res[1042].exec("a-"), 3293);
+assertEquals("a]", res[1043].exec("a]"), 3294);
+assertEquals(null, res[1044].exec("a]b", 3295));
+assertEquals("aed", res[1045].exec("aed"), 3296);
+assertEquals(null, res[1045].exec("*** Failers", 3297));
+assertEquals(null, res[1045].exec("abd", 3298));
+assertEquals(null, res[1045].exec("abd", 3299));
+assertEquals("adc", res[1046].exec("adc"), 3300);
+assertEquals(null, res[1047].exec("adc", 3301));
+assertEquals(null, res[1047].exec("*** Failers", 3302));
+assertEquals(null, res[1047].exec("a-c", 3303));
+assertEquals(null, res[1047].exec("a]c", 3304));
+assertEquals("a", res[1048].exec("a-"), 3305);
+assertEquals("a", res[1048].exec("-a"), 3306);
+assertEquals("a", res[1048].exec("-a-"), 3307);
+assertEquals(null, res[1049].exec("*** Failers", 3308));
+assertEquals(null, res[1049].exec("xy", 3309));
+assertEquals(null, res[1049].exec("yz", 3310));
+assertEquals(null, res[1049].exec("xyz", 3311));
+assertEquals("a", res[1050].exec("*** Failers"), 3312);
+assertEquals(null, res[1050].exec("a-", 3313));
+assertEquals(null, res[1050].exec("-a", 3314));
+assertEquals(null, res[1050].exec("-a-", 3315));
+assertEquals("y", res[1051].exec("xy"), 3316);
+assertEquals("y", res[1052].exec("yz"), 3317);
+assertEquals("y", res[1053].exec("xyz"), 3318);
+assertEquals("a", res[1054].exec("a"), 3319);
+assertEquals("-", res[1055].exec("-"), 3320);
+assertEquals("*", res[1055].exec("*** Failers"), 3321);
+assertEquals("-", res[1055].exec("-"), 3322);
+assertEquals(null, res[1055].exec("a", 3323));
+assertEquals("a b", res[1056].exec("a b"), 3324);
+assertEquals("a-b", res[1057].exec("a-b"), 3325);
+assertEquals(null, res[1057].exec("*** Failers", 3326));
+assertEquals("a-b", res[1057].exec("a-b"), 3327);
+assertEquals(null, res[1057].exec("a b", 3328));
+assertEquals("1", res[1058].exec("1"), 3329);
+assertEquals("-", res[1059].exec("-"), 3330);
+assertEquals("*", res[1059].exec("*** Failers"), 3331);
+assertEquals("-", res[1059].exec("-"), 3332);
+assertEquals(null, res[1059].exec("1", 3333));
+assertEquals("a", res[1060].exec("a"), 3334);
+assertEquals("-", res[1061].exec("-"), 3335);
+assertEquals("*", res[1061].exec("*** Failers"), 3336);
+assertEquals("-", res[1061].exec("-"), 3337);
+assertEquals(null, res[1061].exec("a", 3338));
+assertEquals("a b", res[1062].exec("a b"), 3339);
+assertEquals("a-b", res[1063].exec("a-b"), 3340);
+assertEquals(null, res[1063].exec("*** Failers", 3341));
+assertEquals("a-b", res[1063].exec("a-b"), 3342);
+assertEquals(null, res[1063].exec("a b", 3343));
+assertEquals("1", res[1064].exec("1"), 3344);
+assertEquals("-", res[1065].exec("-"), 3345);
+assertEquals("*", res[1065].exec("*** Failers"), 3346);
+assertEquals("-", res[1065].exec("-"), 3347);
+assertEquals(null, res[1065].exec("1", 3348));
+assertEquals("ab", res[1066].exec("abc"), 3349);
+assertEquals("ab", res[1066].exec("abcd"), 3350);
+assertEquals("ef,", res[1067].exec("def"), 3351);
+assertEquals("a(b", res[1069].exec("a(b"), 3352);
+assertEquals(null, res[1069].exec("ab", 3353));
+assertEquals(null, res[1069].exec("a((b", 3354));
+assertEquals(null, res[1070].exec("a\x08", 3355));
+assertEquals("a,a,a", res[1071].exec("abc"), 3356);
+assertEquals("abc,a,c", res[1072].exec("abc"), 3357);
+assertEquals("abc", res[1073].exec("aabbabc"), 3358);
+assertEquals("abc", res[1074].exec("aabbabc"), 3359);
+assertEquals("abc", res[1075].exec("abcabc"), 3360);
+assertEquals("ab,b", res[1076].exec("ab"), 3361);
+assertEquals("ab,b", res[1077].exec("ab"), 3362);
+assertEquals("ab,b", res[1078].exec("ab"), 3363);
+assertEquals("ab,b", res[1079].exec("ab"), 3364);
+assertEquals("a,a", res[1080].exec("ab"), 3365);
+assertEquals("a,a", res[1081].exec("ab"), 3366);
+assertEquals("cde", res[1082].exec("cde"), 3367);
+assertEquals(null, res[1083].exec("*** Failers", 3368));
+assertEquals(null, res[1083].exec("b", 3369));
+assertEquals("abbbcd,c", res[1085].exec("abbbcd"), 3370);
+assertEquals("abcd,a", res[1086].exec("abcd"), 3371);
+assertEquals("e", res[1087].exec("e"), 3372);
+assertEquals("ef,e", res[1088].exec("ef"), 3373);
+assertEquals("abcdefg", res[1089].exec("abcdefg"), 3374);
+assertEquals("ab", res[1090].exec("xabyabbbz"), 3375);
+assertEquals("a", res[1090].exec("xayabbbz"), 3376);
+assertEquals("cde,cd", res[1091].exec("abcde"), 3377);
+assertEquals("hij", res[1092].exec("hij"), 3378);
+assertEquals("ef,", res[1094].exec("abcdef"), 3379);
+assertEquals("bcd,b", res[1095].exec("abcd"), 3380);
+assertEquals("abc,a", res[1096].exec("abc"), 3381);
+assertEquals("abc,bc", res[1097].exec("abc"), 3382);
+assertEquals("abcd,bc,d", res[1098].exec("abcd"), 3383);
+assertEquals("abcd,bc,d", res[1099].exec("abcd"), 3384);
+assertEquals("abcd,b,cd", res[1100].exec("abcd"), 3385);
+assertEquals("adcdcde", res[1101].exec("adcdcde"), 3386);
+assertEquals(null, res[1102].exec("*** Failers", 3387));
+assertEquals(null, res[1102].exec("abcde", 3388));
+assertEquals(null, res[1102].exec("adcdcde", 3389));
+assertEquals("abc,ab", res[1103].exec("abc"), 3390);
+assertEquals("abcd,abc,a,b,d", res[1104].exec("abcd"), 3391);
+assertEquals("alpha", res[1105].exec("alpha"), 3392);
+assertEquals("bh,", res[1106].exec("abh"), 3393);
+assertEquals("effgz,effgz,", res[1107].exec("effgz"), 3394);
+assertEquals("ij,ij,j", res[1107].exec("ij"), 3395);
+assertEquals("effgz,effgz,", res[1107].exec("reffgz"), 3396);
+assertEquals(null, res[1107].exec("*** Failers", 3397));
+assertEquals(null, res[1107].exec("effg", 3398));
+assertEquals(null, res[1107].exec("bcdd", 3399));
+assertEquals("a,a,a,a,a,a,a,a,a,a,a", res[1108].exec("a"), 3400);
+assertEquals("a,a,a,a,a,a,a,a,a,a", res[1109].exec("a"), 3401);
+assertEquals(null, res[1110].exec("*** Failers", 3402));
+assertEquals(null, res[1110].exec("aa", 3403));
+assertEquals(null, res[1110].exec("uh-uh", 3404));
+assertEquals("multiple words", res[1111].exec("multiple words, yeah"), 3405);
+assertEquals("abcde,ab,de", res[1112].exec("abcde"), 3406);
+assertEquals("(a, b),a,b", res[1113].exec("(a, b)"), 3407);
+assertEquals("abcd", res[1115].exec("abcd"), 3408);
+assertEquals("abcd,bc", res[1116].exec("abcd"), 3409);
+assertEquals("ac", res[1117].exec("ac"), 3410);
+assertEquals("ABC", res[1118].exec("ABC"), 3411);
+assertEquals("ABC", res[1118].exec("XABCY"), 3412);
+assertEquals("ABC", res[1118].exec("ABABC"), 3413);
+assertEquals(null, res[1118].exec("*** Failers", 3414));
+assertEquals(null, res[1118].exec("aaxabxbaxbbx", 3415));
+assertEquals(null, res[1118].exec("XBC", 3416));
+assertEquals(null, res[1118].exec("AXC", 3417));
+assertEquals(null, res[1118].exec("ABX", 3418));
+assertEquals("ABC", res[1119].exec("ABC"), 3419);
+assertEquals("ABC", res[1120].exec("ABC"), 3420);
+assertEquals("ABBC", res[1120].exec("ABBC"), 3421);
+assertEquals("ABBBBC", res[1121].exec("ABBBBC"), 3422);
+assertEquals("ABBBBC", res[1122].exec("ABBBBC"), 3423);
+assertEquals("ABBC", res[1123].exec("ABBC"), 3424);
+assertEquals(null, res[1124].exec("*** Failers", 3425));
+assertEquals(null, res[1124].exec("ABC", 3426));
+assertEquals(null, res[1124].exec("ABQ", 3427));
+assertEquals("ABBBBC", res[1126].exec("ABBBBC"), 3428);
+assertEquals("ABBBBC", res[1127].exec("ABBBBC"), 3429);
+assertEquals("ABBBBC", res[1128].exec("ABBBBC"), 3430);
+assertEquals("ABBBBC", res[1129].exec("ABBBBC"), 3431);
+assertEquals(null, res[1130].exec("*** Failers", 3432));
+assertEquals(null, res[1130].exec("ABQ", 3433));
+assertEquals(null, res[1130].exec("ABBBBC", 3434));
+assertEquals("ABBC", res[1131].exec("ABBC"), 3435);
+assertEquals("ABC", res[1131].exec("ABC"), 3436);
+assertEquals("ABC", res[1132].exec("ABC"), 3437);
+assertEquals("ABC", res[1134].exec("ABC"), 3438);
+assertEquals("ABC", res[1135].exec("ABC"), 3439);
+assertEquals("ABC", res[1136].exec("ABC"), 3440);
+assertEquals(null, res[1136].exec("*** Failers", 3441));
+assertEquals(null, res[1136].exec("ABBBBC", 3442));
+assertEquals(null, res[1136].exec("ABCC", 3443));
+assertEquals("ABC", res[1137].exec("ABCC"), 3444);
+assertEquals("ABC", res[1139].exec("AABC"), 3445);
+assertEquals("", res[1140].exec("ABC"), 3446);
+assertEquals("", res[1141].exec("ABC"), 3447);
+assertEquals("ABC", res[1142].exec("ABC"), 3448);
+assertEquals("AXC", res[1142].exec("AXC"), 3449);
+assertEquals("AXYZC", res[1143].exec("AXYZC"), 3450);
+assertEquals(null, res[1144].exec("*** Failers", 3451));
+assertEquals("AABC", res[1144].exec("AABC"), 3452);
+assertEquals(null, res[1144].exec("AXYZD", 3453));
+assertEquals("ABD", res[1145].exec("ABD"), 3454);
+assertEquals("ACE", res[1146].exec("ACE"), 3455);
+assertEquals(null, res[1146].exec("*** Failers", 3456));
+assertEquals(null, res[1146].exec("ABC", 3457));
+assertEquals(null, res[1146].exec("ABD", 3458));
+assertEquals("AC", res[1147].exec("AAC"), 3459);
+assertEquals("A-", res[1148].exec("A-"), 3460);
+assertEquals("A-", res[1149].exec("A-"), 3461);
+assertEquals("A]", res[1150].exec("A]"), 3462);
+assertEquals(null, res[1151].exec("A]B", 3463));
+assertEquals("AED", res[1152].exec("AED"), 3464);
+assertEquals("ADC", res[1153].exec("ADC"), 3465);
+assertEquals(null, res[1153].exec("*** Failers", 3466));
+assertEquals(null, res[1153].exec("ABD", 3467));
+assertEquals(null, res[1153].exec("A-C", 3468));
+assertEquals(null, res[1154].exec("ADC", 3469));
+assertEquals("AB", res[1155].exec("ABC"), 3470);
+assertEquals("AB", res[1155].exec("ABCD"), 3471);
+assertEquals("EF,", res[1156].exec("DEF"), 3472);
+assertEquals(null, res[1157].exec("*** Failers", 3473));
+assertEquals(null, res[1157].exec("A]C", 3474));
+assertEquals(null, res[1157].exec("B", 3475));
+assertEquals("A(B", res[1158].exec("A(B"), 3476);
+assertEquals(null, res[1158].exec("AB", 3477));
+assertEquals(null, res[1158].exec("A((B", 3478));
+assertEquals(null, res[1159].exec("AB", 3479));
+assertEquals("A,A,A", res[1160].exec("ABC"), 3480);
+assertEquals("ABC,A,C", res[1161].exec("ABC"), 3481);
+assertEquals("ABC", res[1162].exec("AABBABC"), 3482);
+assertEquals("ABC", res[1163].exec("AABBABC"), 3483);
+assertEquals("ABC", res[1164].exec("ABCABC"), 3484);
+assertEquals("ABC", res[1165].exec("ABCABC"), 3485);
+assertEquals("ABC", res[1166].exec("ABCABC"), 3486);
+assertEquals("AB,B", res[1167].exec("AB"), 3487);
+assertEquals("AB,B", res[1168].exec("AB"), 3488);
+assertEquals("AB,B", res[1169].exec("AB"), 3489);
+assertEquals("AB,B", res[1170].exec("AB"), 3490);
+assertEquals("A,A", res[1171].exec("AB"), 3491);
+assertEquals("A,A", res[1172].exec("AB"), 3492);
+assertEquals(",", res[1173].exec("AB"), 3493);
+assertEquals("CDE", res[1174].exec("CDE"), 3494);
+assertEquals("ABBBCD,C", res[1177].exec("ABBBCD"), 3495);
+assertEquals("ABCD,A", res[1178].exec("ABCD"), 3496);
+assertEquals("E", res[1179].exec("E"), 3497);
+assertEquals("EF,E", res[1180].exec("EF"), 3498);
+assertEquals("ABCDEFG", res[1181].exec("ABCDEFG"), 3499);
+assertEquals("AB", res[1182].exec("XABYABBBZ"), 3500);
+assertEquals("A", res[1182].exec("XAYABBBZ"), 3501);
+assertEquals("CDE,CD", res[1183].exec("ABCDE"), 3502);
+assertEquals("HIJ", res[1184].exec("HIJ"), 3503);
+assertEquals(null, res[1185].exec("ABCDE", 3504));
+assertEquals("EF,", res[1186].exec("ABCDEF"), 3505);
+assertEquals("BCD,B", res[1187].exec("ABCD"), 3506);
+assertEquals("ABC,A", res[1188].exec("ABC"), 3507);
+assertEquals("ABC,BC", res[1189].exec("ABC"), 3508);
+assertEquals("ABCD,BC,D", res[1190].exec("ABCD"), 3509);
+assertEquals("ABCD,BC,D", res[1191].exec("ABCD"), 3510);
+assertEquals("ABCD,B,CD", res[1192].exec("ABCD"), 3511);
+assertEquals("ADCDCDE", res[1193].exec("ADCDCDE"), 3512);
+assertEquals("ABC,AB", res[1195].exec("ABC"), 3513);
+assertEquals("ABCD,ABC,A,B,D", res[1196].exec("ABCD"), 3514);
+assertEquals("ALPHA", res[1197].exec("ALPHA"), 3515);
+assertEquals("BH,", res[1198].exec("ABH"), 3516);
+assertEquals("EFFGZ,EFFGZ,", res[1199].exec("EFFGZ"), 3517);
+assertEquals("IJ,IJ,J", res[1199].exec("IJ"), 3518);
+assertEquals("EFFGZ,EFFGZ,", res[1199].exec("REFFGZ"), 3519);
+assertEquals(null, res[1199].exec("*** Failers", 3520));
+assertEquals(null, res[1199].exec("ADCDCDE", 3521));
+assertEquals(null, res[1199].exec("EFFG", 3522));
+assertEquals(null, res[1199].exec("BCDD", 3523));
+assertEquals("A,A,A,A,A,A,A,A,A,A,A", res[1200].exec("A"), 3524);
+assertEquals("A,A,A,A,A,A,A,A,A,A", res[1201].exec("A"), 3525);
+assertEquals("A,A", res[1202].exec("A"), 3526);
+assertEquals("C,C", res[1203].exec("C"), 3527);
+assertEquals(null, res[1204].exec("*** Failers", 3528));
+assertEquals(null, res[1204].exec("AA", 3529));
+assertEquals(null, res[1204].exec("UH-UH", 3530));
+assertEquals("MULTIPLE WORDS", res[1205].exec("MULTIPLE WORDS, YEAH"), 3531);
+assertEquals("ABCDE,AB,DE", res[1206].exec("ABCDE"), 3532);
+assertEquals("(A, B),A,B", res[1207].exec("(A, B)"), 3533);
+assertEquals("ABCD", res[1209].exec("ABCD"), 3534);
+assertEquals("ABCD,BC", res[1210].exec("ABCD"), 3535);
+assertEquals("AC", res[1211].exec("AC"), 3536);
+assertEquals("ad", res[1212].exec("abad"), 3537);
+assertEquals("ad", res[1213].exec("abad"), 3538);
+assertEquals("ad", res[1214].exec("abad"), 3539);
+assertEquals("ace,e", res[1215].exec("ace"), 3540);
+assertEquals("ace,e", res[1216].exec("ace"), 3541);
+assertEquals("ace,e", res[1217].exec("ace"), 3542);
+assertEquals("acd,d", res[1217].exec("acdbcdbe"), 3543);
+assertEquals("acdbcdbe,e", res[1218].exec("acdbcdbe"), 3544);
+assertEquals("acdb,b", res[1219].exec("acdbcdbe"), 3545);
+assertEquals("acdbcdb,b", res[1220].exec("acdbcdbe"), 3546);
+assertEquals("acdbcd,d", res[1221].exec("acdbcdbe"), 3547);
+assertEquals("foobar,bar,,bar", res[1222].exec("foobar"), 3548);
+assertEquals("acdbcdbe,e", res[1223].exec("acdbcdbe"), 3549);
+assertEquals("acdbcdbe,e", res[1224].exec("acdbcdbe"), 3550);
+assertEquals("acdbcdbe,e", res[1225].exec("acdbcdbe"), 3551);
+assertEquals("acdbcdb,b", res[1226].exec("acdbcdbe"), 3552);
+assertEquals("acdbcdbe,e", res[1227].exec("acdbcdbe"), 3553);
+assertEquals("acdbcdb,b", res[1228].exec("acdbcdbe"), 3554);
+assertEquals("ace,c,e", res[1229].exec("ace"), 3555);
+assertEquals("AB,A", res[1230].exec("AB"), 3556);
+assertEquals(".,.,", res[1231].exec("."), 3557);
+assertEquals("<&", res[1232].exec("<&OUT"), 3558);
+assertEquals("foobar,,,,b,a,r", res[1233].exec("foobar"), 3559);
+assertEquals(",,,,,,", res[1233].exec("ab"), 3560);
+assertEquals(",,,,,,", res[1233].exec("*** Failers"), 3561);
+assertEquals(",,,,,,", res[1233].exec("cb"), 3562);
+assertEquals(",,,,,,", res[1233].exec("b"), 3563);
+assertEquals(",,,,,,", res[1233].exec("ab"), 3564);
+assertEquals(",,,,,,", res[1233].exec("b"), 3565);
+assertEquals(",,,,,,", res[1233].exec("b"), 3566);
+assertEquals("aba", res[1234].exec("aba"), 3567);
+assertEquals("a", res[1235].exec("aba"), 3568);
+assertEquals(",", res[1236].exec("abc"), 3569);
+assertEquals("aax,a", res[1237].exec("aax"), 3570);
+assertEquals("aax,a,a", res[1238].exec("aax"), 3571);
+assertEquals("aax,a,a", res[1239].exec("aax"), 3572);
+assertEquals("ab,", res[1240].exec("cab"), 3573);
+assertEquals("ab,", res[1241].exec("cab"), 3574);
+assertEquals("ab,", res[1241].exec("ab"), 3575);
+assertEquals("ab,", res[1241].exec("ab"), 3576);
+assertEquals(null, res[1241].exec("Ab", 3577));
+assertEquals(null, res[1241].exec("Ab", 3578));
+assertEquals(null, res[1241].exec("*** Failers", 3579));
+assertEquals(null, res[1241].exec("cb", 3580));
+assertEquals(null, res[1241].exec("aB", 3581));
+assertEquals("ab,", res[1241].exec("ab"), 3582);
+assertEquals("ab,", res[1241].exec("ab"), 3583);
+assertEquals(null, res[1241].exec("Ab", 3584));
+assertEquals(null, res[1241].exec("Ab", 3585));
+assertEquals(null, res[1241].exec("*** Failers", 3586));
+assertEquals(null, res[1241].exec("aB", 3587));
+assertEquals(null, res[1241].exec("aB", 3588));
+assertEquals("ab,", res[1241].exec("ab"), 3589);
+assertEquals("ab,", res[1241].exec("ab"), 3590);
+assertEquals(null, res[1241].exec("aB", 3591));
+assertEquals(null, res[1241].exec("aB", 3592));
+assertEquals(null, res[1241].exec("*** Failers", 3593));
+assertEquals(null, res[1241].exec("aB", 3594));
+assertEquals(null, res[1241].exec("Ab", 3595));
+assertEquals(null, res[1241].exec("aB", 3596));
+assertEquals(null, res[1241].exec("aB", 3597));
+assertEquals(null, res[1241].exec("*** Failers", 3598));
+assertEquals(null, res[1241].exec("Ab", 3599));
+assertEquals(null, res[1241].exec("AB", 3600));
+assertEquals("ab,", res[1241].exec("ab"), 3601);
+assertEquals("ab,", res[1241].exec("ab"), 3602);
+assertEquals(null, res[1241].exec("aB", 3603));
+assertEquals(null, res[1241].exec("aB", 3604));
+assertEquals(null, res[1241].exec("*** Failers", 3605));
+assertEquals(null, res[1241].exec("AB", 3606));
+assertEquals(null, res[1241].exec("Ab", 3607));
+assertEquals(null, res[1241].exec("aB", 3608));
+assertEquals(null, res[1241].exec("aB", 3609));
+assertEquals(null, res[1241].exec("*** Failers", 3610));
+assertEquals(null, res[1241].exec("Ab", 3611));
+assertEquals(null, res[1241].exec("AB", 3612));
+assertEquals(null, res[1241].exec("*** Failers", 3613));
+assertEquals(null, res[1241].exec("AB", 3614));
+assertEquals(null, res[1241].exec("a\nB", 3615));
+assertEquals(null, res[1241].exec("a\nB", 3616));
+assertEquals("cabbbb", res[1242].exec("cabbbb"), 3617);
+assertEquals("caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", res[1243].exec("caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), 3618);
+assertEquals("foobar1234baz", res[1244].exec("foobar1234baz"), 3619);
+assertEquals("x~~,~~", res[1245].exec("x~~"), 3620);
+assertEquals("aaac", res[1246].exec("aaac"), 3621);
+assertEquals("aaac", res[1247].exec("aaac"), 3622);
+assertEquals(null, res[1247].exec("*** Failers", 3623));
+assertEquals(null, res[1247].exec("B\nB", 3624));
+assertEquals(null, res[1247].exec("dbcb", 3625));
+assertEquals(null, res[1247].exec("dbaacb", 3626));
+assertEquals(null, res[1247].exec("dbaacb", 3627));
+assertEquals(null, res[1247].exec("cdaccb", 3628));
+assertEquals(null, res[1248].exec("*** Failers", 3629));
+assertEquals(null, res[1248].exec("dbcb", 3630));
+assertEquals(null, res[1248].exec("a--", 3631));
+assertEquals(null, res[1248].exec("a\nb\nc\n", 3632));
+assertEquals(null, res[1248].exec("a\nb\nc\n", 3633));
+assertEquals(null, res[1248].exec("a\nb\n", 3634));
+assertEquals(null, res[1248].exec("a\nb\n", 3635));
+assertEquals(null, res[1248].exec("a\nb\n", 3636));
+assertEquals(null, res[1248].exec("a\nb\n", 3637));
+assertEquals(null, res[1248].exec("a\nb\nc\n", 3638));
+assertEquals(null, res[1248].exec("a\nb\nc\n", 3639));
+assertEquals(null, res[1248].exec("a\nb\nc\n", 3640));
+assertEquals(null, res[1248].exec("a\nb\nc\n", 3641));
+assertEquals(null, res[1250].exec("*** Failers", 3642));
+assertEquals(null, res[1250].exec("a\nb\nc\n", 3643));
+assertEquals(null, res[1250].exec("a\nb\nc\n", 3644));
+assertEquals(null, res[1250].exec("a\nb\nc\n", 3645));
+assertEquals(null, res[1250].exec("a", 3646));
+assertEquals(null, res[1250].exec("*** Failers", 3647));
+assertEquals(null, res[1250].exec("a", 3648));
+assertEquals(null, res[1250].exec("a", 3649));
+assertEquals(null, res[1250].exec("a", 3650));
+assertEquals("one:,one:", res[1251].exec("one:"), 3651);
+assertEquals(null, res[1251].exec("a", 3652));
+assertEquals("abcd,,abcd", res[1252].exec("abcd"), 3653);
+assertEquals("xy:z:::abcd,xy:z:::,abcd", res[1252].exec("xy:z:::abcd"), 3654);
+assertEquals("aexyc,c", res[1253].exec("aexycd"), 3655);
+assertEquals("aab,aa", res[1254].exec("caab"), 3656);
+assertEquals("abcd,,abcd", res[1255].exec("abcd"), 3657);
+assertEquals("xy:z:::abcd,xy:z:::,abcd", res[1255].exec("xy:z:::abcd"), 3658);
+assertEquals("Failers,,Failers", res[1255].exec("*** Failers"), 3659);
+assertEquals(null, res[1255].exec("abcd:", 3660));
+assertEquals(null, res[1255].exec("abcd:", 3661));
+assertEquals("aexyc,c", res[1256].exec("aexycd"), 3662);
+assertEquals(null, res[1257].exec("aaab", 3663));
+assertEquals(":[,:[", res[1258].exec("a:[b]:"), 3664);
+assertEquals("=[,=[", res[1259].exec("a=[b]="), 3665);
+assertEquals(".[,.[", res[1260].exec("a.[b]."), 3666);
+assertEquals(null, res[1260].exec("aaab", 3667));
+assertEquals(null, res[1260].exec("aaab", 3668));
+assertEquals(null, res[1260].exec("((abc(ade)ufh()()x", 3669));
+assertEquals(null, res[1261].exec("*** Failers", 3670));
+assertEquals(null, res[1261].exec("aaab", 3671));
+assertEquals(null, res[1261].exec("a\nb\n", 3672));
+assertEquals(null, res[1262].exec("a\nb\n", 3673));
+assertEquals(null, res[1264].exec("a\nb", 3674));
+assertEquals(null, res[1265].exec("a\nb", 3675));
+assertEquals(null, res[1265].exec("*** Failers", 3676));
+assertEquals(null, res[1265].exec("alphabetabcd", 3677));
+assertEquals(null, res[1265].exec("endingwxyz", 3678));
+assertEquals(null, res[1265].exec("*** Failers", 3679));
+assertEquals(null, res[1265].exec("a rather long string that doesn't end with one of them", 3680));
+assertEquals(null, res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark otherword", 3681));
+assertEquals(null, res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark", 3682));
+assertEquals(null, res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope", 3683));
+assertEquals(null, res[1265].exec("999foo", 3684));
+assertEquals(null, res[1265].exec("123999foo ", 3685));
+assertEquals(null, res[1265].exec("*** Failers", 3686));
+assertEquals(null, res[1265].exec("123abcfoo", 3687));
+assertEquals(null, res[1265].exec("999foo", 3688));
+assertEquals(null, res[1265].exec("123999foo ", 3689));
+assertEquals(null, res[1265].exec("*** Failers", 3690));
+assertEquals(null, res[1265].exec("123abcfoo", 3691));
+assertEquals(null, res[1265].exec("123abcfoo", 3692));
+assertEquals(null, res[1265].exec("123456foo ", 3693));
+assertEquals(null, res[1265].exec("*** Failers", 3694));
+assertEquals(null, res[1265].exec("123999foo  ", 3695));
+assertEquals(null, res[1265].exec("123abcfoo   ", 3696));
+assertEquals(null, res[1265].exec("123456foo ", 3697));
+assertEquals(null, res[1265].exec("*** Failers", 3698));
+assertEquals(null, res[1265].exec("123999foo  ", 3699));
+assertEquals("ZA,A,", res[1266].exec("ZABCDEFG"), 3700);
+assertEquals("ZA,A,", res[1267].exec("ZABCDEFG"), 3701);
+assertEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3702);
+assertEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3703);
+assertEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3704);
+assertEquals("a", res[1269].exec("abbab"), 3705);
+assertEquals("", res[1269].exec("abcde"), 3706);
+assertEquals("", res[1269].exec("-things"), 3707);
+assertEquals("", res[1269].exec("0digit"), 3708);
+assertEquals("", res[1269].exec("*** Failers"), 3709);
+assertEquals("", res[1269].exec("bcdef    "), 3710);
+assertEquals("a", res[1270].exec("abcde"), 3711);
+assertEquals("-", res[1270].exec("-things"), 3712);
+assertEquals("0", res[1270].exec("0digit"), 3713);
+assertEquals(null, res[1270].exec("*** Failers", 3714));
+assertEquals(null, res[1270].exec("bcdef    ", 3715));
+assertEquals(null, res[1271].exec("> \x09\n\x0c\x0d\x0b<", 3716));
+assertEquals(null, res[1271].exec(" ", 3717));
+assertEquals(null, res[1272].exec("> \x09\n\x0c\x0d\x0b<", 3718));
+assertEquals(null, res[1272].exec(" ", 3719));
+assertEquals(" \x09\n\x0c\x0d\x0b", res[1273].exec("> \x09\n\x0c\x0d\x0b<"), 3720);
+assertEquals(" ", res[1273].exec(" "), 3721);
+assertEquals(" \x09\n\x0c\x0d\x0b", res[1274].exec("> \x09\n\x0c\x0d\x0b<"), 3722);
+assertEquals(" ", res[1274].exec(" "), 3723);
+assertEquals(null, res[1275].exec("ab", 3724));
+assertEquals(null, res[1278].exec("abcabcabc", 3725));
+assertEquals(null, res[1278].exec("abc(*+|abc ", 3726));
+assertEquals(null, res[1279].exec("abc abcabc", 3727));
+assertEquals(null, res[1279].exec("*** Failers", 3728));
+assertEquals(null, res[1279].exec("abcabcabc  ", 3729));
+assertEquals(null, res[1280].exec("abc#not comment\n    literal     ", 3730));
+assertEquals(null, res[1281].exec("abc#not comment\n    literal     ", 3731));
+assertEquals(null, res[1282].exec("abc#not comment\n    literal     ", 3732));
+assertEquals(null, res[1283].exec("abc#not comment\n    literal     ", 3733));
+assertEquals(null, res[1284].exec("abc\\$xyz", 3734));
+assertEquals(null, res[1285].exec("abc$xyz", 3735));
+assertEquals(null, res[1286].exec("abc", 3736));
+assertEquals(null, res[1286].exec("*** Failers", 3737));
+assertEquals(null, res[1286].exec("xyzabc  ", 3738));
+assertEquals(null, res[1287].exec("abc1abc2xyzabc3", 3739));
+assertEquals("abc1", res[1288].exec("abc1abc2xyzabc3 "), 3740);
+assertEquals(null, res[1288].exec("XabcdY", 3741));
+assertEquals(null, res[1288].exec("*** Failers ", 3742));
+assertEquals(null, res[1288].exec("Xa b c d Y ", 3743));
+assertEquals("abcY", res[1288].exec("XabcY"), 3744);
+assertEquals(null, res[1288].exec("AxyzB ", 3745));
+assertEquals(null, res[1288].exec("XabCY", 3746));
+assertEquals(null, res[1288].exec("*** Failers", 3747));
+assertEquals("abcY", res[1288].exec("XabcY  "), 3748);
+assertEquals(null, res[1288].exec("abCE", 3749));
+assertEquals(null, res[1288].exec("DE", 3750));
+assertEquals(null, res[1288].exec("*** Failers", 3751));
+assertEquals("abcE", res[1288].exec("abcE"), 3752);
+assertEquals(null, res[1288].exec("abCe  ", 3753));
+assertEquals(null, res[1288].exec("dE", 3754));
+assertEquals(null, res[1288].exec("De    ", 3755));
+assertEquals(null, res[1289].exec("z", 3756));
+assertEquals(null, res[1289].exec("a", 3757));
+assertEquals(null, res[1289].exec("-", 3758));
+assertEquals(null, res[1289].exec("d", 3759));
+assertEquals(null, res[1289].exec("] ", 3760));
+assertEquals(null, res[1289].exec("*** Failers", 3761));
+assertEquals(null, res[1289].exec("b     ", 3762));
+assertEquals("z", res[1290].exec("z"), 3763);
+assertEquals("C", res[1290].exec("C "), 3764);
+assertEquals("M", res[1291].exec("M "), 3765);
+assertEquals(null, res[1292].exec("", 3766));
+assertEquals(null, res[1292].exec("REGular", 3767));
+assertEquals(null, res[1292].exec("regulaer", 3768));
+assertEquals(null, res[1292].exec("Regex  ", 3769));
+assertEquals(null, res[1292].exec("regul\ufffdr ", 3770));
+assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3771));
+assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3772));
+assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3773));
+assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3774));
+assertEquals(null, res[1292].exec("\x84XAZXB", 3775));
+assertEquals(null, res[1292].exec("123a", 3776));
+assertEquals(null, res[1292].exec("ac", 3777));
+assertEquals("b,", res[1292].exec("bbbbc"), 3778);
+assertEquals("ab,a", res[1292].exec("abc"), 3779);
+assertEquals(null, res[1292].exec("*** Failers", 3780));
+assertEquals("b,", res[1292].exec("bca"), 3781);
+assertEquals(null, res[1292].exec("", 3782));
+assertEquals("ab,a", res[1292].exec("abc"), 3783);
+assertEquals(null, res[1292].exec("*** Failers", 3784));
+assertEquals("b,", res[1292].exec("bca"), 3785);
+assertEquals("ab,a", res[1292].exec("abc"), 3786);
+assertEquals(null, res[1292].exec("*** Failers", 3787));
+assertEquals(null, res[1292].exec("def  ", 3788));
+assertEquals(null, res[1292].exec("", 3789));
+assertEquals("ab,a", res[1292].exec("abc"), 3790);
+assertEquals(null, res[1292].exec("*** Failers", 3791));
+assertEquals(null, res[1292].exec("def  ", 3792));
+assertEquals(null, res[1292].exec("", 3793));
+assertEquals("line\nbreak", res[1293].exec("this is a line\nbreak"), 3794);
+assertEquals("line\nbreak", res[1293].exec("line one\nthis is a line\nbreak in the second line "), 3795);
+assertEquals("line\nbreak", res[1294].exec("this is a line\nbreak"), 3796);
+assertEquals(null, res[1294].exec("** Failers ", 3797));
+assertEquals("line\nbreak", res[1294].exec("line one\nthis is a line\nbreak in the second line "), 3798);
+assertEquals("line\nbreak", res[1295].exec("this is a line\nbreak"), 3799);
+assertEquals(null, res[1295].exec("** Failers ", 3800));
+assertEquals("line\nbreak", res[1295].exec("line one\nthis is a line\nbreak in the second line "), 3801);
+assertEquals(null, res[1296].exec("123P", 3802));
+assertEquals(null, res[1296].exec("a4PR", 3803));
+assertEquals(null, res[1297].exec("123P", 3804));
+assertEquals(null, res[1297].exec("4PR", 3805));
+assertEquals("", res[1298].exec("a\nb\nc\n"), 3806);
+assertEquals("", res[1298].exec(" "), 3807);
+assertEquals("", res[1298].exec("A\nC\nC\n "), 3808);
+assertEquals("", res[1298].exec("AB"), 3809);
+assertEquals("", res[1298].exec("aB  "), 3810);
+assertEquals("", res[1298].exec("AB"), 3811);
+assertEquals("", res[1298].exec("aB  "), 3812);
+assertEquals("", res[1298].exec("AB"), 3813);
+assertEquals("", res[1298].exec("aB  "), 3814);
+assertEquals("", res[1298].exec("AB"), 3815);
+assertEquals("", res[1298].exec("aB  "), 3816);
+assertEquals("Content-Type:xxxxxyyy ", res[1299].exec("Content-Type:xxxxxyyy "), 3817);
+assertEquals("Content-Type:xxxxxyyyz", res[1300].exec("Content-Type:xxxxxyyyz"), 3818);
+assertEquals("Content-Type:xxxyyy ", res[1301].exec("Content-Type:xxxyyy "), 3819);
+assertEquals("Content-Type:xxxyyyz", res[1302].exec("Content-Type:xxxyyyz"), 3820);
+assertEquals("abc", res[1303].exec("xyz\nabc"), 3821);
+assertEquals("abc", res[1303].exec("xyz\nabc<lf>"), 3822);
+assertEquals("abc", res[1303].exec("xyz\x0d\nabc<lf>"), 3823);
+assertEquals("abc", res[1303].exec("xyz\x0dabc<cr>"), 3824);
+assertEquals("abc", res[1303].exec("xyz\x0d\nabc<crlf>"), 3825);
+assertEquals(null, res[1303].exec("** Failers ", 3826));
+assertEquals("abc", res[1303].exec("xyz\nabc<cr>"), 3827);
+assertEquals("abc", res[1303].exec("xyz\x0d\nabc<cr>"), 3828);
+assertEquals("abc", res[1303].exec("xyz\nabc<crlf>"), 3829);
+assertEquals("abc", res[1303].exec("xyz\x0dabc<crlf>"), 3830);
+assertEquals("abc", res[1303].exec("xyz\x0dabc<lf>"), 3831);
+assertEquals("abc", res[1304].exec("xyzabc"), 3832);
+assertEquals("abc", res[1304].exec("xyzabc\n "), 3833);
+assertEquals("abc", res[1304].exec("xyzabc\npqr "), 3834);
+assertEquals("abc", res[1304].exec("xyzabc\x0d<cr> "), 3835);
+assertEquals("abc", res[1304].exec("xyzabc\x0dpqr<cr> "), 3836);
+assertEquals("abc", res[1304].exec("xyzabc\x0d\n<crlf> "), 3837);
+assertEquals("abc", res[1304].exec("xyzabc\x0d\npqr<crlf> "), 3838);
+assertEquals(null, res[1304].exec("** Failers", 3839));
+assertEquals("abc", res[1304].exec("xyzabc\x0d "), 3840);
+assertEquals("abc", res[1304].exec("xyzabc\x0dpqr "), 3841);
+assertEquals("abc", res[1304].exec("xyzabc\x0d\n "), 3842);
+assertEquals("abc", res[1304].exec("xyzabc\x0d\npqr "), 3843);
+assertEquals("abc", res[1305].exec("xyz\x0dabcdef"), 3844);
+assertEquals("abc", res[1305].exec("xyz\nabcdef<lf>"), 3845);
+assertEquals(null, res[1305].exec("** Failers  ", 3846));
+assertEquals("abc", res[1305].exec("xyz\nabcdef"), 3847);
+assertEquals(null, res[1305].exec("   ", 3848));
+assertEquals("abc", res[1306].exec("xyz\nabcdef"), 3849);
+assertEquals("abc", res[1306].exec("xyz\x0dabcdef<cr>"), 3850);
+assertEquals(null, res[1306].exec("** Failers  ", 3851));
+assertEquals("abc", res[1306].exec("xyz\x0dabcdef"), 3852);
+assertEquals(null, res[1306].exec("   ", 3853));
+assertEquals("abc", res[1307].exec("xyz\x0d\nabcdef"), 3854);
+assertEquals("abc", res[1307].exec("xyz\x0dabcdef<cr>"), 3855);
+assertEquals(null, res[1307].exec("** Failers  ", 3856));
+assertEquals("abc", res[1307].exec("xyz\x0dabcdef"), 3857);
+assertEquals("abc", res[1308].exec("abc\ndef"), 3858);
+assertEquals("abc", res[1308].exec("abc\x0ddef"), 3859);
+assertEquals("abc", res[1308].exec("abc\x0d\ndef"), 3860);
+assertEquals("<cr>abc", res[1308].exec("<cr>abc\ndef"), 3861);
+assertEquals("<cr>abc", res[1308].exec("<cr>abc\x0ddef"), 3862);
+assertEquals("<cr>abc", res[1308].exec("<cr>abc\x0d\ndef"), 3863);
+assertEquals("<crlf>abc", res[1308].exec("<crlf>abc\ndef"), 3864);
+assertEquals("<crlf>abc", res[1308].exec("<crlf>abc\x0ddef"), 3865);
+assertEquals("<crlf>abc", res[1308].exec("<crlf>abc\x0d\ndef"), 3866);
+assertEquals(null, res[1309].exec("abc\ndef", 3867));
+assertEquals(null, res[1309].exec("abc\x0ddef", 3868));
+assertEquals(null, res[1309].exec("abc\x0d\ndef", 3869));
+assertEquals("abc=xyz\\,", res[1310].exec("abc=xyz\\\npqr"), 3870);
+assertEquals("aaaa,a,", res[1311].exec("aaaa"), 3871);
+assertEquals("aaaa", res[1312].exec("aaaa"), 3872);
+assertEquals("aaaa,a,", res[1313].exec("aaaa"), 3873);
+assertEquals("aaaa", res[1314].exec("aaaa"), 3874);
+assertEquals(null, res[1317].exec("a\x0db", 3875));
+assertEquals(null, res[1317].exec("a\nb<cr> ", 3876));
+assertEquals(null, res[1317].exec("** Failers", 3877));
+assertEquals(null, res[1317].exec("a\nb", 3878));
+assertEquals(null, res[1317].exec("a\nb<any>", 3879));
+assertEquals(null, res[1317].exec("a\x0db<cr>   ", 3880));
+assertEquals(null, res[1317].exec("a\x0db<any>   ", 3881));
+assertEquals("abc1", res[1318].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 3882);
+assertEquals("abc1", res[1319].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 3883);
+assertEquals(null, res[1320].exec("a\nb", 3884));
+assertEquals(null, res[1320].exec("a\x0db", 3885));
+assertEquals(null, res[1320].exec("a\x0d\nb", 3886));
+assertEquals(null, res[1320].exec("a\x0bb", 3887));
+assertEquals(null, res[1320].exec("a\x0cb", 3888));
+assertEquals(null, res[1320].exec("a\x85b   ", 3889));
+assertEquals(null, res[1320].exec("** Failers", 3890));
+assertEquals(null, res[1320].exec("a\n\x0db    ", 3891));
+assertEquals("ab", res[1321].exec("ab"), 3892);
+assertEquals(null, res[1321].exec("a\nb", 3893));
+assertEquals(null, res[1321].exec("a\x0db", 3894));
+assertEquals(null, res[1321].exec("a\x0d\nb", 3895));
+assertEquals(null, res[1321].exec("a\x0bb", 3896));
+assertEquals(null, res[1321].exec("a\x0cb", 3897));
+assertEquals(null, res[1321].exec("a\x85b   ", 3898));
+assertEquals(null, res[1321].exec("a\n\x0db    ", 3899));
+assertEquals(null, res[1321].exec("a\n\x0d\x85\x0cb ", 3900));
+assertEquals(null, res[1322].exec("a\nb", 3901));
+assertEquals(null, res[1322].exec("a\x0db", 3902));
+assertEquals(null, res[1322].exec("a\x0d\nb", 3903));
+assertEquals(null, res[1322].exec("a\x0bb", 3904));
+assertEquals(null, res[1322].exec("a\x0cb", 3905));
+assertEquals(null, res[1322].exec("a\x85b   ", 3906));
+assertEquals(null, res[1322].exec("a\n\x0db    ", 3907));
+assertEquals(null, res[1322].exec("a\n\x0d\x85\x0cb ", 3908));
+assertEquals(null, res[1322].exec("** Failers", 3909));
+assertEquals(null, res[1322].exec("ab  ", 3910));
+assertEquals(null, res[1323].exec("a\nb", 3911));
+assertEquals(null, res[1323].exec("a\n\x0db", 3912));
+assertEquals(null, res[1323].exec("a\n\x0d\x85b", 3913));
+assertEquals(null, res[1323].exec("a\x0d\n\x0d\nb ", 3914));
+assertEquals(null, res[1323].exec("a\x0d\n\x0d\n\x0d\nb ", 3915));
+assertEquals(null, res[1323].exec("a\n\x0d\n\x0db", 3916));
+assertEquals(null, res[1323].exec("a\n\n\x0d\nb ", 3917));
+assertEquals(null, res[1323].exec("** Failers", 3918));
+assertEquals(null, res[1323].exec("a\n\n\n\x0db", 3919));
+assertEquals(null, res[1323].exec("a\x0d", 3920));
+assertEquals("aRb", res[1324].exec("aRb"), 3921);
+assertEquals(null, res[1324].exec("** Failers", 3922));
+assertEquals(null, res[1324].exec("a\nb  ", 3923));
+assertEquals("afoo", res[1325].exec("afoo"), 3924);
+assertEquals(null, res[1325].exec("** Failers ", 3925));
+assertEquals(null, res[1325].exec("\x0d\nfoo ", 3926));
+assertEquals(null, res[1325].exec("\nfoo ", 3927));
+assertEquals("afoo", res[1326].exec("afoo"), 3928);
+assertEquals(null, res[1326].exec("\nfoo ", 3929));
+assertEquals(null, res[1326].exec("** Failers ", 3930));
+assertEquals(null, res[1326].exec("\x0d\nfoo ", 3931));
+assertEquals("afoo", res[1327].exec("afoo"), 3932);
+assertEquals(null, res[1327].exec("** Failers ", 3933));
+assertEquals(null, res[1327].exec("\nfoo ", 3934));
+assertEquals(null, res[1327].exec("\x0d\nfoo ", 3935));
+assertEquals("afoo", res[1328].exec("afoo"), 3936);
+assertEquals(null, res[1328].exec("\x0d\nfoo ", 3937));
+assertEquals(null, res[1328].exec("\nfoo ", 3938));
+assertEquals("", res[1329].exec("abc\x0d\x0dxyz"), 3939);
+assertEquals("", res[1329].exec("abc\n\x0dxyz  "), 3940);
+assertEquals(null, res[1329].exec("** Failers ", 3941));
+assertEquals("", res[1329].exec("abc\x0d\nxyz"), 3942);
+assertEquals("X", res[1330].exec("XABC"), 3943);
+assertEquals(null, res[1330].exec("** Failers ", 3944));
+assertEquals("X", res[1330].exec("XABCB"), 3945);
+assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3946));
+assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3947));
+assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3948));
 assertThrows("var re = /(?|(abc)|(xyz))/;", 3949);
 assertThrows("var re = /(x)(?|(abc)|(xyz))(x)/;", 3950);
-assertNull(res[1330].exec("xabcx", 3951));
-assertNull(res[1330].exec("xxyzx ", 3952));
+assertEquals(null, res[1330].exec("xabcx", 3951));
+assertEquals(null, res[1330].exec("xxyzx ", 3952));
 assertThrows("var re = /(x)(?|(abc)(pqr)|(xyz))(x)/;", 3953);
-assertNull(res[1330].exec("xabcpqrx", 3954));
-assertNull(res[1330].exec("xxyzx ", 3955));
-assertNull(res[1330].exec("abcabc", 3956));
-assertNull(res[1330].exec("xyzabc ", 3957));
-assertNull(res[1330].exec("** Failers ", 3958));
-assertNull(res[1330].exec("xyzxyz ", 3959));
-assertNull(res[1331].exec("X X\n", 3960));
-assertNull(res[1331].exec("X\x09X\x0b", 3961));
-assertNull(res[1331].exec("** Failers", 3962));
-assertNull(res[1331].exec("\xa0 X\n   ", 3963));
-assertNull(res[1332].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 3964));
-assertNull(res[1332].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 3965));
-assertNull(res[1332].exec("\x09 \xa0\n\x0b\x0c", 3966));
-assertNull(res[1332].exec("** Failers ", 3967));
-assertNull(res[1332].exec("\x09 \xa0\n\x0b", 3968));
-assertNull(res[1332].exec(" ", 3969));
-assertNull(res[1333].exec("XY  ABCDE", 3970));
-assertNull(res[1333].exec("XY  PQR ST ", 3971));
-assertNull(res[1334].exec("XY  AB    PQRS", 3972));
-assertNull(res[1335].exec(">XNNNYZ", 3973));
-assertNull(res[1335].exec(">  X NYQZ", 3974));
-assertNull(res[1335].exec("** Failers", 3975));
-assertNull(res[1335].exec(">XYZ   ", 3976));
-assertNull(res[1335].exec(">  X NY Z", 3977));
-assertNull(res[1336].exec(">XY\nZ\nA\x0bNN\x0c", 3978));
-assertNull(res[1336].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 3979));
-assertNull(res[1337].exec("\x0d\nA", 3980));
-assertToStringEquals("\nA", res[1338].exec("\x0d\nA "), 3981);
-assertToStringEquals("\nA", res[1339].exec("\x0d\nA "), 3982);
-assertToStringEquals("\nA,\n", res[1340].exec("\x0d\nA "), 3983);
-assertNull(res[1341].exec("a\x0db", 3984));
-assertNull(res[1341].exec("a\nb", 3985));
-assertNull(res[1341].exec("a\x0d\nb", 3986));
-assertNull(res[1341].exec("** Failers", 3987));
-assertNull(res[1341].exec("a\x85b", 3988));
-assertNull(res[1341].exec("a\x0bb     ", 3989));
-assertNull(res[1342].exec("a\x0db", 3990));
-assertNull(res[1342].exec("a\nb", 3991));
-assertNull(res[1342].exec("a\x0d\nb", 3992));
-assertNull(res[1342].exec("a\x85b", 3993));
-assertNull(res[1342].exec("a\x0bb     ", 3994));
-assertNull(res[1342].exec("** Failers ", 3995));
-assertNull(res[1342].exec("a\x85b<bsr_anycrlf>", 3996));
-assertNull(res[1342].exec("a\x0bb<bsr_anycrlf>", 3997));
-assertNull(res[1343].exec("a\x0db", 3998));
-assertNull(res[1343].exec("a\nb", 3999));
-assertNull(res[1343].exec("a\x0d\nb", 4000));
-assertNull(res[1343].exec("** Failers", 4001));
-assertNull(res[1343].exec("a\x85b", 4002));
-assertNull(res[1343].exec("a\x0bb     ", 4003));
-assertNull(res[1344].exec("a\x0db", 4004));
-assertNull(res[1344].exec("a\nb", 4005));
-assertNull(res[1344].exec("a\x0d\nb", 4006));
-assertNull(res[1344].exec("a\x85b", 4007));
-assertNull(res[1344].exec("a\x0bb     ", 4008));
-assertNull(res[1344].exec("** Failers ", 4009));
-assertNull(res[1344].exec("a\x85b<bsr_anycrlf>", 4010));
-assertNull(res[1344].exec("a\x0bb<bsr_anycrlf>", 4011));
-assertNull(res[1345].exec("a\x0d\n\nb", 4012));
-assertNull(res[1345].exec("a\n\x0d\x0db", 4013));
-assertNull(res[1345].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 4014));
-assertNull(res[1345].exec("** Failers", 4015));
-assertNull(res[1345].exec("a\x8585b", 4016));
-assertNull(res[1345].exec("a\x0b\x00bb     ", 4017));
-assertNull(res[1346].exec("a\x0d\x0db", 4018));
-assertNull(res[1346].exec("a\n\n\nb", 4019));
-assertNull(res[1346].exec("a\x0d\n\n\x0d\x0db", 4020));
-assertNull(res[1346].exec("a\x8585b", 4021));
-assertNull(res[1346].exec("a\x0b\x00bb     ", 4022));
-assertNull(res[1346].exec("** Failers ", 4023));
-assertNull(res[1346].exec("a\x0d\x0d\x0d\x0d\x0db ", 4024));
-assertNull(res[1346].exec("a\x8585b<bsr_anycrlf>", 4025));
-assertNull(res[1346].exec("a\x0b\x00bb<bsr_anycrlf>", 4026));
-assertToStringEquals("abc", res[1347].exec("abc "), 4027);
-assertNull(res[1348].exec("** Failers", 4028));
-assertNull(res[1348].exec("ab", 4029));
-assertNull(res[1349].exec("** Failers", 4030));
-assertNull(res[1349].exec("ab ", 4031));
-assertNull(res[1349].exec("** Failers", 4032));
-assertNull(res[1349].exec("ab ", 4033));
-assertToStringEquals("aXb", res[1350].exec("aXb"), 4034);
-assertToStringEquals("a\nb", res[1350].exec("a\nb "), 4035);
-assertNull(res[1350].exec("** Failers", 4036));
-assertNull(res[1350].exec("ab  ", 4037));
-assertToStringEquals("aXb", res[1351].exec("aXb"), 4038);
-assertToStringEquals("a\nX\nXb", res[1351].exec("a\nX\nXb "), 4039);
-assertNull(res[1351].exec("** Failers", 4040));
-assertNull(res[1351].exec("ab  ", 4041));
-assertNull(res[1352].exec("ab", 4042));
-assertNull(res[1352].exec("ax{100}b  ", 4043));
-assertNull(res[1352].exec("ax{100}x{100}b  ", 4044));
-assertNull(res[1352].exec("ax{100}b  ", 4045));
-assertNull(res[1352].exec("ax{100}x{100}b  ", 4046));
-assertNull(res[1352].exec("*** Failers ", 4047));
-assertNull(res[1352].exec("ab", 4048));
-assertNull(res[1352].exec(" ", 4049));
-assertToStringEquals("X", res[1353].exec("Xoanon"), 4050);
-assertToStringEquals("X", res[1353].exec("+Xoanon"), 4051);
-assertToStringEquals("X", res[1353].exec("x{300}Xoanon "), 4052);
-assertNull(res[1353].exec("*** Failers ", 4053));
-assertNull(res[1353].exec("YXoanon  ", 4054));
-assertToStringEquals("X", res[1354].exec("YXoanon"), 4055);
-assertNull(res[1354].exec("*** Failers", 4056));
-assertNull(res[1354].exec("Xoanon", 4057));
-assertNull(res[1354].exec("+Xoanon    ", 4058));
-assertNull(res[1354].exec("x{300}Xoanon ", 4059));
-assertToStringEquals("X", res[1355].exec("X+oanon"), 4060);
-assertNull(res[1355].exec("ZXx{300}oanon ", 4061));
-assertToStringEquals("X", res[1355].exec("FAX "), 4062);
-assertNull(res[1355].exec("*** Failers ", 4063));
-assertNull(res[1355].exec("Xoanon  ", 4064));
-assertToStringEquals("X", res[1356].exec("Xoanon  "), 4065);
-assertNull(res[1356].exec("*** Failers", 4066));
-assertNull(res[1356].exec("X+oanon", 4067));
-assertToStringEquals("X", res[1356].exec("ZXx{300}oanon "), 4068);
-assertNull(res[1356].exec("FAX ", 4069));
-assertToStringEquals("b", res[1357].exec("abcd"), 4070);
-assertToStringEquals("x", res[1357].exec("ax{100}   "), 4071);
-assertToStringEquals("b", res[1357].exec("ab99"), 4072);
-assertToStringEquals("x", res[1357].exec("x{123}x{123}45"), 4073);
-assertToStringEquals("x", res[1357].exec("x{400}x{401}x{402}6  "), 4074);
-assertToStringEquals("*", res[1357].exec("*** Failers"), 4075);
-assertToStringEquals("d", res[1357].exec("d99"), 4076);
-assertToStringEquals("x", res[1357].exec("x{123}x{122}4   "), 4077);
-assertToStringEquals("x", res[1357].exec("x{400}x{403}6  "), 4078);
-assertToStringEquals("x", res[1357].exec("x{400}x{401}x{402}x{402}6  "), 4079);
-assertNull(res[1358].exec("\ufffd]", 4080));
-assertNull(res[1358].exec("\ufffd", 4081));
-assertNull(res[1358].exec("\ufffd\ufffd\ufffd", 4082));
-assertNull(res[1358].exec("\ufffd\ufffd\ufffd?", 4083));
-assertToStringEquals("acb", res[1359].exec("acb"), 4084);
-assertToStringEquals("ab", res[1359].exec("ab"), 4085);
-assertNull(res[1359].exec("ax{100}b ", 4086));
-assertNull(res[1359].exec("*** Failers", 4087));
-assertNull(res[1359].exec("a\nb  ", 4088));
-assertNull(res[1360].exec("ax{4000}xyb ", 4089));
-assertNull(res[1360].exec("ax{4000}yb ", 4090));
-assertNull(res[1360].exec("ax{4000}x{100}yb ", 4091));
-assertNull(res[1360].exec("*** Failers", 4092));
-assertNull(res[1360].exec("ax{4000}b ", 4093));
-assertNull(res[1360].exec("ac\ncb ", 4094));
-assertToStringEquals("a\xc0,,\xc0", res[1361].exec("a\xc0\x88b"), 4095);
-assertToStringEquals("ax,,x", res[1362].exec("ax{100}b"), 4096);
-assertToStringEquals("a\xc0\x88b,\xc0\x88,b", res[1363].exec("a\xc0\x88b"), 4097);
-assertToStringEquals("ax{100}b,x{100},b", res[1364].exec("ax{100}b"), 4098);
-assertToStringEquals("a\xc0\x92,\xc0,\x92", res[1365].exec("a\xc0\x92bcd"), 4099);
-assertToStringEquals("ax{,x,{", res[1366].exec("ax{240}bcd"), 4100);
-assertToStringEquals("a\xc0\x92,\xc0,\x92", res[1367].exec("a\xc0\x92bcd"), 4101);
-assertToStringEquals("ax{,x,{", res[1368].exec("ax{240}bcd"), 4102);
-assertToStringEquals("a\xc0,,\xc0", res[1369].exec("a\xc0\x92bcd"), 4103);
-assertToStringEquals("ax,,x", res[1370].exec("ax{240}bcd"), 4104);
-assertNull(res[1371].exec("ax{1234}xyb ", 4105));
-assertNull(res[1371].exec("ax{1234}x{4321}yb ", 4106));
-assertNull(res[1371].exec("ax{1234}x{4321}x{3412}b ", 4107));
-assertNull(res[1371].exec("*** Failers", 4108));
-assertNull(res[1371].exec("ax{1234}b ", 4109));
-assertNull(res[1371].exec("ac\ncb ", 4110));
-assertToStringEquals("ax{1234}xyb,x{1234}xy", res[1372].exec("ax{1234}xyb "), 4111);
-assertToStringEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1372].exec("ax{1234}x{4321}yb "), 4112);
-assertToStringEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1372].exec("ax{1234}x{4321}x{3412}b "), 4113);
-assertToStringEquals("axxxxbcdefghijb,xxxxbcdefghij", res[1372].exec("axxxxbcdefghijb "), 4114);
-assertToStringEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1372].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4115);
-assertNull(res[1372].exec("*** Failers", 4116));
-assertToStringEquals("ax{1234}b,x{1234}", res[1372].exec("ax{1234}b "), 4117);
-assertToStringEquals("ax{1234}xyb,x{1234}xy", res[1373].exec("ax{1234}xyb "), 4118);
-assertToStringEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1373].exec("ax{1234}x{4321}yb "), 4119);
-assertToStringEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1373].exec("ax{1234}x{4321}x{3412}b "), 4120);
-assertToStringEquals("axxxxb,xxxx", res[1373].exec("axxxxbcdefghijb "), 4121);
-assertToStringEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1373].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4122);
-assertNull(res[1373].exec("*** Failers", 4123));
-assertToStringEquals("ax{1234}b,x{1234}", res[1373].exec("ax{1234}b "), 4124);
-assertNull(res[1374].exec("ax{1234}xyb ", 4125));
-assertNull(res[1374].exec("ax{1234}x{4321}yb ", 4126));
-assertNull(res[1374].exec("ax{1234}x{4321}x{3412}b ", 4127));
-assertToStringEquals("axxxxb,xxxx", res[1374].exec("axxxxbcdefghijb "), 4128);
-assertNull(res[1374].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4129));
-assertToStringEquals("axbxxb,xbxx", res[1374].exec("axbxxbcdefghijb "), 4130);
-assertToStringEquals("axxxxxb,xxxxx", res[1374].exec("axxxxxbcdefghijb "), 4131);
-assertNull(res[1374].exec("*** Failers", 4132));
-assertNull(res[1374].exec("ax{1234}b ", 4133));
-assertNull(res[1374].exec("axxxxxxbcdefghijb ", 4134));
-assertNull(res[1375].exec("ax{1234}xyb ", 4135));
-assertNull(res[1375].exec("ax{1234}x{4321}yb ", 4136));
-assertNull(res[1375].exec("ax{1234}x{4321}x{3412}b ", 4137));
-assertToStringEquals("axxxxb,xxxx", res[1375].exec("axxxxbcdefghijb "), 4138);
-assertNull(res[1375].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4139));
-assertToStringEquals("axbxxb,xbxx", res[1375].exec("axbxxbcdefghijb "), 4140);
-assertToStringEquals("axxxxxb,xxxxx", res[1375].exec("axxxxxbcdefghijb "), 4141);
-assertNull(res[1375].exec("*** Failers", 4142));
-assertNull(res[1375].exec("ax{1234}b ", 4143));
-assertNull(res[1375].exec("axxxxxxbcdefghijb ", 4144));
-assertNull(res[1375].exec("*** Failers", 4145));
-assertNull(res[1375].exec("x{100}", 4146));
-assertNull(res[1375].exec("aXbcd", 4147));
-assertNull(res[1375].exec("ax{100}bcd", 4148));
-assertNull(res[1375].exec("ax{100000}bcd", 4149));
-assertNull(res[1375].exec("x{100}x{100}x{100}b", 4150));
-assertNull(res[1375].exec("*** Failers ", 4151));
-assertNull(res[1375].exec("x{100}x{100}b", 4152));
-assertNull(res[1375].exec("x{ab} ", 4153));
-assertNull(res[1375].exec("\xc2\xab", 4154));
-assertNull(res[1375].exec("*** Failers ", 4155));
-assertNull(res[1375].exec("\x00{ab}", 4156));
-assertNull(res[1375].exec("WXYZ", 4157));
-assertNull(res[1375].exec("x{256}XYZ ", 4158));
-assertNull(res[1375].exec("*** Failers", 4159));
-assertNull(res[1375].exec("XYZ ", 4160));
-assertToStringEquals("bcd", res[1376].exec("bcd"), 4161);
-assertToStringEquals("00}", res[1376].exec("x{100}aYx{256}Z "), 4162);
-assertToStringEquals("x{", res[1377].exec("x{100}bc"), 4163);
-assertToStringEquals("x{100}bcA", res[1378].exec("x{100}bcAa"), 4164);
-assertToStringEquals("x{", res[1379].exec("x{100}bca"), 4165);
-assertToStringEquals("bcd", res[1380].exec("bcd"), 4166);
-assertToStringEquals("00}", res[1380].exec("x{100}aYx{256}Z "), 4167);
-assertToStringEquals("x{", res[1381].exec("x{100}bc"), 4168);
-assertToStringEquals("x{100}bc", res[1382].exec("x{100}bcAa"), 4169);
-assertToStringEquals("x{", res[1383].exec("x{100}bca"), 4170);
-assertNull(res[1383].exec("abcd", 4171));
-assertNull(res[1383].exec("abcd", 4172));
-assertToStringEquals("x{", res[1383].exec("x{100}x{100} "), 4173);
-assertToStringEquals("x{", res[1383].exec("x{100}x{100} "), 4174);
-assertToStringEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4175);
-assertNull(res[1383].exec("abce", 4176));
-assertToStringEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4177);
-assertNull(res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4178));
-assertNull(res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4179));
-assertNull(res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4180));
-assertNull(res[1383].exec("abcdx{100}x{100}x{100}XX", 4181));
-assertNull(res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4182));
-assertNull(res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4183));
-assertToStringEquals("Xy", res[1383].exec("Xyyyax{100}x{100}bXzzz"), 4184);
-assertToStringEquals("X", res[1386].exec("1X2"), 4185);
-assertToStringEquals("x", res[1386].exec("1x{100}2 "), 4186);
-assertToStringEquals(">X", res[1387].exec("> >X Y"), 4187);
-assertToStringEquals(">x", res[1387].exec("> >x{100} Y"), 4188);
-assertToStringEquals("1", res[1388].exec("x{100}3"), 4189);
-assertToStringEquals(" ", res[1389].exec("x{100} X"), 4190);
-assertToStringEquals("abcd", res[1390].exec("12abcd34"), 4191);
-assertToStringEquals("*** Failers", res[1390].exec("*** Failers"), 4192);
-assertToStringEquals("  ", res[1390].exec("1234  "), 4193);
-assertToStringEquals("abc", res[1391].exec("12abcd34"), 4194);
-assertToStringEquals("ab", res[1391].exec("12ab34"), 4195);
-assertToStringEquals("***", res[1391].exec("*** Failers  "), 4196);
-assertNull(res[1391].exec("1234", 4197));
-assertToStringEquals("  ", res[1391].exec("12a34  "), 4198);
-assertToStringEquals("ab", res[1392].exec("12abcd34"), 4199);
-assertToStringEquals("ab", res[1392].exec("12ab34"), 4200);
-assertToStringEquals("**", res[1392].exec("*** Failers  "), 4201);
-assertNull(res[1392].exec("1234", 4202));
-assertToStringEquals("  ", res[1392].exec("12a34  "), 4203);
-assertToStringEquals("12", res[1393].exec("12abcd34"), 4204);
-assertNull(res[1393].exec("*** Failers", 4205));
-assertToStringEquals("12", res[1394].exec("12abcd34"), 4206);
-assertToStringEquals("123", res[1394].exec("1234abcd"), 4207);
-assertNull(res[1394].exec("*** Failers  ", 4208));
-assertNull(res[1394].exec("1.4 ", 4209));
-assertToStringEquals("12", res[1395].exec("12abcd34"), 4210);
-assertToStringEquals("12", res[1395].exec("1234abcd"), 4211);
-assertNull(res[1395].exec("*** Failers  ", 4212));
-assertNull(res[1395].exec("1.4 ", 4213));
-assertToStringEquals("12abcd34", res[1396].exec("12abcd34"), 4214);
-assertToStringEquals("***", res[1396].exec("*** Failers"), 4215);
-assertNull(res[1396].exec("     ", 4216));
-assertToStringEquals("12a", res[1397].exec("12abcd34"), 4217);
-assertToStringEquals("123", res[1397].exec("1234abcd"), 4218);
-assertToStringEquals("***", res[1397].exec("*** Failers"), 4219);
-assertNull(res[1397].exec("       ", 4220));
-assertToStringEquals("12", res[1398].exec("12abcd34"), 4221);
-assertToStringEquals("12", res[1398].exec("1234abcd"), 4222);
-assertToStringEquals("**", res[1398].exec("*** Failers"), 4223);
-assertNull(res[1398].exec("       ", 4224));
-assertToStringEquals(">      <", res[1399].exec("12>      <34"), 4225);
-assertNull(res[1399].exec("*** Failers", 4226));
-assertToStringEquals(">  <", res[1400].exec("ab>  <cd"), 4227);
-assertToStringEquals(">   <", res[1400].exec("ab>   <ce"), 4228);
-assertNull(res[1400].exec("*** Failers", 4229));
-assertNull(res[1400].exec("ab>    <cd ", 4230));
-assertToStringEquals(">  <", res[1401].exec("ab>  <cd"), 4231);
-assertToStringEquals(">   <", res[1401].exec("ab>   <ce"), 4232);
-assertNull(res[1401].exec("*** Failers", 4233));
-assertNull(res[1401].exec("ab>    <cd ", 4234));
-assertToStringEquals("12", res[1402].exec("12      34"), 4235);
-assertToStringEquals("Failers", res[1402].exec("*** Failers"), 4236);
-assertNull(res[1402].exec("+++=*! ", 4237));
-assertToStringEquals("ab", res[1403].exec("ab  cd"), 4238);
-assertToStringEquals("abc", res[1403].exec("abcd ce"), 4239);
-assertToStringEquals("Fai", res[1403].exec("*** Failers"), 4240);
-assertNull(res[1403].exec("a.b.c", 4241));
-assertToStringEquals("ab", res[1404].exec("ab  cd"), 4242);
-assertToStringEquals("ab", res[1404].exec("abcd ce"), 4243);
-assertToStringEquals("Fa", res[1404].exec("*** Failers"), 4244);
-assertNull(res[1404].exec("a.b.c", 4245));
-assertToStringEquals("====", res[1405].exec("12====34"), 4246);
-assertToStringEquals("*** ", res[1405].exec("*** Failers"), 4247);
-assertToStringEquals(" ", res[1405].exec("abcd "), 4248);
-assertToStringEquals("===", res[1406].exec("ab====cd"), 4249);
-assertToStringEquals("==", res[1406].exec("ab==cd"), 4250);
-assertToStringEquals("***", res[1406].exec("*** Failers"), 4251);
-assertNull(res[1406].exec("a.b.c", 4252));
-assertToStringEquals("==", res[1407].exec("ab====cd"), 4253);
-assertToStringEquals("==", res[1407].exec("ab==cd"), 4254);
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4255);
-assertNull(res[1407].exec("a.b.c", 4256));
-assertNull(res[1407].exec("x{100}", 4257));
-assertNull(res[1407].exec("Zx{100}", 4258));
-assertNull(res[1407].exec("x{100}Z", 4259));
-assertToStringEquals("**", res[1407].exec("*** Failers "), 4260);
-assertNull(res[1407].exec("Zx{100}", 4261));
-assertNull(res[1407].exec("x{100}", 4262));
-assertNull(res[1407].exec("x{100}Z", 4263));
-assertToStringEquals("**", res[1407].exec("*** Failers "), 4264);
-assertNull(res[1407].exec("abcx{200}X", 4265));
-assertNull(res[1407].exec("abcx{100}X ", 4266));
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4267);
-assertToStringEquals("  ", res[1407].exec("X  "), 4268);
-assertNull(res[1407].exec("abcx{200}X", 4269));
-assertNull(res[1407].exec("abcx{100}X ", 4270));
-assertNull(res[1407].exec("abQX ", 4271));
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4272);
-assertToStringEquals("  ", res[1407].exec("X  "), 4273);
-assertNull(res[1407].exec("abcx{100}x{200}x{100}X", 4274));
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4275);
-assertNull(res[1407].exec("abcx{200}X", 4276));
-assertToStringEquals("  ", res[1407].exec("X  "), 4277);
-assertNull(res[1407].exec("AX", 4278));
-assertNull(res[1407].exec("x{150}X", 4279));
-assertNull(res[1407].exec("x{500}X ", 4280));
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4281);
-assertNull(res[1407].exec("x{100}X", 4282));
-assertToStringEquals("  ", res[1407].exec("x{200}X   "), 4283);
-assertNull(res[1407].exec("AX", 4284));
-assertNull(res[1407].exec("x{150}X", 4285));
-assertNull(res[1407].exec("x{500}X ", 4286));
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4287);
-assertNull(res[1407].exec("x{100}X", 4288));
-assertToStringEquals("  ", res[1407].exec("x{200}X   "), 4289);
-assertNull(res[1407].exec("QX ", 4290));
-assertNull(res[1407].exec("AX", 4291));
-assertNull(res[1407].exec("x{500}X ", 4292));
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4293);
-assertNull(res[1407].exec("x{100}X", 4294));
-assertNull(res[1407].exec("x{150}X", 4295));
-assertToStringEquals("  ", res[1407].exec("x{200}X   "), 4296);
-assertNull(res[1407].exec("z", 4297));
-assertNull(res[1407].exec("Z ", 4298));
-assertNull(res[1407].exec("x{100}", 4299));
-assertToStringEquals("**", res[1407].exec("*** Failers"), 4300);
-assertNull(res[1407].exec("x{102}", 4301));
-assertToStringEquals("  ", res[1407].exec("y    "), 4302);
-assertToStringEquals("\xff", res[1408].exec(">\xff<"), 4303);
-assertNull(res[1409].exec(">x{ff}<", 4304));
-assertToStringEquals("X", res[1410].exec("XYZ"), 4305);
-assertToStringEquals("X", res[1411].exec("XYZ"), 4306);
-assertToStringEquals("x", res[1411].exec("x{123} "), 4307);
-assertToStringEquals(",", res[1416].exec("catac"), 4308);
-assertToStringEquals(",", res[1416].exec("ax{256}a "), 4309);
-assertToStringEquals(",", res[1416].exec("x{85}"), 4310);
-assertToStringEquals("abc1", res[1417].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 4311);
-assertToStringEquals("abc1", res[1418].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 4312);
-assertNull(res[1419].exec("a\nb", 4313));
-assertNull(res[1419].exec("a\x0db", 4314));
-assertNull(res[1419].exec("a\x0d\nb", 4315));
-assertNull(res[1419].exec("a\x0bb", 4316));
-assertNull(res[1419].exec("a\x0cb", 4317));
-assertNull(res[1419].exec("ax{85}b   ", 4318));
-assertNull(res[1419].exec("ax{2028}b ", 4319));
-assertNull(res[1419].exec("ax{2029}b ", 4320));
-assertNull(res[1419].exec("** Failers", 4321));
-assertNull(res[1419].exec("a\n\x0db    ", 4322));
-assertToStringEquals("ab", res[1420].exec("ab"), 4323);
-assertNull(res[1420].exec("a\nb", 4324));
-assertNull(res[1420].exec("a\x0db", 4325));
-assertNull(res[1420].exec("a\x0d\nb", 4326));
-assertNull(res[1420].exec("a\x0bb", 4327));
-assertNull(res[1420].exec("a\x0cx{2028}x{2029}b", 4328));
-assertNull(res[1420].exec("ax{85}b   ", 4329));
-assertNull(res[1420].exec("a\n\x0db    ", 4330));
-assertNull(res[1420].exec("a\n\x0dx{85}\x0cb ", 4331));
-assertNull(res[1421].exec("a\nb", 4332));
-assertNull(res[1421].exec("a\x0db", 4333));
-assertNull(res[1421].exec("a\x0d\nb", 4334));
-assertNull(res[1421].exec("a\x0bb", 4335));
-assertNull(res[1421].exec("a\x0cx{2028}x{2029}b", 4336));
-assertNull(res[1421].exec("ax{85}b   ", 4337));
-assertNull(res[1421].exec("a\n\x0db    ", 4338));
-assertNull(res[1421].exec("a\n\x0dx{85}\x0cb ", 4339));
-assertNull(res[1421].exec("** Failers", 4340));
-assertNull(res[1421].exec("ab  ", 4341));
-assertNull(res[1422].exec("a\nb", 4342));
-assertNull(res[1422].exec("a\n\x0db", 4343));
-assertNull(res[1422].exec("a\n\x0dx{85}b", 4344));
-assertNull(res[1422].exec("a\x0d\n\x0d\nb ", 4345));
-assertNull(res[1422].exec("a\x0d\n\x0d\n\x0d\nb ", 4346));
-assertNull(res[1422].exec("a\n\x0d\n\x0db", 4347));
-assertNull(res[1422].exec("a\n\n\x0d\nb ", 4348));
-assertNull(res[1422].exec("** Failers", 4349));
-assertNull(res[1422].exec("a\n\n\n\x0db", 4350));
-assertNull(res[1422].exec("a\x0d", 4351));
-assertNull(res[1423].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4352));
-assertNull(res[1424].exec(" x{a0}X\n\x0b\x0c\x0d\n", 4353));
-assertNull(res[1425].exec(">\x09 x{a0}X\n\n\n<", 4354));
-assertNull(res[1426].exec(">\x09 x{a0}X\n\n\n<", 4355));
-assertNull(res[1427].exec("X X\n", 4356));
-assertNull(res[1427].exec("X\x09X\x0b", 4357));
-assertNull(res[1427].exec("** Failers", 4358));
-assertNull(res[1427].exec("x{a0} X\n   ", 4359));
-assertNull(res[1428].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4360));
-assertNull(res[1428].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 4361));
-assertNull(res[1428].exec("\x09 x{a0}\n\x0b\x0c", 4362));
-assertNull(res[1428].exec("** Failers ", 4363));
-assertNull(res[1428].exec("\x09 x{a0}\n\x0b", 4364));
-assertNull(res[1428].exec(" ", 4365));
-assertNull(res[1429].exec("x{3001}x{3000}x{2030}x{2028}", 4366));
-assertNull(res[1429].exec("Xx{180e}Xx{85}", 4367));
-assertNull(res[1429].exec("** Failers", 4368));
-assertNull(res[1429].exec("x{2009} X\n   ", 4369));
-assertNull(res[1430].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 4370));
-assertNull(res[1430].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 4371));
-assertNull(res[1430].exec("\x09 x{202f}\n\x0b\x0c", 4372));
-assertNull(res[1430].exec("** Failers ", 4373));
-assertNull(res[1430].exec("\x09x{200a}x{a0}x{2028}\x0b", 4374));
-assertNull(res[1430].exec(" ", 4375));
-assertNull(res[1431].exec("a\x0db", 4376));
-assertNull(res[1431].exec("a\nb", 4377));
-assertNull(res[1431].exec("a\x0d\nb", 4378));
-assertNull(res[1431].exec("** Failers", 4379));
-assertNull(res[1431].exec("ax{85}b", 4380));
-assertNull(res[1431].exec("a\x0bb     ", 4381));
-assertNull(res[1432].exec("a\x0db", 4382));
-assertNull(res[1432].exec("a\nb", 4383));
-assertNull(res[1432].exec("a\x0d\nb", 4384));
-assertNull(res[1432].exec("ax{85}b", 4385));
-assertNull(res[1432].exec("a\x0bb     ", 4386));
-assertNull(res[1432].exec("** Failers ", 4387));
-assertNull(res[1432].exec("ax{85}b<bsr_anycrlf>", 4388));
-assertNull(res[1432].exec("a\x0bb<bsr_anycrlf>", 4389));
-assertNull(res[1433].exec("a\x0db", 4390));
-assertNull(res[1433].exec("a\nb", 4391));
-assertNull(res[1433].exec("a\x0d\nb", 4392));
-assertNull(res[1433].exec("** Failers", 4393));
-assertNull(res[1433].exec("ax{85}b", 4394));
-assertNull(res[1433].exec("a\x0bb     ", 4395));
-assertNull(res[1434].exec("a\x0db", 4396));
-assertNull(res[1434].exec("a\nb", 4397));
-assertNull(res[1434].exec("a\x0d\nb", 4398));
-assertNull(res[1434].exec("ax{85}b", 4399));
-assertNull(res[1434].exec("a\x0bb     ", 4400));
-assertNull(res[1434].exec("** Failers ", 4401));
-assertNull(res[1434].exec("ax{85}b<bsr_anycrlf>", 4402));
-assertNull(res[1434].exec("a\x0bb<bsr_anycrlf>", 4403));
-assertToStringEquals("X", res[1435].exec("Ax{1ec5}ABCXYZ"), 4404);
-assertNull(res[1437].exec("AB", 4405));
-assertNull(res[1437].exec("*** Failers", 4406));
-assertNull(res[1437].exec("A0", 4407));
-assertNull(res[1437].exec("00   ", 4408));
-assertNull(res[1438].exec("AB", 4409));
-assertNull(res[1438].exec("Ax{300}BC ", 4410));
-assertNull(res[1438].exec("Ax{300}x{301}x{302}BC ", 4411));
-assertNull(res[1438].exec("*** Failers", 4412));
-assertNull(res[1438].exec("x{300}  ", 4413));
-assertNull(res[1439].exec("ABC", 4414));
-assertNull(res[1439].exec("Ax{300}Bx{300}x{301}C ", 4415));
-assertNull(res[1439].exec("Ax{300}x{301}x{302}BC ", 4416));
-assertNull(res[1439].exec("*** Failers", 4417));
-assertNull(res[1439].exec("x{300}  ", 4418));
-assertNull(res[1440].exec("abcd", 4419));
-assertNull(res[1440].exec("a ", 4420));
-assertNull(res[1440].exec("*** Failers ", 4421));
-assertNull(res[1441].exec("1234", 4422));
-assertNull(res[1441].exec("= ", 4423));
-assertNull(res[1441].exec("*** Failers ", 4424));
-assertNull(res[1441].exec("abcd ", 4425));
-assertNull(res[1442].exec("abcdAx{300}x{301}x{302}", 4426));
-assertNull(res[1442].exec("Ax{300}x{301}x{302}", 4427));
-assertNull(res[1442].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}", 4428));
-assertNull(res[1442].exec("a ", 4429));
-assertNull(res[1442].exec("*** Failers ", 4430));
-assertNull(res[1442].exec("x{300}x{301}x{302}", 4431));
-assertToStringEquals("abc", res[1443].exec("abc"), 4432);
-assertToStringEquals("abc", res[1443].exec("Ax{300}abc"), 4433);
-assertToStringEquals("abc", res[1443].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4434);
-assertToStringEquals("abc", res[1443].exec("x{300}abc  "), 4435);
-assertNull(res[1443].exec("*** Failers", 4436));
-assertToStringEquals("abc", res[1444].exec("abc"), 4437);
-assertNull(res[1444].exec("Ax{300}abc", 4438));
-assertNull(res[1444].exec("*** Failers", 4439));
-assertNull(res[1444].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4440));
-assertNull(res[1444].exec("x{300}abc  ", 4441));
-assertToStringEquals("abc", res[1445].exec("abc"), 4442);
-assertToStringEquals("abc", res[1445].exec("Ax{300}abc"), 4443);
-assertToStringEquals("abc", res[1445].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4444);
-assertToStringEquals("abc", res[1445].exec("x{300}abc  "), 4445);
-assertNull(res[1445].exec("*** Failers", 4446));
-assertToStringEquals("abc", res[1446].exec("abc"), 4447);
-assertNull(res[1446].exec("Ax{300}abc", 4448));
-assertNull(res[1446].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4449));
-assertNull(res[1446].exec("*** Failers", 4450));
-assertNull(res[1446].exec("x{300}abc  ", 4451));
-assertNull(res[1447].exec("A=b", 4452));
-assertNull(res[1447].exec("=c ", 4453));
-assertNull(res[1447].exec("*** Failers", 4454));
-assertNull(res[1447].exec("1=2 ", 4455));
-assertNull(res[1447].exec("AAAA=b  ", 4456));
-assertNull(res[1448].exec("AAAA=b", 4457));
-assertNull(res[1448].exec("=c ", 4458));
-assertNull(res[1448].exec("*** Failers", 4459));
-assertNull(res[1448].exec("1=2  ", 4460));
-assertNull(res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4461));
-assertNull(res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X ", 4462));
-assertNull(res[1449].exec("*** Failers", 4463));
-assertNull(res[1449].exec("X", 4464));
-assertNull(res[1449].exec("Ax{300}x{301}x{302}X", 4465));
-assertNull(res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4466));
-assertNull(res[1450].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 4467));
-assertNull(res[1450].exec("\npx{300}9!$ < ", 4468));
-assertNull(res[1450].exec("** Failers ", 4469));
-assertNull(res[1450].exec("apx{300}9!$ < ", 4470));
-assertNull(res[1451].exec("X", 4471));
-assertNull(res[1451].exec("** Failers ", 4472));
-assertNull(res[1451].exec("", 4473));
-assertNull(res[1452].exec("9", 4474));
-assertNull(res[1452].exec("** Failers ", 4475));
-assertNull(res[1452].exec("x{c0}", 4476));
-assertNull(res[1453].exec("X", 4477));
-assertNull(res[1453].exec("** Failers ", 4478));
-assertNull(res[1453].exec("x{30f}", 4479));
-assertNull(res[1454].exec("X", 4480));
-assertNull(res[1454].exec("** Failers ", 4481));
-assertNull(res[1454].exec("x{660}", 4482));
-assertNull(res[1455].exec("X", 4483));
-assertNull(res[1455].exec("** Failers ", 4484));
-assertNull(res[1455].exec("x{66c}", 4485));
-assertNull(res[1456].exec("X", 4486));
-assertNull(res[1456].exec("** Failers ", 4487));
-assertNull(res[1456].exec("x{f01}", 4488));
-assertNull(res[1457].exec("X", 4489));
-assertNull(res[1457].exec("** Failers ", 4490));
-assertNull(res[1457].exec("x{1680}", 4491));
-assertNull(res[1458].exec("x{017}", 4492));
-assertNull(res[1458].exec("x{09f} ", 4493));
-assertNull(res[1458].exec("** Failers", 4494));
-assertNull(res[1458].exec("x{0600} ", 4495));
-assertNull(res[1459].exec("x{601}", 4496));
-assertNull(res[1459].exec("** Failers", 4497));
-assertNull(res[1459].exec("x{09f} ", 4498));
-assertNull(res[1460].exec("** Failers", 4499));
-assertNull(res[1460].exec("x{09f} ", 4500));
-assertNull(res[1461].exec("x{f8ff}", 4501));
-assertNull(res[1461].exec("** Failers", 4502));
-assertNull(res[1461].exec("x{09f} ", 4503));
-assertNull(res[1462].exec("?x{dfff}", 4504));
-assertNull(res[1462].exec("** Failers", 4505));
-assertNull(res[1462].exec("x{09f} ", 4506));
-assertNull(res[1463].exec("a", 4507));
-assertNull(res[1463].exec("** Failers ", 4508));
-assertNull(res[1463].exec("Z", 4509));
-assertNull(res[1463].exec("x{e000}  ", 4510));
-assertNull(res[1464].exec("x{2b0}", 4511));
-assertNull(res[1464].exec("** Failers", 4512));
-assertNull(res[1464].exec("a ", 4513));
-assertNull(res[1465].exec("x{1bb}", 4514));
-assertNull(res[1465].exec("** Failers", 4515));
-assertNull(res[1465].exec("a ", 4516));
-assertNull(res[1465].exec("x{2b0}", 4517));
-assertNull(res[1466].exec("x{1c5}", 4518));
-assertNull(res[1466].exec("** Failers", 4519));
-assertNull(res[1466].exec("a ", 4520));
-assertNull(res[1466].exec("x{2b0}", 4521));
-assertNull(res[1467].exec("A", 4522));
-assertNull(res[1467].exec("** Failers", 4523));
-assertNull(res[1467].exec("x{2b0}", 4524));
-assertNull(res[1468].exec("x{903}", 4525));
-assertNull(res[1468].exec("** Failers", 4526));
-assertNull(res[1468].exec("X", 4527));
-assertNull(res[1468].exec("x{300}", 4528));
-assertNull(res[1468].exec("   ", 4529));
-assertNull(res[1469].exec("x{488}", 4530));
-assertNull(res[1469].exec("** Failers", 4531));
-assertNull(res[1469].exec("X", 4532));
-assertNull(res[1469].exec("x{903}", 4533));
-assertNull(res[1469].exec("x{300}", 4534));
-assertNull(res[1470].exec("x{300}", 4535));
-assertNull(res[1470].exec("** Failers", 4536));
-assertNull(res[1470].exec("X", 4537));
-assertNull(res[1470].exec("x{903}", 4538));
-assertNull(res[1470].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 4539));
-assertNull(res[1470].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 4540));
-assertNull(res[1470].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 4541));
-assertNull(res[1470].exec("** Failers", 4542));
-assertNull(res[1470].exec("X", 4543));
-assertNull(res[1471].exec("x{16ee}", 4544));
-assertNull(res[1471].exec("** Failers", 4545));
-assertNull(res[1471].exec("X", 4546));
-assertNull(res[1471].exec("x{966}", 4547));
-assertNull(res[1472].exec("x{b2}", 4548));
-assertNull(res[1472].exec("x{b3}", 4549));
-assertNull(res[1472].exec("** Failers", 4550));
-assertNull(res[1472].exec("X", 4551));
-assertNull(res[1472].exec("x{16ee}", 4552));
-assertNull(res[1473].exec("_", 4553));
-assertNull(res[1473].exec("x{203f}", 4554));
-assertNull(res[1473].exec("** Failers", 4555));
-assertNull(res[1473].exec("X", 4556));
-assertNull(res[1473].exec("-", 4557));
-assertNull(res[1473].exec("x{58a}", 4558));
-assertNull(res[1474].exec("-", 4559));
-assertNull(res[1474].exec("x{58a}", 4560));
-assertNull(res[1474].exec("** Failers", 4561));
-assertNull(res[1474].exec("X", 4562));
-assertNull(res[1474].exec("x{203f}", 4563));
-assertNull(res[1475].exec(")", 4564));
-assertNull(res[1475].exec("]", 4565));
-assertNull(res[1475].exec("}", 4566));
-assertNull(res[1475].exec("x{f3b}", 4567));
-assertNull(res[1475].exec("** Failers", 4568));
-assertNull(res[1475].exec("X", 4569));
-assertNull(res[1475].exec("x{203f}", 4570));
-assertNull(res[1475].exec("(", 4571));
-assertNull(res[1475].exec("[", 4572));
-assertNull(res[1475].exec("{", 4573));
-assertNull(res[1475].exec("x{f3c}", 4574));
-assertNull(res[1476].exec("x{bb}", 4575));
-assertNull(res[1476].exec("x{2019}", 4576));
-assertNull(res[1476].exec("** Failers", 4577));
-assertNull(res[1476].exec("X", 4578));
-assertNull(res[1476].exec("x{203f}", 4579));
-assertNull(res[1477].exec("x{ab}", 4580));
-assertNull(res[1477].exec("x{2018}", 4581));
-assertNull(res[1477].exec("** Failers", 4582));
-assertNull(res[1477].exec("X", 4583));
-assertNull(res[1477].exec("x{203f}", 4584));
-assertNull(res[1478].exec("!", 4585));
-assertNull(res[1478].exec("x{37e}", 4586));
-assertNull(res[1478].exec("** Failers", 4587));
-assertNull(res[1478].exec("X", 4588));
-assertNull(res[1478].exec("x{203f}", 4589));
-assertNull(res[1479].exec("(", 4590));
-assertNull(res[1479].exec("[", 4591));
-assertNull(res[1479].exec("{", 4592));
-assertNull(res[1479].exec("x{f3c}", 4593));
-assertNull(res[1479].exec("** Failers", 4594));
-assertNull(res[1479].exec("X", 4595));
-assertNull(res[1479].exec(")", 4596));
-assertNull(res[1479].exec("]", 4597));
-assertNull(res[1479].exec("}", 4598));
-assertNull(res[1479].exec("x{f3b}", 4599));
-assertNull(res[1479].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 4600));
-assertNull(res[1479].exec("x{9f2}", 4601));
-assertNull(res[1479].exec("** Failers", 4602));
-assertNull(res[1479].exec("X", 4603));
-assertNull(res[1479].exec("x{2c2}", 4604));
-assertNull(res[1480].exec("x{2c2}", 4605));
-assertNull(res[1480].exec("** Failers", 4606));
-assertNull(res[1480].exec("X", 4607));
-assertNull(res[1480].exec("x{9f2}", 4608));
-assertNull(res[1480].exec("+<|~x{ac}x{2044}", 4609));
-assertNull(res[1480].exec("** Failers", 4610));
-assertNull(res[1480].exec("X", 4611));
-assertNull(res[1480].exec("x{9f2}", 4612));
-assertNull(res[1481].exec("x{a6}", 4613));
-assertNull(res[1481].exec("x{482} ", 4614));
-assertNull(res[1481].exec("** Failers", 4615));
-assertNull(res[1481].exec("X", 4616));
-assertNull(res[1481].exec("x{9f2}", 4617));
-assertNull(res[1482].exec("x{2028}", 4618));
-assertNull(res[1482].exec("** Failers", 4619));
-assertNull(res[1482].exec("X", 4620));
-assertNull(res[1482].exec("x{2029}", 4621));
-assertNull(res[1483].exec("x{2029}", 4622));
-assertNull(res[1483].exec("** Failers", 4623));
-assertNull(res[1483].exec("X", 4624));
-assertNull(res[1483].exec("x{2028}", 4625));
-assertNull(res[1484].exec("\\ \\", 4626));
-assertNull(res[1484].exec("x{a0}", 4627));
-assertNull(res[1484].exec("x{1680}", 4628));
-assertNull(res[1484].exec("x{180e}", 4629));
-assertNull(res[1484].exec("x{2000}", 4630));
-assertNull(res[1484].exec("x{2001}     ", 4631));
-assertNull(res[1484].exec("** Failers", 4632));
-assertNull(res[1484].exec("x{2028}", 4633));
-assertNull(res[1484].exec("x{200d} ", 4634));
-assertNull(res[1484].exec("  x{660}x{661}x{662}ABC", 4635));
-assertNull(res[1484].exec("  x{660}x{661}x{662}ABC", 4636));
-assertNull(res[1485].exec("  x{660}x{661}x{662}ABC", 4637));
-assertNull(res[1486].exec("  x{660}x{661}x{662}ABC", 4638));
-assertNull(res[1487].exec("  x{660}x{661}x{662}ABC", 4639));
-assertNull(res[1488].exec("  x{660}x{661}x{662}ABC", 4640));
-assertNull(res[1489].exec("  x{660}x{661}x{662}ABC", 4641));
-assertNull(res[1490].exec("  x{660}x{661}x{662}ABC", 4642));
-assertNull(res[1491].exec("  x{660}x{661}x{662}ABC", 4643));
-assertNull(res[1492].exec("  x{660}x{661}x{662}ABC", 4644));
-assertNull(res[1493].exec("  x{660}x{661}x{662}ABC", 4645));
-assertNull(res[1493].exec("  x{660}x{661}x{662}ABC", 4646));
-assertNull(res[1493].exec("  x{660}x{661}x{662}ABC", 4647));
-assertNull(res[1493].exec("  ** Failers", 4648));
-assertNull(res[1493].exec("  x{660}x{661}x{662}ABC", 4649));
-assertNull(res[1494].exec("A", 4650));
-assertNull(res[1494].exec("ax{10a0}B ", 4651));
-assertNull(res[1494].exec("** Failers ", 4652));
-assertNull(res[1494].exec("a", 4653));
-assertNull(res[1494].exec("x{1d00}  ", 4654));
-assertNull(res[1495].exec("1234", 4655));
-assertNull(res[1495].exec("** Failers", 4656));
-assertNull(res[1495].exec("ABC ", 4657));
-assertNull(res[1496].exec("1234", 4658));
-assertNull(res[1496].exec("** Failers", 4659));
-assertNull(res[1496].exec("ABC ", 4660));
-assertNull(res[1496].exec("A2XYZ", 4661));
-assertNull(res[1496].exec("123A5XYZPQR", 4662));
-assertNull(res[1496].exec("ABAx{660}XYZpqr", 4663));
-assertNull(res[1496].exec("** Failers", 4664));
-assertNull(res[1496].exec("AXYZ", 4665));
-assertNull(res[1496].exec("XYZ     ", 4666));
-assertNull(res[1496].exec("1XYZ", 4667));
-assertNull(res[1496].exec("AB=XYZ.. ", 4668));
-assertNull(res[1496].exec("XYZ ", 4669));
-assertNull(res[1496].exec("** Failers", 4670));
-assertNull(res[1496].exec("WXYZ ", 4671));
-assertNull(res[1497].exec("1234", 4672));
-assertNull(res[1497].exec("1234", 4673));
-assertNull(res[1497].exec("12-34", 4674));
-assertToStringEquals("{", res[1497].exec("12+x{661}-34  "), 4675);
-assertNull(res[1497].exec("** Failers", 4676));
-assertToStringEquals("d", res[1497].exec("abcd  "), 4677);
-assertToStringEquals("d", res[1498].exec("abcd"), 4678);
-assertNull(res[1498].exec("** Failers", 4679));
-assertNull(res[1498].exec("1234", 4680));
-assertNull(res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4681));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4682);
-assertToStringEquals(" ", res[1499].exec(" "), 4683);
-assertNull(res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4684));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4685);
-assertNull(res[1500].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4686));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1500].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4687);
-assertNull(res[1501].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4688));
-assertNull(res[1501].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 4689));
-assertNull(res[1502].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4690));
-assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1502].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4691);
-assertNull(res[1503].exec("a", 4692));
-assertNull(res[1503].exec("A ", 4693));
-assertNull(res[1504].exec("a", 4694));
-assertNull(res[1504].exec("A ", 4695));
-assertNull(res[1505].exec("A", 4696));
-assertNull(res[1505].exec("aZ", 4697));
-assertNull(res[1505].exec("** Failers", 4698));
-assertNull(res[1505].exec("abc   ", 4699));
-assertNull(res[1506].exec("A", 4700));
-assertNull(res[1506].exec("aZ", 4701));
-assertNull(res[1506].exec("** Failers", 4702));
-assertNull(res[1506].exec("abc   ", 4703));
-assertNull(res[1507].exec("a", 4704));
-assertNull(res[1507].exec("Az", 4705));
-assertNull(res[1507].exec("** Failers", 4706));
-assertNull(res[1507].exec("ABC   ", 4707));
-assertNull(res[1508].exec("a", 4708));
-assertNull(res[1508].exec("Az", 4709));
-assertNull(res[1508].exec("** Failers", 4710));
-assertNull(res[1508].exec("ABC   ", 4711));
-assertNull(res[1508].exec("x{c0}", 4712));
-assertNull(res[1508].exec("x{e0} ", 4713));
-assertNull(res[1508].exec("x{c0}", 4714));
-assertNull(res[1508].exec("x{e0} ", 4715));
-assertNull(res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4716));
-assertNull(res[1508].exec("** Failers", 4717));
-assertNull(res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 4718));
-assertNull(res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4719));
-assertNull(res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4720));
-assertNull(res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4721));
-assertNull(res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4722));
-assertNull(res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4723));
-assertNull(res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 4724));
-assertNull(res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4725));
-assertNull(res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4726));
-assertNull(res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4727));
-assertNull(res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4728));
-assertNull(res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 4729));
-assertNull(res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4730));
-assertNull(res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4731));
-assertNull(res[1508].exec("x{391}", 4732));
-assertNull(res[1508].exec("x{ff3a}", 4733));
-assertNull(res[1508].exec("x{3b1}", 4734));
-assertNull(res[1508].exec("x{ff5a}   ", 4735));
-assertNull(res[1508].exec("x{c0}", 4736));
-assertNull(res[1508].exec("x{e0} ", 4737));
-assertNull(res[1508].exec("x{104}", 4738));
-assertNull(res[1508].exec("x{105}", 4739));
-assertNull(res[1508].exec("x{109}  ", 4740));
-assertNull(res[1508].exec("** Failers", 4741));
-assertNull(res[1508].exec("x{100}", 4742));
-assertNull(res[1508].exec("x{10a} ", 4743));
-assertNull(res[1508].exec("Z", 4744));
-assertNull(res[1508].exec("z", 4745));
-assertNull(res[1508].exec("x{39c}", 4746));
-assertNull(res[1508].exec("x{178}", 4747));
-assertNull(res[1508].exec("|", 4748));
-assertNull(res[1508].exec("x{80}", 4749));
-assertNull(res[1508].exec("x{ff}", 4750));
-assertNull(res[1508].exec("x{100}", 4751));
-assertNull(res[1508].exec("x{101} ", 4752));
-assertNull(res[1508].exec("** Failers", 4753));
-assertNull(res[1508].exec("x{102}", 4754));
-assertNull(res[1508].exec("Y", 4755));
-assertNull(res[1508].exec("y           ", 4756));
-assertNull(res[1509].exec("A", 4757));
-assertNull(res[1509].exec("Ax{300}BC ", 4758));
-assertNull(res[1509].exec("Ax{300}x{301}x{302}BC ", 4759));
-assertNull(res[1509].exec("*** Failers", 4760));
-assertNull(res[1509].exec("x{300}  ", 4761));
-assertToStringEquals("X", res[1510].exec("X123"), 4762);
-assertNull(res[1510].exec("*** Failers", 4763));
-assertNull(res[1510].exec("AXYZ", 4764));
-assertNull(res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4765));
-assertNull(res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4766));
-assertNull(res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4767));
-assertNull(res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4768));
-assertToStringEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4769);
-assertToStringEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4770);
-assertToStringEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4771);
-assertToStringEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4772);
-assertNull(res[1515].exec("*** Failers", 4773));
-assertNull(res[1515].exec("Ax{300}x{301}x{302}", 4774));
-assertNull(res[1516].exec("Ax{300}x{301}Bx{300}X", 4775));
-assertNull(res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4776));
-assertNull(res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4777));
-assertNull(res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4778));
-assertNull(res[1517].exec("Ax{300}x{301}Bx{300}X", 4779));
-assertNull(res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4780));
-assertNull(res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4781));
-assertNull(res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4782));
-assertNull(res[1518].exec("12X", 4783));
-assertNull(res[1518].exec("123X", 4784));
-assertNull(res[1518].exec("*** Failers", 4785));
-assertNull(res[1518].exec("X", 4786));
-assertNull(res[1518].exec("1X", 4787));
-assertNull(res[1518].exec("1234X     ", 4788));
-assertNull(res[1518].exec("x{100}   ", 4789));
-assertNull(res[1518].exec("x{101} ", 4790));
-assertNull(res[1518].exec("x{2e81}x{3007}x{2f804}x{31a0}", 4791));
-assertNull(res[1518].exec("** Failers", 4792));
-assertNull(res[1518].exec("x{2e7f}  ", 4793));
-assertNull(res[1518].exec("x{3105}", 4794));
-assertNull(res[1518].exec("** Failers", 4795));
-assertNull(res[1518].exec("x{30ff}  ", 4796));
-assertNull(res[1519].exec("x{06e9}", 4797));
-assertNull(res[1519].exec("x{060b}", 4798));
-assertNull(res[1519].exec("** Failers", 4799));
-assertNull(res[1519].exec("Xx{06e9}   ", 4800));
-assertNull(res[1520].exec("x{2f800}", 4801));
-assertNull(res[1520].exec("** Failers", 4802));
-assertNull(res[1520].exec("x{a014}", 4803));
-assertNull(res[1520].exec("x{a4c6}   ", 4804));
-assertNull(res[1521].exec("AXYZ", 4805));
-assertNull(res[1521].exec("x{1234}XYZ ", 4806));
-assertNull(res[1521].exec("** Failers", 4807));
-assertNull(res[1521].exec("X  ", 4808));
-assertNull(res[1522].exec("** Failers", 4809));
-assertNull(res[1522].exec("AX", 4810));
-assertNull(res[1523].exec("XYZ", 4811));
-assertNull(res[1523].exec("AXYZ", 4812));
-assertNull(res[1523].exec("x{1234}XYZ ", 4813));
-assertNull(res[1523].exec("** Failers", 4814));
-assertNull(res[1523].exec("ABXYZ   ", 4815));
-assertNull(res[1524].exec("XYZ", 4816));
-assertNull(res[1524].exec("** Failers", 4817));
-assertNull(res[1524].exec("AXYZ", 4818));
-assertNull(res[1524].exec("x{1234}XYZ ", 4819));
-assertNull(res[1524].exec("ABXYZ   ", 4820));
-assertNull(res[1524].exec("AXYZ", 4821));
-assertNull(res[1524].exec("x{1234}XYZ", 4822));
-assertNull(res[1524].exec("Ax{1234}XYZ", 4823));
-assertNull(res[1524].exec("** Failers", 4824));
-assertNull(res[1524].exec("XYZ", 4825));
-assertNull(res[1524].exec("** Failers", 4826));
-assertNull(res[1524].exec("AXYZ", 4827));
-assertNull(res[1524].exec("x{1234}XYZ", 4828));
-assertNull(res[1524].exec("Ax{1234}XYZ", 4829));
-assertNull(res[1524].exec("XYZ", 4830));
-assertNull(res[1525].exec("XYZ", 4831));
-assertNull(res[1525].exec("AXYZ", 4832));
-assertNull(res[1525].exec("x{1234}XYZ", 4833));
-assertNull(res[1525].exec("Ax{1234}XYZ", 4834));
-assertNull(res[1525].exec("** Failers", 4835));
-assertNull(res[1526].exec("XYZ", 4836));
-assertNull(res[1526].exec("** Failers", 4837));
-assertNull(res[1526].exec("AXYZ", 4838));
-assertNull(res[1526].exec("x{1234}XYZ", 4839));
-assertNull(res[1526].exec("Ax{1234}XYZ", 4840));
-assertToStringEquals("AX", res[1527].exec("AXYZ"), 4841);
-assertNull(res[1527].exec("x{1234}XYZ ", 4842));
-assertNull(res[1527].exec("** Failers", 4843));
-assertNull(res[1527].exec("X  ", 4844));
-assertNull(res[1528].exec("** Failers", 4845));
-assertToStringEquals("AX", res[1528].exec("AX"), 4846);
-assertToStringEquals("X", res[1529].exec("XYZ"), 4847);
-assertToStringEquals("AX", res[1529].exec("AXYZ"), 4848);
-assertNull(res[1529].exec("x{1234}XYZ ", 4849));
-assertNull(res[1529].exec("** Failers", 4850));
-assertNull(res[1529].exec("ABXYZ   ", 4851));
-assertToStringEquals("X", res[1530].exec("XYZ"), 4852);
-assertNull(res[1530].exec("** Failers", 4853));
-assertToStringEquals("AX", res[1530].exec("AXYZ"), 4854);
-assertNull(res[1530].exec("x{1234}XYZ ", 4855));
-assertNull(res[1530].exec("ABXYZ   ", 4856));
-assertToStringEquals("AX", res[1531].exec("AXYZ"), 4857);
-assertNull(res[1531].exec("x{1234}XYZ", 4858));
-assertNull(res[1531].exec("Ax{1234}XYZ", 4859));
-assertNull(res[1531].exec("** Failers", 4860));
-assertNull(res[1531].exec("XYZ", 4861));
-assertNull(res[1532].exec("** Failers", 4862));
-assertToStringEquals("AX", res[1532].exec("AXYZ"), 4863);
-assertNull(res[1532].exec("x{1234}XYZ", 4864));
-assertNull(res[1532].exec("Ax{1234}XYZ", 4865));
-assertNull(res[1532].exec("XYZ", 4866));
-assertToStringEquals("X", res[1533].exec("XYZ"), 4867);
-assertToStringEquals("AX", res[1533].exec("AXYZ"), 4868);
-assertNull(res[1533].exec("x{1234}XYZ", 4869));
-assertNull(res[1533].exec("Ax{1234}XYZ", 4870));
-assertNull(res[1533].exec("** Failers", 4871));
-assertToStringEquals("X", res[1534].exec("XYZ"), 4872);
-assertNull(res[1534].exec("** Failers", 4873));
-assertToStringEquals("AX", res[1534].exec("AXYZ"), 4874);
-assertNull(res[1534].exec("x{1234}XYZ", 4875));
-assertNull(res[1534].exec("Ax{1234}XYZ", 4876));
-assertNull(res[1535].exec("abcdefgh", 4877));
-assertNull(res[1535].exec("x{1234}\n\x0dx{3456}xyz ", 4878));
-assertNull(res[1536].exec("abcdefgh", 4879));
-assertNull(res[1536].exec("x{1234}\n\x0dx{3456}xyz ", 4880));
-assertNull(res[1537].exec("** Failers", 4881));
-assertNull(res[1537].exec("abcdefgh", 4882));
-assertNull(res[1537].exec("x{1234}\n\x0dx{3456}xyz ", 4883));
-assertNull(res[1538].exec(" AXY", 4884));
-assertNull(res[1538].exec(" aXY", 4885));
-assertNull(res[1538].exec(" x{1c5}XY", 4886));
-assertNull(res[1538].exec(" ** Failers", 4887));
-assertNull(res[1538].exec(" x{1bb}XY", 4888));
-assertNull(res[1538].exec(" x{2b0}XY", 4889));
-assertNull(res[1538].exec(" !XY      ", 4890));
-assertNull(res[1539].exec(" AXY", 4891));
-assertNull(res[1539].exec(" aXY", 4892));
-assertNull(res[1539].exec(" x{1c5}XY", 4893));
-assertNull(res[1539].exec(" ** Failers", 4894));
-assertNull(res[1539].exec(" x{1bb}XY", 4895));
-assertNull(res[1539].exec(" x{2b0}XY", 4896));
-assertNull(res[1539].exec(" !XY      ", 4897));
-assertNull(res[1539].exec(" AXY", 4898));
-assertNull(res[1539].exec(" aXY", 4899));
-assertNull(res[1539].exec(" AbcdeXyz ", 4900));
-assertNull(res[1539].exec(" x{1c5}AbXY", 4901));
-assertNull(res[1539].exec(" abcDEXypqreXlmn ", 4902));
-assertNull(res[1539].exec(" ** Failers", 4903));
-assertNull(res[1539].exec(" x{1bb}XY", 4904));
-assertNull(res[1539].exec(" x{2b0}XY", 4905));
-assertNull(res[1539].exec(" !XY      ", 4906));
-assertNull(res[1540].exec(" AXY", 4907));
-assertNull(res[1540].exec(" aXY", 4908));
-assertNull(res[1540].exec(" AbcdeXyz ", 4909));
-assertNull(res[1540].exec(" x{1c5}AbXY", 4910));
-assertNull(res[1540].exec(" abcDEXypqreXlmn ", 4911));
-assertNull(res[1540].exec(" ** Failers", 4912));
-assertNull(res[1540].exec(" x{1bb}XY", 4913));
-assertNull(res[1540].exec(" x{2b0}XY", 4914));
-assertNull(res[1540].exec(" !XY      ", 4915));
-assertNull(res[1540].exec(" AXY", 4916));
-assertNull(res[1540].exec(" aXY", 4917));
-assertNull(res[1540].exec(" AbcdeXyz ", 4918));
-assertNull(res[1540].exec(" x{1c5}AbXY", 4919));
-assertNull(res[1540].exec(" abcDEXypqreXlmn ", 4920));
-assertNull(res[1540].exec(" ** Failers", 4921));
-assertNull(res[1540].exec(" x{1bb}XY", 4922));
-assertNull(res[1540].exec(" x{2b0}XY", 4923));
-assertNull(res[1540].exec(" !XY      ", 4924));
-assertNull(res[1541].exec(" AXY", 4925));
-assertNull(res[1541].exec(" aXY", 4926));
-assertNull(res[1541].exec(" AbcdeXyz ", 4927));
-assertNull(res[1541].exec(" x{1c5}AbXY", 4928));
-assertNull(res[1541].exec(" abcDEXypqreXlmn ", 4929));
-assertNull(res[1541].exec(" ** Failers", 4930));
-assertNull(res[1541].exec(" x{1bb}XY", 4931));
-assertNull(res[1541].exec(" x{2b0}XY", 4932));
-assertNull(res[1541].exec(" !XY      ", 4933));
-assertNull(res[1542].exec(" !XY", 4934));
-assertNull(res[1542].exec(" x{1bb}XY", 4935));
-assertNull(res[1542].exec(" x{2b0}XY", 4936));
-assertNull(res[1542].exec(" ** Failers", 4937));
-assertNull(res[1542].exec(" x{1c5}XY", 4938));
-assertNull(res[1542].exec(" AXY      ", 4939));
-assertNull(res[1543].exec(" !XY", 4940));
-assertNull(res[1543].exec(" x{1bb}XY", 4941));
-assertNull(res[1543].exec(" x{2b0}XY", 4942));
-assertNull(res[1543].exec(" ** Failers", 4943));
-assertNull(res[1543].exec(" x{1c5}XY", 4944));
-assertNull(res[1543].exec(" AXY      ", 4945));
-assertNull(res[1543].exec("x{c0}x{e0}x{116}x{117}", 4946));
-assertNull(res[1543].exec("x{c0}x{e0}x{116}x{117}", 4947));
-assertNull(res[1545].exec("123abcdefg", 4948));
-assertNull(res[1545].exec("123abc\xc4\xc5zz", 4949));
-assertNull(res[1546].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 4950));
-assertNull(res[1546].exec("x{a77d}x{1d79}", 4951));
-assertNull(res[1546].exec("x{1d79}x{a77d} ", 4952));
-assertNull(res[1546].exec("x{a77d}x{1d79}", 4953));
-assertNull(res[1546].exec("** Failers ", 4954));
-assertNull(res[1546].exec("x{1d79}x{a77d} ", 4955));
+assertEquals(null, res[1330].exec("xabcpqrx", 3954));
+assertEquals(null, res[1330].exec("xxyzx ", 3955));
+assertEquals(null, res[1330].exec("abcabc", 3956));
+assertEquals(null, res[1330].exec("xyzabc ", 3957));
+assertEquals(null, res[1330].exec("** Failers ", 3958));
+assertEquals(null, res[1330].exec("xyzxyz ", 3959));
+assertEquals(null, res[1331].exec("X X\n", 3960));
+assertEquals(null, res[1331].exec("X\x09X\x0b", 3961));
+assertEquals(null, res[1331].exec("** Failers", 3962));
+assertEquals(null, res[1331].exec("\xa0 X\n   ", 3963));
+assertEquals(null, res[1332].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 3964));
+assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 3965));
+assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b\x0c", 3966));
+assertEquals(null, res[1332].exec("** Failers ", 3967));
+assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b", 3968));
+assertEquals(null, res[1332].exec(" ", 3969));
+assertEquals(null, res[1333].exec("XY  ABCDE", 3970));
+assertEquals(null, res[1333].exec("XY  PQR ST ", 3971));
+assertEquals(null, res[1334].exec("XY  AB    PQRS", 3972));
+assertEquals(null, res[1335].exec(">XNNNYZ", 3973));
+assertEquals(null, res[1335].exec(">  X NYQZ", 3974));
+assertEquals(null, res[1335].exec("** Failers", 3975));
+assertEquals(null, res[1335].exec(">XYZ   ", 3976));
+assertEquals(null, res[1335].exec(">  X NY Z", 3977));
+assertEquals(null, res[1336].exec(">XY\nZ\nA\x0bNN\x0c", 3978));
+assertEquals(null, res[1336].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 3979));
+assertEquals(null, res[1337].exec("\x0d\nA", 3980));
+assertEquals("\nA", res[1338].exec("\x0d\nA "), 3981);
+assertEquals("\nA", res[1339].exec("\x0d\nA "), 3982);
+assertEquals("\nA,\n", res[1340].exec("\x0d\nA "), 3983);
+assertEquals(null, res[1341].exec("a\x0db", 3984));
+assertEquals(null, res[1341].exec("a\nb", 3985));
+assertEquals(null, res[1341].exec("a\x0d\nb", 3986));
+assertEquals(null, res[1341].exec("** Failers", 3987));
+assertEquals(null, res[1341].exec("a\x85b", 3988));
+assertEquals(null, res[1341].exec("a\x0bb     ", 3989));
+assertEquals(null, res[1342].exec("a\x0db", 3990));
+assertEquals(null, res[1342].exec("a\nb", 3991));
+assertEquals(null, res[1342].exec("a\x0d\nb", 3992));
+assertEquals(null, res[1342].exec("a\x85b", 3993));
+assertEquals(null, res[1342].exec("a\x0bb     ", 3994));
+assertEquals(null, res[1342].exec("** Failers ", 3995));
+assertEquals(null, res[1342].exec("a\x85b<bsr_anycrlf>", 3996));
+assertEquals(null, res[1342].exec("a\x0bb<bsr_anycrlf>", 3997));
+assertEquals(null, res[1343].exec("a\x0db", 3998));
+assertEquals(null, res[1343].exec("a\nb", 3999));
+assertEquals(null, res[1343].exec("a\x0d\nb", 4000));
+assertEquals(null, res[1343].exec("** Failers", 4001));
+assertEquals(null, res[1343].exec("a\x85b", 4002));
+assertEquals(null, res[1343].exec("a\x0bb     ", 4003));
+assertEquals(null, res[1344].exec("a\x0db", 4004));
+assertEquals(null, res[1344].exec("a\nb", 4005));
+assertEquals(null, res[1344].exec("a\x0d\nb", 4006));
+assertEquals(null, res[1344].exec("a\x85b", 4007));
+assertEquals(null, res[1344].exec("a\x0bb     ", 4008));
+assertEquals(null, res[1344].exec("** Failers ", 4009));
+assertEquals(null, res[1344].exec("a\x85b<bsr_anycrlf>", 4010));
+assertEquals(null, res[1344].exec("a\x0bb<bsr_anycrlf>", 4011));
+assertEquals(null, res[1345].exec("a\x0d\n\nb", 4012));
+assertEquals(null, res[1345].exec("a\n\x0d\x0db", 4013));
+assertEquals(null, res[1345].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 4014));
+assertEquals(null, res[1345].exec("** Failers", 4015));
+assertEquals(null, res[1345].exec("a\x8585b", 4016));
+assertEquals(null, res[1345].exec("a\x0b\x00bb     ", 4017));
+assertEquals(null, res[1346].exec("a\x0d\x0db", 4018));
+assertEquals(null, res[1346].exec("a\n\n\nb", 4019));
+assertEquals(null, res[1346].exec("a\x0d\n\n\x0d\x0db", 4020));
+assertEquals(null, res[1346].exec("a\x8585b", 4021));
+assertEquals(null, res[1346].exec("a\x0b\x00bb     ", 4022));
+assertEquals(null, res[1346].exec("** Failers ", 4023));
+assertEquals(null, res[1346].exec("a\x0d\x0d\x0d\x0d\x0db ", 4024));
+assertEquals(null, res[1346].exec("a\x8585b<bsr_anycrlf>", 4025));
+assertEquals(null, res[1346].exec("a\x0b\x00bb<bsr_anycrlf>", 4026));
+assertEquals("abc", res[1347].exec("abc "), 4027);
+assertEquals(null, res[1348].exec("** Failers", 4028));
+assertEquals(null, res[1348].exec("ab", 4029));
+assertEquals(null, res[1349].exec("** Failers", 4030));
+assertEquals(null, res[1349].exec("ab ", 4031));
+assertEquals(null, res[1349].exec("** Failers", 4032));
+assertEquals(null, res[1349].exec("ab ", 4033));
+assertEquals("aXb", res[1350].exec("aXb"), 4034);
+assertEquals("a\nb", res[1350].exec("a\nb "), 4035);
+assertEquals(null, res[1350].exec("** Failers", 4036));
+assertEquals(null, res[1350].exec("ab  ", 4037));
+assertEquals("aXb", res[1351].exec("aXb"), 4038);
+assertEquals("a\nX\nXb", res[1351].exec("a\nX\nXb "), 4039);
+assertEquals(null, res[1351].exec("** Failers", 4040));
+assertEquals(null, res[1351].exec("ab  ", 4041));
+assertEquals(null, res[1352].exec("ab", 4042));
+assertEquals(null, res[1352].exec("ax{100}b  ", 4043));
+assertEquals(null, res[1352].exec("ax{100}x{100}b  ", 4044));
+assertEquals(null, res[1352].exec("ax{100}b  ", 4045));
+assertEquals(null, res[1352].exec("ax{100}x{100}b  ", 4046));
+assertEquals(null, res[1352].exec("*** Failers ", 4047));
+assertEquals(null, res[1352].exec("ab", 4048));
+assertEquals(null, res[1352].exec(" ", 4049));
+assertEquals("X", res[1353].exec("Xoanon"), 4050);
+assertEquals("X", res[1353].exec("+Xoanon"), 4051);
+assertEquals("X", res[1353].exec("x{300}Xoanon "), 4052);
+assertEquals(null, res[1353].exec("*** Failers ", 4053));
+assertEquals(null, res[1353].exec("YXoanon  ", 4054));
+assertEquals("X", res[1354].exec("YXoanon"), 4055);
+assertEquals(null, res[1354].exec("*** Failers", 4056));
+assertEquals(null, res[1354].exec("Xoanon", 4057));
+assertEquals(null, res[1354].exec("+Xoanon    ", 4058));
+assertEquals(null, res[1354].exec("x{300}Xoanon ", 4059));
+assertEquals("X", res[1355].exec("X+oanon"), 4060);
+assertEquals(null, res[1355].exec("ZXx{300}oanon ", 4061));
+assertEquals("X", res[1355].exec("FAX "), 4062);
+assertEquals(null, res[1355].exec("*** Failers ", 4063));
+assertEquals(null, res[1355].exec("Xoanon  ", 4064));
+assertEquals("X", res[1356].exec("Xoanon  "), 4065);
+assertEquals(null, res[1356].exec("*** Failers", 4066));
+assertEquals(null, res[1356].exec("X+oanon", 4067));
+assertEquals("X", res[1356].exec("ZXx{300}oanon "), 4068);
+assertEquals(null, res[1356].exec("FAX ", 4069));
+assertEquals("b", res[1357].exec("abcd"), 4070);
+assertEquals("x", res[1357].exec("ax{100}   "), 4071);
+assertEquals("b", res[1357].exec("ab99"), 4072);
+assertEquals("x", res[1357].exec("x{123}x{123}45"), 4073);
+assertEquals("x", res[1357].exec("x{400}x{401}x{402}6  "), 4074);
+assertEquals("*", res[1357].exec("*** Failers"), 4075);
+assertEquals("d", res[1357].exec("d99"), 4076);
+assertEquals("x", res[1357].exec("x{123}x{122}4   "), 4077);
+assertEquals("x", res[1357].exec("x{400}x{403}6  "), 4078);
+assertEquals("x", res[1357].exec("x{400}x{401}x{402}x{402}6  "), 4079);
+assertEquals(null, res[1358].exec("\ufffd]", 4080));
+assertEquals(null, res[1358].exec("\ufffd", 4081));
+assertEquals(null, res[1358].exec("\ufffd\ufffd\ufffd", 4082));
+assertEquals(null, res[1358].exec("\ufffd\ufffd\ufffd?", 4083));
+assertEquals("acb", res[1359].exec("acb"), 4084);
+assertEquals("ab", res[1359].exec("ab"), 4085);
+assertEquals(null, res[1359].exec("ax{100}b ", 4086));
+assertEquals(null, res[1359].exec("*** Failers", 4087));
+assertEquals(null, res[1359].exec("a\nb  ", 4088));
+assertEquals(null, res[1360].exec("ax{4000}xyb ", 4089));
+assertEquals(null, res[1360].exec("ax{4000}yb ", 4090));
+assertEquals(null, res[1360].exec("ax{4000}x{100}yb ", 4091));
+assertEquals(null, res[1360].exec("*** Failers", 4092));
+assertEquals(null, res[1360].exec("ax{4000}b ", 4093));
+assertEquals(null, res[1360].exec("ac\ncb ", 4094));
+assertEquals("a\xc0,,\xc0", res[1361].exec("a\xc0\x88b"), 4095);
+assertEquals("ax,,x", res[1362].exec("ax{100}b"), 4096);
+assertEquals("a\xc0\x88b,\xc0\x88,b", res[1363].exec("a\xc0\x88b"), 4097);
+assertEquals("ax{100}b,x{100},b", res[1364].exec("ax{100}b"), 4098);
+assertEquals("a\xc0\x92,\xc0,\x92", res[1365].exec("a\xc0\x92bcd"), 4099);
+assertEquals("ax{,x,{", res[1366].exec("ax{240}bcd"), 4100);
+assertEquals("a\xc0\x92,\xc0,\x92", res[1367].exec("a\xc0\x92bcd"), 4101);
+assertEquals("ax{,x,{", res[1368].exec("ax{240}bcd"), 4102);
+assertEquals("a\xc0,,\xc0", res[1369].exec("a\xc0\x92bcd"), 4103);
+assertEquals("ax,,x", res[1370].exec("ax{240}bcd"), 4104);
+assertEquals(null, res[1371].exec("ax{1234}xyb ", 4105));
+assertEquals(null, res[1371].exec("ax{1234}x{4321}yb ", 4106));
+assertEquals(null, res[1371].exec("ax{1234}x{4321}x{3412}b ", 4107));
+assertEquals(null, res[1371].exec("*** Failers", 4108));
+assertEquals(null, res[1371].exec("ax{1234}b ", 4109));
+assertEquals(null, res[1371].exec("ac\ncb ", 4110));
+assertEquals("ax{1234}xyb,x{1234}xy", res[1372].exec("ax{1234}xyb "), 4111);
+assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1372].exec("ax{1234}x{4321}yb "), 4112);
+assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1372].exec("ax{1234}x{4321}x{3412}b "), 4113);
+assertEquals("axxxxbcdefghijb,xxxxbcdefghij", res[1372].exec("axxxxbcdefghijb "), 4114);
+assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1372].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4115);
+assertEquals(null, res[1372].exec("*** Failers", 4116));
+assertEquals("ax{1234}b,x{1234}", res[1372].exec("ax{1234}b "), 4117);
+assertEquals("ax{1234}xyb,x{1234}xy", res[1373].exec("ax{1234}xyb "), 4118);
+assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1373].exec("ax{1234}x{4321}yb "), 4119);
+assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1373].exec("ax{1234}x{4321}x{3412}b "), 4120);
+assertEquals("axxxxb,xxxx", res[1373].exec("axxxxbcdefghijb "), 4121);
+assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1373].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4122);
+assertEquals(null, res[1373].exec("*** Failers", 4123));
+assertEquals("ax{1234}b,x{1234}", res[1373].exec("ax{1234}b "), 4124);
+assertEquals(null, res[1374].exec("ax{1234}xyb ", 4125));
+assertEquals(null, res[1374].exec("ax{1234}x{4321}yb ", 4126));
+assertEquals(null, res[1374].exec("ax{1234}x{4321}x{3412}b ", 4127));
+assertEquals("axxxxb,xxxx", res[1374].exec("axxxxbcdefghijb "), 4128);
+assertEquals(null, res[1374].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4129));
+assertEquals("axbxxb,xbxx", res[1374].exec("axbxxbcdefghijb "), 4130);
+assertEquals("axxxxxb,xxxxx", res[1374].exec("axxxxxbcdefghijb "), 4131);
+assertEquals(null, res[1374].exec("*** Failers", 4132));
+assertEquals(null, res[1374].exec("ax{1234}b ", 4133));
+assertEquals(null, res[1374].exec("axxxxxxbcdefghijb ", 4134));
+assertEquals(null, res[1375].exec("ax{1234}xyb ", 4135));
+assertEquals(null, res[1375].exec("ax{1234}x{4321}yb ", 4136));
+assertEquals(null, res[1375].exec("ax{1234}x{4321}x{3412}b ", 4137));
+assertEquals("axxxxb,xxxx", res[1375].exec("axxxxbcdefghijb "), 4138);
+assertEquals(null, res[1375].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4139));
+assertEquals("axbxxb,xbxx", res[1375].exec("axbxxbcdefghijb "), 4140);
+assertEquals("axxxxxb,xxxxx", res[1375].exec("axxxxxbcdefghijb "), 4141);
+assertEquals(null, res[1375].exec("*** Failers", 4142));
+assertEquals(null, res[1375].exec("ax{1234}b ", 4143));
+assertEquals(null, res[1375].exec("axxxxxxbcdefghijb ", 4144));
+assertEquals(null, res[1375].exec("*** Failers", 4145));
+assertEquals(null, res[1375].exec("x{100}", 4146));
+assertEquals(null, res[1375].exec("aXbcd", 4147));
+assertEquals(null, res[1375].exec("ax{100}bcd", 4148));
+assertEquals(null, res[1375].exec("ax{100000}bcd", 4149));
+assertEquals(null, res[1375].exec("x{100}x{100}x{100}b", 4150));
+assertEquals(null, res[1375].exec("*** Failers ", 4151));
+assertEquals(null, res[1375].exec("x{100}x{100}b", 4152));
+assertEquals(null, res[1375].exec("x{ab} ", 4153));
+assertEquals(null, res[1375].exec("\xc2\xab", 4154));
+assertEquals(null, res[1375].exec("*** Failers ", 4155));
+assertEquals(null, res[1375].exec("\x00{ab}", 4156));
+assertEquals(null, res[1375].exec("WXYZ", 4157));
+assertEquals(null, res[1375].exec("x{256}XYZ ", 4158));
+assertEquals(null, res[1375].exec("*** Failers", 4159));
+assertEquals(null, res[1375].exec("XYZ ", 4160));
+assertEquals("bcd", res[1376].exec("bcd"), 4161);
+assertEquals("00}", res[1376].exec("x{100}aYx{256}Z "), 4162);
+assertEquals("x{", res[1377].exec("x{100}bc"), 4163);
+assertEquals("x{100}bcA", res[1378].exec("x{100}bcAa"), 4164);
+assertEquals("x{", res[1379].exec("x{100}bca"), 4165);
+assertEquals("bcd", res[1380].exec("bcd"), 4166);
+assertEquals("00}", res[1380].exec("x{100}aYx{256}Z "), 4167);
+assertEquals("x{", res[1381].exec("x{100}bc"), 4168);
+assertEquals("x{100}bc", res[1382].exec("x{100}bcAa"), 4169);
+assertEquals("x{", res[1383].exec("x{100}bca"), 4170);
+assertEquals(null, res[1383].exec("abcd", 4171));
+assertEquals(null, res[1383].exec("abcd", 4172));
+assertEquals("x{", res[1383].exec("x{100}x{100} "), 4173);
+assertEquals("x{", res[1383].exec("x{100}x{100} "), 4174);
+assertEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4175);
+assertEquals(null, res[1383].exec("abce", 4176));
+assertEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4177);
+assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4178));
+assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4179));
+assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4180));
+assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}XX", 4181));
+assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4182));
+assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4183));
+assertEquals("Xy", res[1383].exec("Xyyyax{100}x{100}bXzzz"), 4184);
+assertEquals("X", res[1386].exec("1X2"), 4185);
+assertEquals("x", res[1386].exec("1x{100}2 "), 4186);
+assertEquals(">X", res[1387].exec("> >X Y"), 4187);
+assertEquals(">x", res[1387].exec("> >x{100} Y"), 4188);
+assertEquals("1", res[1388].exec("x{100}3"), 4189);
+assertEquals(" ", res[1389].exec("x{100} X"), 4190);
+assertEquals("abcd", res[1390].exec("12abcd34"), 4191);
+assertEquals("*** Failers", res[1390].exec("*** Failers"), 4192);
+assertEquals("  ", res[1390].exec("1234  "), 4193);
+assertEquals("abc", res[1391].exec("12abcd34"), 4194);
+assertEquals("ab", res[1391].exec("12ab34"), 4195);
+assertEquals("***", res[1391].exec("*** Failers  "), 4196);
+assertEquals(null, res[1391].exec("1234", 4197));
+assertEquals("  ", res[1391].exec("12a34  "), 4198);
+assertEquals("ab", res[1392].exec("12abcd34"), 4199);
+assertEquals("ab", res[1392].exec("12ab34"), 4200);
+assertEquals("**", res[1392].exec("*** Failers  "), 4201);
+assertEquals(null, res[1392].exec("1234", 4202));
+assertEquals("  ", res[1392].exec("12a34  "), 4203);
+assertEquals("12", res[1393].exec("12abcd34"), 4204);
+assertEquals(null, res[1393].exec("*** Failers", 4205));
+assertEquals("12", res[1394].exec("12abcd34"), 4206);
+assertEquals("123", res[1394].exec("1234abcd"), 4207);
+assertEquals(null, res[1394].exec("*** Failers  ", 4208));
+assertEquals(null, res[1394].exec("1.4 ", 4209));
+assertEquals("12", res[1395].exec("12abcd34"), 4210);
+assertEquals("12", res[1395].exec("1234abcd"), 4211);
+assertEquals(null, res[1395].exec("*** Failers  ", 4212));
+assertEquals(null, res[1395].exec("1.4 ", 4213));
+assertEquals("12abcd34", res[1396].exec("12abcd34"), 4214);
+assertEquals("***", res[1396].exec("*** Failers"), 4215);
+assertEquals(null, res[1396].exec("     ", 4216));
+assertEquals("12a", res[1397].exec("12abcd34"), 4217);
+assertEquals("123", res[1397].exec("1234abcd"), 4218);
+assertEquals("***", res[1397].exec("*** Failers"), 4219);
+assertEquals(null, res[1397].exec("       ", 4220));
+assertEquals("12", res[1398].exec("12abcd34"), 4221);
+assertEquals("12", res[1398].exec("1234abcd"), 4222);
+assertEquals("**", res[1398].exec("*** Failers"), 4223);
+assertEquals(null, res[1398].exec("       ", 4224));
+assertEquals(">      <", res[1399].exec("12>      <34"), 4225);
+assertEquals(null, res[1399].exec("*** Failers", 4226));
+assertEquals(">  <", res[1400].exec("ab>  <cd"), 4227);
+assertEquals(">   <", res[1400].exec("ab>   <ce"), 4228);
+assertEquals(null, res[1400].exec("*** Failers", 4229));
+assertEquals(null, res[1400].exec("ab>    <cd ", 4230));
+assertEquals(">  <", res[1401].exec("ab>  <cd"), 4231);
+assertEquals(">   <", res[1401].exec("ab>   <ce"), 4232);
+assertEquals(null, res[1401].exec("*** Failers", 4233));
+assertEquals(null, res[1401].exec("ab>    <cd ", 4234));
+assertEquals("12", res[1402].exec("12      34"), 4235);
+assertEquals("Failers", res[1402].exec("*** Failers"), 4236);
+assertEquals(null, res[1402].exec("+++=*! ", 4237));
+assertEquals("ab", res[1403].exec("ab  cd"), 4238);
+assertEquals("abc", res[1403].exec("abcd ce"), 4239);
+assertEquals("Fai", res[1403].exec("*** Failers"), 4240);
+assertEquals(null, res[1403].exec("a.b.c", 4241));
+assertEquals("ab", res[1404].exec("ab  cd"), 4242);
+assertEquals("ab", res[1404].exec("abcd ce"), 4243);
+assertEquals("Fa", res[1404].exec("*** Failers"), 4244);
+assertEquals(null, res[1404].exec("a.b.c", 4245));
+assertEquals("====", res[1405].exec("12====34"), 4246);
+assertEquals("*** ", res[1405].exec("*** Failers"), 4247);
+assertEquals(" ", res[1405].exec("abcd "), 4248);
+assertEquals("===", res[1406].exec("ab====cd"), 4249);
+assertEquals("==", res[1406].exec("ab==cd"), 4250);
+assertEquals("***", res[1406].exec("*** Failers"), 4251);
+assertEquals(null, res[1406].exec("a.b.c", 4252));
+assertEquals("==", res[1407].exec("ab====cd"), 4253);
+assertEquals("==", res[1407].exec("ab==cd"), 4254);
+assertEquals("**", res[1407].exec("*** Failers"), 4255);
+assertEquals(null, res[1407].exec("a.b.c", 4256));
+assertEquals(null, res[1407].exec("x{100}", 4257));
+assertEquals(null, res[1407].exec("Zx{100}", 4258));
+assertEquals(null, res[1407].exec("x{100}Z", 4259));
+assertEquals("**", res[1407].exec("*** Failers "), 4260);
+assertEquals(null, res[1407].exec("Zx{100}", 4261));
+assertEquals(null, res[1407].exec("x{100}", 4262));
+assertEquals(null, res[1407].exec("x{100}Z", 4263));
+assertEquals("**", res[1407].exec("*** Failers "), 4264);
+assertEquals(null, res[1407].exec("abcx{200}X", 4265));
+assertEquals(null, res[1407].exec("abcx{100}X ", 4266));
+assertEquals("**", res[1407].exec("*** Failers"), 4267);
+assertEquals("  ", res[1407].exec("X  "), 4268);
+assertEquals(null, res[1407].exec("abcx{200}X", 4269));
+assertEquals(null, res[1407].exec("abcx{100}X ", 4270));
+assertEquals(null, res[1407].exec("abQX ", 4271));
+assertEquals("**", res[1407].exec("*** Failers"), 4272);
+assertEquals("  ", res[1407].exec("X  "), 4273);
+assertEquals(null, res[1407].exec("abcx{100}x{200}x{100}X", 4274));
+assertEquals("**", res[1407].exec("*** Failers"), 4275);
+assertEquals(null, res[1407].exec("abcx{200}X", 4276));
+assertEquals("  ", res[1407].exec("X  "), 4277);
+assertEquals(null, res[1407].exec("AX", 4278));
+assertEquals(null, res[1407].exec("x{150}X", 4279));
+assertEquals(null, res[1407].exec("x{500}X ", 4280));
+assertEquals("**", res[1407].exec("*** Failers"), 4281);
+assertEquals(null, res[1407].exec("x{100}X", 4282));
+assertEquals("  ", res[1407].exec("x{200}X   "), 4283);
+assertEquals(null, res[1407].exec("AX", 4284));
+assertEquals(null, res[1407].exec("x{150}X", 4285));
+assertEquals(null, res[1407].exec("x{500}X ", 4286));
+assertEquals("**", res[1407].exec("*** Failers"), 4287);
+assertEquals(null, res[1407].exec("x{100}X", 4288));
+assertEquals("  ", res[1407].exec("x{200}X   "), 4289);
+assertEquals(null, res[1407].exec("QX ", 4290));
+assertEquals(null, res[1407].exec("AX", 4291));
+assertEquals(null, res[1407].exec("x{500}X ", 4292));
+assertEquals("**", res[1407].exec("*** Failers"), 4293);
+assertEquals(null, res[1407].exec("x{100}X", 4294));
+assertEquals(null, res[1407].exec("x{150}X", 4295));
+assertEquals("  ", res[1407].exec("x{200}X   "), 4296);
+assertEquals(null, res[1407].exec("z", 4297));
+assertEquals(null, res[1407].exec("Z ", 4298));
+assertEquals(null, res[1407].exec("x{100}", 4299));
+assertEquals("**", res[1407].exec("*** Failers"), 4300);
+assertEquals(null, res[1407].exec("x{102}", 4301));
+assertEquals("  ", res[1407].exec("y    "), 4302);
+assertEquals("\xff", res[1408].exec(">\xff<"), 4303);
+assertEquals(null, res[1409].exec(">x{ff}<", 4304));
+assertEquals("X", res[1410].exec("XYZ"), 4305);
+assertEquals("X", res[1411].exec("XYZ"), 4306);
+assertEquals("x", res[1411].exec("x{123} "), 4307);
+assertEquals(",", res[1416].exec("catac"), 4308);
+assertEquals(",", res[1416].exec("ax{256}a "), 4309);
+assertEquals(",", res[1416].exec("x{85}"), 4310);
+assertEquals("abc1", res[1417].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 4311);
+assertEquals("abc1", res[1418].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 4312);
+assertEquals(null, res[1419].exec("a\nb", 4313));
+assertEquals(null, res[1419].exec("a\x0db", 4314));
+assertEquals(null, res[1419].exec("a\x0d\nb", 4315));
+assertEquals(null, res[1419].exec("a\x0bb", 4316));
+assertEquals(null, res[1419].exec("a\x0cb", 4317));
+assertEquals(null, res[1419].exec("ax{85}b   ", 4318));
+assertEquals(null, res[1419].exec("ax{2028}b ", 4319));
+assertEquals(null, res[1419].exec("ax{2029}b ", 4320));
+assertEquals(null, res[1419].exec("** Failers", 4321));
+assertEquals(null, res[1419].exec("a\n\x0db    ", 4322));
+assertEquals("ab", res[1420].exec("ab"), 4323);
+assertEquals(null, res[1420].exec("a\nb", 4324));
+assertEquals(null, res[1420].exec("a\x0db", 4325));
+assertEquals(null, res[1420].exec("a\x0d\nb", 4326));
+assertEquals(null, res[1420].exec("a\x0bb", 4327));
+assertEquals(null, res[1420].exec("a\x0cx{2028}x{2029}b", 4328));
+assertEquals(null, res[1420].exec("ax{85}b   ", 4329));
+assertEquals(null, res[1420].exec("a\n\x0db    ", 4330));
+assertEquals(null, res[1420].exec("a\n\x0dx{85}\x0cb ", 4331));
+assertEquals(null, res[1421].exec("a\nb", 4332));
+assertEquals(null, res[1421].exec("a\x0db", 4333));
+assertEquals(null, res[1421].exec("a\x0d\nb", 4334));
+assertEquals(null, res[1421].exec("a\x0bb", 4335));
+assertEquals(null, res[1421].exec("a\x0cx{2028}x{2029}b", 4336));
+assertEquals(null, res[1421].exec("ax{85}b   ", 4337));
+assertEquals(null, res[1421].exec("a\n\x0db    ", 4338));
+assertEquals(null, res[1421].exec("a\n\x0dx{85}\x0cb ", 4339));
+assertEquals(null, res[1421].exec("** Failers", 4340));
+assertEquals(null, res[1421].exec("ab  ", 4341));
+assertEquals(null, res[1422].exec("a\nb", 4342));
+assertEquals(null, res[1422].exec("a\n\x0db", 4343));
+assertEquals(null, res[1422].exec("a\n\x0dx{85}b", 4344));
+assertEquals(null, res[1422].exec("a\x0d\n\x0d\nb ", 4345));
+assertEquals(null, res[1422].exec("a\x0d\n\x0d\n\x0d\nb ", 4346));
+assertEquals(null, res[1422].exec("a\n\x0d\n\x0db", 4347));
+assertEquals(null, res[1422].exec("a\n\n\x0d\nb ", 4348));
+assertEquals(null, res[1422].exec("** Failers", 4349));
+assertEquals(null, res[1422].exec("a\n\n\n\x0db", 4350));
+assertEquals(null, res[1422].exec("a\x0d", 4351));
+assertEquals(null, res[1423].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4352));
+assertEquals(null, res[1424].exec(" x{a0}X\n\x0b\x0c\x0d\n", 4353));
+assertEquals(null, res[1425].exec(">\x09 x{a0}X\n\n\n<", 4354));
+assertEquals(null, res[1426].exec(">\x09 x{a0}X\n\n\n<", 4355));
+assertEquals(null, res[1427].exec("X X\n", 4356));
+assertEquals(null, res[1427].exec("X\x09X\x0b", 4357));
+assertEquals(null, res[1427].exec("** Failers", 4358));
+assertEquals(null, res[1427].exec("x{a0} X\n   ", 4359));
+assertEquals(null, res[1428].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4360));
+assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 4361));
+assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b\x0c", 4362));
+assertEquals(null, res[1428].exec("** Failers ", 4363));
+assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b", 4364));
+assertEquals(null, res[1428].exec(" ", 4365));
+assertEquals(null, res[1429].exec("x{3001}x{3000}x{2030}x{2028}", 4366));
+assertEquals(null, res[1429].exec("Xx{180e}Xx{85}", 4367));
+assertEquals(null, res[1429].exec("** Failers", 4368));
+assertEquals(null, res[1429].exec("x{2009} X\n   ", 4369));
+assertEquals(null, res[1430].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 4370));
+assertEquals(null, res[1430].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 4371));
+assertEquals(null, res[1430].exec("\x09 x{202f}\n\x0b\x0c", 4372));
+assertEquals(null, res[1430].exec("** Failers ", 4373));
+assertEquals(null, res[1430].exec("\x09x{200a}x{a0}x{2028}\x0b", 4374));
+assertEquals(null, res[1430].exec(" ", 4375));
+assertEquals(null, res[1431].exec("a\x0db", 4376));
+assertEquals(null, res[1431].exec("a\nb", 4377));
+assertEquals(null, res[1431].exec("a\x0d\nb", 4378));
+assertEquals(null, res[1431].exec("** Failers", 4379));
+assertEquals(null, res[1431].exec("ax{85}b", 4380));
+assertEquals(null, res[1431].exec("a\x0bb     ", 4381));
+assertEquals(null, res[1432].exec("a\x0db", 4382));
+assertEquals(null, res[1432].exec("a\nb", 4383));
+assertEquals(null, res[1432].exec("a\x0d\nb", 4384));
+assertEquals(null, res[1432].exec("ax{85}b", 4385));
+assertEquals(null, res[1432].exec("a\x0bb     ", 4386));
+assertEquals(null, res[1432].exec("** Failers ", 4387));
+assertEquals(null, res[1432].exec("ax{85}b<bsr_anycrlf>", 4388));
+assertEquals(null, res[1432].exec("a\x0bb<bsr_anycrlf>", 4389));
+assertEquals(null, res[1433].exec("a\x0db", 4390));
+assertEquals(null, res[1433].exec("a\nb", 4391));
+assertEquals(null, res[1433].exec("a\x0d\nb", 4392));
+assertEquals(null, res[1433].exec("** Failers", 4393));
+assertEquals(null, res[1433].exec("ax{85}b", 4394));
+assertEquals(null, res[1433].exec("a\x0bb     ", 4395));
+assertEquals(null, res[1434].exec("a\x0db", 4396));
+assertEquals(null, res[1434].exec("a\nb", 4397));
+assertEquals(null, res[1434].exec("a\x0d\nb", 4398));
+assertEquals(null, res[1434].exec("ax{85}b", 4399));
+assertEquals(null, res[1434].exec("a\x0bb     ", 4400));
+assertEquals(null, res[1434].exec("** Failers ", 4401));
+assertEquals(null, res[1434].exec("ax{85}b<bsr_anycrlf>", 4402));
+assertEquals(null, res[1434].exec("a\x0bb<bsr_anycrlf>", 4403));
+assertEquals("X", res[1435].exec("Ax{1ec5}ABCXYZ"), 4404);
+assertEquals(null, res[1437].exec("AB", 4405));
+assertEquals(null, res[1437].exec("*** Failers", 4406));
+assertEquals(null, res[1437].exec("A0", 4407));
+assertEquals(null, res[1437].exec("00   ", 4408));
+assertEquals(null, res[1438].exec("AB", 4409));
+assertEquals(null, res[1438].exec("Ax{300}BC ", 4410));
+assertEquals(null, res[1438].exec("Ax{300}x{301}x{302}BC ", 4411));
+assertEquals(null, res[1438].exec("*** Failers", 4412));
+assertEquals(null, res[1438].exec("x{300}  ", 4413));
+assertEquals(null, res[1439].exec("ABC", 4414));
+assertEquals(null, res[1439].exec("Ax{300}Bx{300}x{301}C ", 4415));
+assertEquals(null, res[1439].exec("Ax{300}x{301}x{302}BC ", 4416));
+assertEquals(null, res[1439].exec("*** Failers", 4417));
+assertEquals(null, res[1439].exec("x{300}  ", 4418));
+assertEquals(null, res[1440].exec("abcd", 4419));
+assertEquals(null, res[1440].exec("a ", 4420));
+assertEquals(null, res[1440].exec("*** Failers ", 4421));
+assertEquals(null, res[1441].exec("1234", 4422));
+assertEquals(null, res[1441].exec("= ", 4423));
+assertEquals(null, res[1441].exec("*** Failers ", 4424));
+assertEquals(null, res[1441].exec("abcd ", 4425));
+assertEquals(null, res[1442].exec("abcdAx{300}x{301}x{302}", 4426));
+assertEquals(null, res[1442].exec("Ax{300}x{301}x{302}", 4427));
+assertEquals(null, res[1442].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}", 4428));
+assertEquals(null, res[1442].exec("a ", 4429));
+assertEquals(null, res[1442].exec("*** Failers ", 4430));
+assertEquals(null, res[1442].exec("x{300}x{301}x{302}", 4431));
+assertEquals("abc", res[1443].exec("abc"), 4432);
+assertEquals("abc", res[1443].exec("Ax{300}abc"), 4433);
+assertEquals("abc", res[1443].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4434);
+assertEquals("abc", res[1443].exec("x{300}abc  "), 4435);
+assertEquals(null, res[1443].exec("*** Failers", 4436));
+assertEquals("abc", res[1444].exec("abc"), 4437);
+assertEquals(null, res[1444].exec("Ax{300}abc", 4438));
+assertEquals(null, res[1444].exec("*** Failers", 4439));
+assertEquals(null, res[1444].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4440));
+assertEquals(null, res[1444].exec("x{300}abc  ", 4441));
+assertEquals("abc", res[1445].exec("abc"), 4442);
+assertEquals("abc", res[1445].exec("Ax{300}abc"), 4443);
+assertEquals("abc", res[1445].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4444);
+assertEquals("abc", res[1445].exec("x{300}abc  "), 4445);
+assertEquals(null, res[1445].exec("*** Failers", 4446));
+assertEquals("abc", res[1446].exec("abc"), 4447);
+assertEquals(null, res[1446].exec("Ax{300}abc", 4448));
+assertEquals(null, res[1446].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4449));
+assertEquals(null, res[1446].exec("*** Failers", 4450));
+assertEquals(null, res[1446].exec("x{300}abc  ", 4451));
+assertEquals(null, res[1447].exec("A=b", 4452));
+assertEquals(null, res[1447].exec("=c ", 4453));
+assertEquals(null, res[1447].exec("*** Failers", 4454));
+assertEquals(null, res[1447].exec("1=2 ", 4455));
+assertEquals(null, res[1447].exec("AAAA=b  ", 4456));
+assertEquals(null, res[1448].exec("AAAA=b", 4457));
+assertEquals(null, res[1448].exec("=c ", 4458));
+assertEquals(null, res[1448].exec("*** Failers", 4459));
+assertEquals(null, res[1448].exec("1=2  ", 4460));
+assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4461));
+assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X ", 4462));
+assertEquals(null, res[1449].exec("*** Failers", 4463));
+assertEquals(null, res[1449].exec("X", 4464));
+assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}X", 4465));
+assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4466));
+assertEquals(null, res[1450].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 4467));
+assertEquals(null, res[1450].exec("\npx{300}9!$ < ", 4468));
+assertEquals(null, res[1450].exec("** Failers ", 4469));
+assertEquals(null, res[1450].exec("apx{300}9!$ < ", 4470));
+assertEquals(null, res[1451].exec("X", 4471));
+assertEquals(null, res[1451].exec("** Failers ", 4472));
+assertEquals(null, res[1451].exec("", 4473));
+assertEquals(null, res[1452].exec("9", 4474));
+assertEquals(null, res[1452].exec("** Failers ", 4475));
+assertEquals(null, res[1452].exec("x{c0}", 4476));
+assertEquals(null, res[1453].exec("X", 4477));
+assertEquals(null, res[1453].exec("** Failers ", 4478));
+assertEquals(null, res[1453].exec("x{30f}", 4479));
+assertEquals(null, res[1454].exec("X", 4480));
+assertEquals(null, res[1454].exec("** Failers ", 4481));
+assertEquals(null, res[1454].exec("x{660}", 4482));
+assertEquals(null, res[1455].exec("X", 4483));
+assertEquals(null, res[1455].exec("** Failers ", 4484));
+assertEquals(null, res[1455].exec("x{66c}", 4485));
+assertEquals(null, res[1456].exec("X", 4486));
+assertEquals(null, res[1456].exec("** Failers ", 4487));
+assertEquals(null, res[1456].exec("x{f01}", 4488));
+assertEquals(null, res[1457].exec("X", 4489));
+assertEquals(null, res[1457].exec("** Failers ", 4490));
+assertEquals(null, res[1457].exec("x{1680}", 4491));
+assertEquals(null, res[1458].exec("x{017}", 4492));
+assertEquals(null, res[1458].exec("x{09f} ", 4493));
+assertEquals(null, res[1458].exec("** Failers", 4494));
+assertEquals(null, res[1458].exec("x{0600} ", 4495));
+assertEquals(null, res[1459].exec("x{601}", 4496));
+assertEquals(null, res[1459].exec("** Failers", 4497));
+assertEquals(null, res[1459].exec("x{09f} ", 4498));
+assertEquals(null, res[1460].exec("** Failers", 4499));
+assertEquals(null, res[1460].exec("x{09f} ", 4500));
+assertEquals(null, res[1461].exec("x{f8ff}", 4501));
+assertEquals(null, res[1461].exec("** Failers", 4502));
+assertEquals(null, res[1461].exec("x{09f} ", 4503));
+assertEquals(null, res[1462].exec("?x{dfff}", 4504));
+assertEquals(null, res[1462].exec("** Failers", 4505));
+assertEquals(null, res[1462].exec("x{09f} ", 4506));
+assertEquals(null, res[1463].exec("a", 4507));
+assertEquals(null, res[1463].exec("** Failers ", 4508));
+assertEquals(null, res[1463].exec("Z", 4509));
+assertEquals(null, res[1463].exec("x{e000}  ", 4510));
+assertEquals(null, res[1464].exec("x{2b0}", 4511));
+assertEquals(null, res[1464].exec("** Failers", 4512));
+assertEquals(null, res[1464].exec("a ", 4513));
+assertEquals(null, res[1465].exec("x{1bb}", 4514));
+assertEquals(null, res[1465].exec("** Failers", 4515));
+assertEquals(null, res[1465].exec("a ", 4516));
+assertEquals(null, res[1465].exec("x{2b0}", 4517));
+assertEquals(null, res[1466].exec("x{1c5}", 4518));
+assertEquals(null, res[1466].exec("** Failers", 4519));
+assertEquals(null, res[1466].exec("a ", 4520));
+assertEquals(null, res[1466].exec("x{2b0}", 4521));
+assertEquals(null, res[1467].exec("A", 4522));
+assertEquals(null, res[1467].exec("** Failers", 4523));
+assertEquals(null, res[1467].exec("x{2b0}", 4524));
+assertEquals(null, res[1468].exec("x{903}", 4525));
+assertEquals(null, res[1468].exec("** Failers", 4526));
+assertEquals(null, res[1468].exec("X", 4527));
+assertEquals(null, res[1468].exec("x{300}", 4528));
+assertEquals(null, res[1468].exec("   ", 4529));
+assertEquals(null, res[1469].exec("x{488}", 4530));
+assertEquals(null, res[1469].exec("** Failers", 4531));
+assertEquals(null, res[1469].exec("X", 4532));
+assertEquals(null, res[1469].exec("x{903}", 4533));
+assertEquals(null, res[1469].exec("x{300}", 4534));
+assertEquals(null, res[1470].exec("x{300}", 4535));
+assertEquals(null, res[1470].exec("** Failers", 4536));
+assertEquals(null, res[1470].exec("X", 4537));
+assertEquals(null, res[1470].exec("x{903}", 4538));
+assertEquals(null, res[1470].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 4539));
+assertEquals(null, res[1470].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 4540));
+assertEquals(null, res[1470].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 4541));
+assertEquals(null, res[1470].exec("** Failers", 4542));
+assertEquals(null, res[1470].exec("X", 4543));
+assertEquals(null, res[1471].exec("x{16ee}", 4544));
+assertEquals(null, res[1471].exec("** Failers", 4545));
+assertEquals(null, res[1471].exec("X", 4546));
+assertEquals(null, res[1471].exec("x{966}", 4547));
+assertEquals(null, res[1472].exec("x{b2}", 4548));
+assertEquals(null, res[1472].exec("x{b3}", 4549));
+assertEquals(null, res[1472].exec("** Failers", 4550));
+assertEquals(null, res[1472].exec("X", 4551));
+assertEquals(null, res[1472].exec("x{16ee}", 4552));
+assertEquals(null, res[1473].exec("_", 4553));
+assertEquals(null, res[1473].exec("x{203f}", 4554));
+assertEquals(null, res[1473].exec("** Failers", 4555));
+assertEquals(null, res[1473].exec("X", 4556));
+assertEquals(null, res[1473].exec("-", 4557));
+assertEquals(null, res[1473].exec("x{58a}", 4558));
+assertEquals(null, res[1474].exec("-", 4559));
+assertEquals(null, res[1474].exec("x{58a}", 4560));
+assertEquals(null, res[1474].exec("** Failers", 4561));
+assertEquals(null, res[1474].exec("X", 4562));
+assertEquals(null, res[1474].exec("x{203f}", 4563));
+assertEquals(null, res[1475].exec(")", 4564));
+assertEquals(null, res[1475].exec("]", 4565));
+assertEquals(null, res[1475].exec("}", 4566));
+assertEquals(null, res[1475].exec("x{f3b}", 4567));
+assertEquals(null, res[1475].exec("** Failers", 4568));
+assertEquals(null, res[1475].exec("X", 4569));
+assertEquals(null, res[1475].exec("x{203f}", 4570));
+assertEquals(null, res[1475].exec("(", 4571));
+assertEquals(null, res[1475].exec("[", 4572));
+assertEquals(null, res[1475].exec("{", 4573));
+assertEquals(null, res[1475].exec("x{f3c}", 4574));
+assertEquals(null, res[1476].exec("x{bb}", 4575));
+assertEquals(null, res[1476].exec("x{2019}", 4576));
+assertEquals(null, res[1476].exec("** Failers", 4577));
+assertEquals(null, res[1476].exec("X", 4578));
+assertEquals(null, res[1476].exec("x{203f}", 4579));
+assertEquals(null, res[1477].exec("x{ab}", 4580));
+assertEquals(null, res[1477].exec("x{2018}", 4581));
+assertEquals(null, res[1477].exec("** Failers", 4582));
+assertEquals(null, res[1477].exec("X", 4583));
+assertEquals(null, res[1477].exec("x{203f}", 4584));
+assertEquals(null, res[1478].exec("!", 4585));
+assertEquals(null, res[1478].exec("x{37e}", 4586));
+assertEquals(null, res[1478].exec("** Failers", 4587));
+assertEquals(null, res[1478].exec("X", 4588));
+assertEquals(null, res[1478].exec("x{203f}", 4589));
+assertEquals(null, res[1479].exec("(", 4590));
+assertEquals(null, res[1479].exec("[", 4591));
+assertEquals(null, res[1479].exec("{", 4592));
+assertEquals(null, res[1479].exec("x{f3c}", 4593));
+assertEquals(null, res[1479].exec("** Failers", 4594));
+assertEquals(null, res[1479].exec("X", 4595));
+assertEquals(null, res[1479].exec(")", 4596));
+assertEquals(null, res[1479].exec("]", 4597));
+assertEquals(null, res[1479].exec("}", 4598));
+assertEquals(null, res[1479].exec("x{f3b}", 4599));
+assertEquals(null, res[1479].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 4600));
+assertEquals(null, res[1479].exec("x{9f2}", 4601));
+assertEquals(null, res[1479].exec("** Failers", 4602));
+assertEquals(null, res[1479].exec("X", 4603));
+assertEquals(null, res[1479].exec("x{2c2}", 4604));
+assertEquals(null, res[1480].exec("x{2c2}", 4605));
+assertEquals(null, res[1480].exec("** Failers", 4606));
+assertEquals(null, res[1480].exec("X", 4607));
+assertEquals(null, res[1480].exec("x{9f2}", 4608));
+assertEquals(null, res[1480].exec("+<|~x{ac}x{2044}", 4609));
+assertEquals(null, res[1480].exec("** Failers", 4610));
+assertEquals(null, res[1480].exec("X", 4611));
+assertEquals(null, res[1480].exec("x{9f2}", 4612));
+assertEquals(null, res[1481].exec("x{a6}", 4613));
+assertEquals(null, res[1481].exec("x{482} ", 4614));
+assertEquals(null, res[1481].exec("** Failers", 4615));
+assertEquals(null, res[1481].exec("X", 4616));
+assertEquals(null, res[1481].exec("x{9f2}", 4617));
+assertEquals(null, res[1482].exec("x{2028}", 4618));
+assertEquals(null, res[1482].exec("** Failers", 4619));
+assertEquals(null, res[1482].exec("X", 4620));
+assertEquals(null, res[1482].exec("x{2029}", 4621));
+assertEquals(null, res[1483].exec("x{2029}", 4622));
+assertEquals(null, res[1483].exec("** Failers", 4623));
+assertEquals(null, res[1483].exec("X", 4624));
+assertEquals(null, res[1483].exec("x{2028}", 4625));
+assertEquals(null, res[1484].exec("\\ \\", 4626));
+assertEquals(null, res[1484].exec("x{a0}", 4627));
+assertEquals(null, res[1484].exec("x{1680}", 4628));
+assertEquals(null, res[1484].exec("x{180e}", 4629));
+assertEquals(null, res[1484].exec("x{2000}", 4630));
+assertEquals(null, res[1484].exec("x{2001}     ", 4631));
+assertEquals(null, res[1484].exec("** Failers", 4632));
+assertEquals(null, res[1484].exec("x{2028}", 4633));
+assertEquals(null, res[1484].exec("x{200d} ", 4634));
+assertEquals(null, res[1484].exec("  x{660}x{661}x{662}ABC", 4635));
+assertEquals(null, res[1484].exec("  x{660}x{661}x{662}ABC", 4636));
+assertEquals(null, res[1485].exec("  x{660}x{661}x{662}ABC", 4637));
+assertEquals(null, res[1486].exec("  x{660}x{661}x{662}ABC", 4638));
+assertEquals(null, res[1487].exec("  x{660}x{661}x{662}ABC", 4639));
+assertEquals(null, res[1488].exec("  x{660}x{661}x{662}ABC", 4640));
+assertEquals(null, res[1489].exec("  x{660}x{661}x{662}ABC", 4641));
+assertEquals(null, res[1490].exec("  x{660}x{661}x{662}ABC", 4642));
+assertEquals(null, res[1491].exec("  x{660}x{661}x{662}ABC", 4643));
+assertEquals(null, res[1492].exec("  x{660}x{661}x{662}ABC", 4644));
+assertEquals(null, res[1493].exec("  x{660}x{661}x{662}ABC", 4645));
+assertEquals(null, res[1493].exec("  x{660}x{661}x{662}ABC", 4646));
+assertEquals(null, res[1493].exec("  x{660}x{661}x{662}ABC", 4647));
+assertEquals(null, res[1493].exec("  ** Failers", 4648));
+assertEquals(null, res[1493].exec("  x{660}x{661}x{662}ABC", 4649));
+assertEquals(null, res[1494].exec("A", 4650));
+assertEquals(null, res[1494].exec("ax{10a0}B ", 4651));
+assertEquals(null, res[1494].exec("** Failers ", 4652));
+assertEquals(null, res[1494].exec("a", 4653));
+assertEquals(null, res[1494].exec("x{1d00}  ", 4654));
+assertEquals(null, res[1495].exec("1234", 4655));
+assertEquals(null, res[1495].exec("** Failers", 4656));
+assertEquals(null, res[1495].exec("ABC ", 4657));
+assertEquals(null, res[1496].exec("1234", 4658));
+assertEquals(null, res[1496].exec("** Failers", 4659));
+assertEquals(null, res[1496].exec("ABC ", 4660));
+assertEquals(null, res[1496].exec("A2XYZ", 4661));
+assertEquals(null, res[1496].exec("123A5XYZPQR", 4662));
+assertEquals(null, res[1496].exec("ABAx{660}XYZpqr", 4663));
+assertEquals(null, res[1496].exec("** Failers", 4664));
+assertEquals(null, res[1496].exec("AXYZ", 4665));
+assertEquals(null, res[1496].exec("XYZ     ", 4666));
+assertEquals(null, res[1496].exec("1XYZ", 4667));
+assertEquals(null, res[1496].exec("AB=XYZ.. ", 4668));
+assertEquals(null, res[1496].exec("XYZ ", 4669));
+assertEquals(null, res[1496].exec("** Failers", 4670));
+assertEquals(null, res[1496].exec("WXYZ ", 4671));
+assertEquals(null, res[1497].exec("1234", 4672));
+assertEquals(null, res[1497].exec("1234", 4673));
+assertEquals(null, res[1497].exec("12-34", 4674));
+assertEquals("{", res[1497].exec("12+x{661}-34  "), 4675);
+assertEquals(null, res[1497].exec("** Failers", 4676));
+assertEquals("d", res[1497].exec("abcd  "), 4677);
+assertEquals("d", res[1498].exec("abcd"), 4678);
+assertEquals(null, res[1498].exec("** Failers", 4679));
+assertEquals(null, res[1498].exec("1234", 4680));
+assertEquals(null, res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4681));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4682);
+assertEquals(" ", res[1499].exec(" "), 4683);
+assertEquals(null, res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4684));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4685);
+assertEquals(null, res[1500].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4686));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1500].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4687);
+assertEquals(null, res[1501].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4688));
+assertEquals(null, res[1501].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 4689));
+assertEquals(null, res[1502].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4690));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1502].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4691);
+assertEquals(null, res[1503].exec("a", 4692));
+assertEquals(null, res[1503].exec("A ", 4693));
+assertEquals(null, res[1504].exec("a", 4694));
+assertEquals(null, res[1504].exec("A ", 4695));
+assertEquals(null, res[1505].exec("A", 4696));
+assertEquals(null, res[1505].exec("aZ", 4697));
+assertEquals(null, res[1505].exec("** Failers", 4698));
+assertEquals(null, res[1505].exec("abc   ", 4699));
+assertEquals(null, res[1506].exec("A", 4700));
+assertEquals(null, res[1506].exec("aZ", 4701));
+assertEquals(null, res[1506].exec("** Failers", 4702));
+assertEquals(null, res[1506].exec("abc   ", 4703));
+assertEquals(null, res[1507].exec("a", 4704));
+assertEquals(null, res[1507].exec("Az", 4705));
+assertEquals(null, res[1507].exec("** Failers", 4706));
+assertEquals(null, res[1507].exec("ABC   ", 4707));
+assertEquals(null, res[1508].exec("a", 4708));
+assertEquals(null, res[1508].exec("Az", 4709));
+assertEquals(null, res[1508].exec("** Failers", 4710));
+assertEquals(null, res[1508].exec("ABC   ", 4711));
+assertEquals(null, res[1508].exec("x{c0}", 4712));
+assertEquals(null, res[1508].exec("x{e0} ", 4713));
+assertEquals(null, res[1508].exec("x{c0}", 4714));
+assertEquals(null, res[1508].exec("x{e0} ", 4715));
+assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4716));
+assertEquals(null, res[1508].exec("** Failers", 4717));
+assertEquals(null, res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 4718));
+assertEquals(null, res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4719));
+assertEquals(null, res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4720));
+assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4721));
+assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4722));
+assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4723));
+assertEquals(null, res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0}   ", 4724));
+assertEquals(null, res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4725));
+assertEquals(null, res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4726));
+assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4727));
+assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4728));
+assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 4729));
+assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4730));
+assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4731));
+assertEquals(null, res[1508].exec("x{391}", 4732));
+assertEquals(null, res[1508].exec("x{ff3a}", 4733));
+assertEquals(null, res[1508].exec("x{3b1}", 4734));
+assertEquals(null, res[1508].exec("x{ff5a}   ", 4735));
+assertEquals(null, res[1508].exec("x{c0}", 4736));
+assertEquals(null, res[1508].exec("x{e0} ", 4737));
+assertEquals(null, res[1508].exec("x{104}", 4738));
+assertEquals(null, res[1508].exec("x{105}", 4739));
+assertEquals(null, res[1508].exec("x{109}  ", 4740));
+assertEquals(null, res[1508].exec("** Failers", 4741));
+assertEquals(null, res[1508].exec("x{100}", 4742));
+assertEquals(null, res[1508].exec("x{10a} ", 4743));
+assertEquals(null, res[1508].exec("Z", 4744));
+assertEquals(null, res[1508].exec("z", 4745));
+assertEquals(null, res[1508].exec("x{39c}", 4746));
+assertEquals(null, res[1508].exec("x{178}", 4747));
+assertEquals(null, res[1508].exec("|", 4748));
+assertEquals(null, res[1508].exec("x{80}", 4749));
+assertEquals(null, res[1508].exec("x{ff}", 4750));
+assertEquals(null, res[1508].exec("x{100}", 4751));
+assertEquals(null, res[1508].exec("x{101} ", 4752));
+assertEquals(null, res[1508].exec("** Failers", 4753));
+assertEquals(null, res[1508].exec("x{102}", 4754));
+assertEquals(null, res[1508].exec("Y", 4755));
+assertEquals(null, res[1508].exec("y           ", 4756));
+assertEquals(null, res[1509].exec("A", 4757));
+assertEquals(null, res[1509].exec("Ax{300}BC ", 4758));
+assertEquals(null, res[1509].exec("Ax{300}x{301}x{302}BC ", 4759));
+assertEquals(null, res[1509].exec("*** Failers", 4760));
+assertEquals(null, res[1509].exec("x{300}  ", 4761));
+assertEquals("X", res[1510].exec("X123"), 4762);
+assertEquals(null, res[1510].exec("*** Failers", 4763));
+assertEquals(null, res[1510].exec("AXYZ", 4764));
+assertEquals(null, res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4765));
+assertEquals(null, res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4766));
+assertEquals(null, res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4767));
+assertEquals(null, res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4768));
+assertEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4769);
+assertEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4770);
+assertEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4771);
+assertEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4772);
+assertEquals(null, res[1515].exec("*** Failers", 4773));
+assertEquals(null, res[1515].exec("Ax{300}x{301}x{302}", 4774));
+assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}X", 4775));
+assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4776));
+assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4777));
+assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4778));
+assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}X", 4779));
+assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4780));
+assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4781));
+assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4782));
+assertEquals(null, res[1518].exec("12X", 4783));
+assertEquals(null, res[1518].exec("123X", 4784));
+assertEquals(null, res[1518].exec("*** Failers", 4785));
+assertEquals(null, res[1518].exec("X", 4786));
+assertEquals(null, res[1518].exec("1X", 4787));
+assertEquals(null, res[1518].exec("1234X     ", 4788));
+assertEquals(null, res[1518].exec("x{100}   ", 4789));
+assertEquals(null, res[1518].exec("x{101} ", 4790));
+assertEquals(null, res[1518].exec("x{2e81}x{3007}x{2f804}x{31a0}", 4791));
+assertEquals(null, res[1518].exec("** Failers", 4792));
+assertEquals(null, res[1518].exec("x{2e7f}  ", 4793));
+assertEquals(null, res[1518].exec("x{3105}", 4794));
+assertEquals(null, res[1518].exec("** Failers", 4795));
+assertEquals(null, res[1518].exec("x{30ff}  ", 4796));
+assertEquals(null, res[1519].exec("x{06e9}", 4797));
+assertEquals(null, res[1519].exec("x{060b}", 4798));
+assertEquals(null, res[1519].exec("** Failers", 4799));
+assertEquals(null, res[1519].exec("Xx{06e9}   ", 4800));
+assertEquals(null, res[1520].exec("x{2f800}", 4801));
+assertEquals(null, res[1520].exec("** Failers", 4802));
+assertEquals(null, res[1520].exec("x{a014}", 4803));
+assertEquals(null, res[1520].exec("x{a4c6}   ", 4804));
+assertEquals(null, res[1521].exec("AXYZ", 4805));
+assertEquals(null, res[1521].exec("x{1234}XYZ ", 4806));
+assertEquals(null, res[1521].exec("** Failers", 4807));
+assertEquals(null, res[1521].exec("X  ", 4808));
+assertEquals(null, res[1522].exec("** Failers", 4809));
+assertEquals(null, res[1522].exec("AX", 4810));
+assertEquals(null, res[1523].exec("XYZ", 4811));
+assertEquals(null, res[1523].exec("AXYZ", 4812));
+assertEquals(null, res[1523].exec("x{1234}XYZ ", 4813));
+assertEquals(null, res[1523].exec("** Failers", 4814));
+assertEquals(null, res[1523].exec("ABXYZ   ", 4815));
+assertEquals(null, res[1524].exec("XYZ", 4816));
+assertEquals(null, res[1524].exec("** Failers", 4817));
+assertEquals(null, res[1524].exec("AXYZ", 4818));
+assertEquals(null, res[1524].exec("x{1234}XYZ ", 4819));
+assertEquals(null, res[1524].exec("ABXYZ   ", 4820));
+assertEquals(null, res[1524].exec("AXYZ", 4821));
+assertEquals(null, res[1524].exec("x{1234}XYZ", 4822));
+assertEquals(null, res[1524].exec("Ax{1234}XYZ", 4823));
+assertEquals(null, res[1524].exec("** Failers", 4824));
+assertEquals(null, res[1524].exec("XYZ", 4825));
+assertEquals(null, res[1524].exec("** Failers", 4826));
+assertEquals(null, res[1524].exec("AXYZ", 4827));
+assertEquals(null, res[1524].exec("x{1234}XYZ", 4828));
+assertEquals(null, res[1524].exec("Ax{1234}XYZ", 4829));
+assertEquals(null, res[1524].exec("XYZ", 4830));
+assertEquals(null, res[1525].exec("XYZ", 4831));
+assertEquals(null, res[1525].exec("AXYZ", 4832));
+assertEquals(null, res[1525].exec("x{1234}XYZ", 4833));
+assertEquals(null, res[1525].exec("Ax{1234}XYZ", 4834));
+assertEquals(null, res[1525].exec("** Failers", 4835));
+assertEquals(null, res[1526].exec("XYZ", 4836));
+assertEquals(null, res[1526].exec("** Failers", 4837));
+assertEquals(null, res[1526].exec("AXYZ", 4838));
+assertEquals(null, res[1526].exec("x{1234}XYZ", 4839));
+assertEquals(null, res[1526].exec("Ax{1234}XYZ", 4840));
+assertEquals("AX", res[1527].exec("AXYZ"), 4841);
+assertEquals(null, res[1527].exec("x{1234}XYZ ", 4842));
+assertEquals(null, res[1527].exec("** Failers", 4843));
+assertEquals(null, res[1527].exec("X  ", 4844));
+assertEquals(null, res[1528].exec("** Failers", 4845));
+assertEquals("AX", res[1528].exec("AX"), 4846);
+assertEquals("X", res[1529].exec("XYZ"), 4847);
+assertEquals("AX", res[1529].exec("AXYZ"), 4848);
+assertEquals(null, res[1529].exec("x{1234}XYZ ", 4849));
+assertEquals(null, res[1529].exec("** Failers", 4850));
+assertEquals(null, res[1529].exec("ABXYZ   ", 4851));
+assertEquals("X", res[1530].exec("XYZ"), 4852);
+assertEquals(null, res[1530].exec("** Failers", 4853));
+assertEquals("AX", res[1530].exec("AXYZ"), 4854);
+assertEquals(null, res[1530].exec("x{1234}XYZ ", 4855));
+assertEquals(null, res[1530].exec("ABXYZ   ", 4856));
+assertEquals("AX", res[1531].exec("AXYZ"), 4857);
+assertEquals(null, res[1531].exec("x{1234}XYZ", 4858));
+assertEquals(null, res[1531].exec("Ax{1234}XYZ", 4859));
+assertEquals(null, res[1531].exec("** Failers", 4860));
+assertEquals(null, res[1531].exec("XYZ", 4861));
+assertEquals(null, res[1532].exec("** Failers", 4862));
+assertEquals("AX", res[1532].exec("AXYZ"), 4863);
+assertEquals(null, res[1532].exec("x{1234}XYZ", 4864));
+assertEquals(null, res[1532].exec("Ax{1234}XYZ", 4865));
+assertEquals(null, res[1532].exec("XYZ", 4866));
+assertEquals("X", res[1533].exec("XYZ"), 4867);
+assertEquals("AX", res[1533].exec("AXYZ"), 4868);
+assertEquals(null, res[1533].exec("x{1234}XYZ", 4869));
+assertEquals(null, res[1533].exec("Ax{1234}XYZ", 4870));
+assertEquals(null, res[1533].exec("** Failers", 4871));
+assertEquals("X", res[1534].exec("XYZ"), 4872);
+assertEquals(null, res[1534].exec("** Failers", 4873));
+assertEquals("AX", res[1534].exec("AXYZ"), 4874);
+assertEquals(null, res[1534].exec("x{1234}XYZ", 4875));
+assertEquals(null, res[1534].exec("Ax{1234}XYZ", 4876));
+assertEquals(null, res[1535].exec("abcdefgh", 4877));
+assertEquals(null, res[1535].exec("x{1234}\n\x0dx{3456}xyz ", 4878));
+assertEquals(null, res[1536].exec("abcdefgh", 4879));
+assertEquals(null, res[1536].exec("x{1234}\n\x0dx{3456}xyz ", 4880));
+assertEquals(null, res[1537].exec("** Failers", 4881));
+assertEquals(null, res[1537].exec("abcdefgh", 4882));
+assertEquals(null, res[1537].exec("x{1234}\n\x0dx{3456}xyz ", 4883));
+assertEquals(null, res[1538].exec(" AXY", 4884));
+assertEquals(null, res[1538].exec(" aXY", 4885));
+assertEquals(null, res[1538].exec(" x{1c5}XY", 4886));
+assertEquals(null, res[1538].exec(" ** Failers", 4887));
+assertEquals(null, res[1538].exec(" x{1bb}XY", 4888));
+assertEquals(null, res[1538].exec(" x{2b0}XY", 4889));
+assertEquals(null, res[1538].exec(" !XY      ", 4890));
+assertEquals(null, res[1539].exec(" AXY", 4891));
+assertEquals(null, res[1539].exec(" aXY", 4892));
+assertEquals(null, res[1539].exec(" x{1c5}XY", 4893));
+assertEquals(null, res[1539].exec(" ** Failers", 4894));
+assertEquals(null, res[1539].exec(" x{1bb}XY", 4895));
+assertEquals(null, res[1539].exec(" x{2b0}XY", 4896));
+assertEquals(null, res[1539].exec(" !XY      ", 4897));
+assertEquals(null, res[1539].exec(" AXY", 4898));
+assertEquals(null, res[1539].exec(" aXY", 4899));
+assertEquals(null, res[1539].exec(" AbcdeXyz ", 4900));
+assertEquals(null, res[1539].exec(" x{1c5}AbXY", 4901));
+assertEquals(null, res[1539].exec(" abcDEXypqreXlmn ", 4902));
+assertEquals(null, res[1539].exec(" ** Failers", 4903));
+assertEquals(null, res[1539].exec(" x{1bb}XY", 4904));
+assertEquals(null, res[1539].exec(" x{2b0}XY", 4905));
+assertEquals(null, res[1539].exec(" !XY      ", 4906));
+assertEquals(null, res[1540].exec(" AXY", 4907));
+assertEquals(null, res[1540].exec(" aXY", 4908));
+assertEquals(null, res[1540].exec(" AbcdeXyz ", 4909));
+assertEquals(null, res[1540].exec(" x{1c5}AbXY", 4910));
+assertEquals(null, res[1540].exec(" abcDEXypqreXlmn ", 4911));
+assertEquals(null, res[1540].exec(" ** Failers", 4912));
+assertEquals(null, res[1540].exec(" x{1bb}XY", 4913));
+assertEquals(null, res[1540].exec(" x{2b0}XY", 4914));
+assertEquals(null, res[1540].exec(" !XY      ", 4915));
+assertEquals(null, res[1540].exec(" AXY", 4916));
+assertEquals(null, res[1540].exec(" aXY", 4917));
+assertEquals(null, res[1540].exec(" AbcdeXyz ", 4918));
+assertEquals(null, res[1540].exec(" x{1c5}AbXY", 4919));
+assertEquals(null, res[1540].exec(" abcDEXypqreXlmn ", 4920));
+assertEquals(null, res[1540].exec(" ** Failers", 4921));
+assertEquals(null, res[1540].exec(" x{1bb}XY", 4922));
+assertEquals(null, res[1540].exec(" x{2b0}XY", 4923));
+assertEquals(null, res[1540].exec(" !XY      ", 4924));
+assertEquals(null, res[1541].exec(" AXY", 4925));
+assertEquals(null, res[1541].exec(" aXY", 4926));
+assertEquals(null, res[1541].exec(" AbcdeXyz ", 4927));
+assertEquals(null, res[1541].exec(" x{1c5}AbXY", 4928));
+assertEquals(null, res[1541].exec(" abcDEXypqreXlmn ", 4929));
+assertEquals(null, res[1541].exec(" ** Failers", 4930));
+assertEquals(null, res[1541].exec(" x{1bb}XY", 4931));
+assertEquals(null, res[1541].exec(" x{2b0}XY", 4932));
+assertEquals(null, res[1541].exec(" !XY      ", 4933));
+assertEquals(null, res[1542].exec(" !XY", 4934));
+assertEquals(null, res[1542].exec(" x{1bb}XY", 4935));
+assertEquals(null, res[1542].exec(" x{2b0}XY", 4936));
+assertEquals(null, res[1542].exec(" ** Failers", 4937));
+assertEquals(null, res[1542].exec(" x{1c5}XY", 4938));
+assertEquals(null, res[1542].exec(" AXY      ", 4939));
+assertEquals(null, res[1543].exec(" !XY", 4940));
+assertEquals(null, res[1543].exec(" x{1bb}XY", 4941));
+assertEquals(null, res[1543].exec(" x{2b0}XY", 4942));
+assertEquals(null, res[1543].exec(" ** Failers", 4943));
+assertEquals(null, res[1543].exec(" x{1c5}XY", 4944));
+assertEquals(null, res[1543].exec(" AXY      ", 4945));
+assertEquals(null, res[1543].exec("x{c0}x{e0}x{116}x{117}", 4946));
+assertEquals(null, res[1543].exec("x{c0}x{e0}x{116}x{117}", 4947));
+assertEquals(null, res[1545].exec("123abcdefg", 4948));
+assertEquals(null, res[1545].exec("123abc\xc4\xc5zz", 4949));
+assertEquals(null, res[1546].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 4950));
+assertEquals(null, res[1546].exec("x{a77d}x{1d79}", 4951));
+assertEquals(null, res[1546].exec("x{1d79}x{a77d} ", 4952));
+assertEquals(null, res[1546].exec("x{a77d}x{1d79}", 4953));
+assertEquals(null, res[1546].exec("** Failers ", 4954));
+assertEquals(null, res[1546].exec("x{1d79}x{a77d} ", 4955));
 assertThrows("var re = //;", 4956);
diff --git a/test/mjsunit/tools/codemap.js b/test/mjsunit/tools/codemap.js
index 33d7e4e0..81fb8101 100644
--- a/test/mjsunit/tools/codemap.js
+++ b/test/mjsunit/tools/codemap.js
@@ -157,7 +157,6 @@ function assertNoEntry(codeMap, addr) {
   codeMap.addStaticCode(0x15500, newCodeEntry(0x5000, 'lib2'));
   codeMap.addStaticCode(0x155500, newCodeEntry(0x10000, 'lib3'));
   var allStatics = codeMap.getAllStaticEntries();
-  allStatics = allStatics.map(String);
   allStatics.sort();
   assertEquals(['lib1: 3000', 'lib2: 5000', 'lib3: 10000'], allStatics);
 })();
@@ -169,15 +168,13 @@ function assertNoEntry(codeMap, addr) {
   codeMap.addCode(0x1700, newCodeEntry(0x100, 'code2'));
   codeMap.addCode(0x1900, newCodeEntry(0x50, 'code3'));
   var allDynamics = codeMap.getAllDynamicEntries();
-  allDynamics = allDynamics.map(String);
   allDynamics.sort();
   assertEquals(['code1: 200', 'code2: 100', 'code3: 50'], allDynamics);
   codeMap.deleteCode(0x1700);
   var allDynamics2 = codeMap.getAllDynamicEntries();
-  allDynamics2 = allDynamics2.map(String);
   allDynamics2.sort();
   assertEquals(['code1: 200', 'code3: 50'], allDynamics2);
   codeMap.deleteCode(0x1500);
   var allDynamics3 = codeMap.getAllDynamicEntries();
-  assertEquals(['code3: 50'], allDynamics3.map(String));
+  assertEquals(['code3: 50'], allDynamics3);
 })();
diff --git a/test/mjsunit/tools/splaytree.js b/test/mjsunit/tools/splaytree.js
index d582dc97..5e18796d 100644
--- a/test/mjsunit/tools/splaytree.js
+++ b/test/mjsunit/tools/splaytree.js
@@ -81,13 +81,13 @@ function createSampleTree() {
 (function testSplay() {
   var tree = new SplayTree();
   tree.root_ = createSampleTree();
-  assertArrayEquals([50, 30, 60, 10, 40, 90, 20, 70, 100, 15, 80],
+  assertArrayEquals(['50', '30', '60', '10', '40', '90', '20', '70', '100', '15', '80'],
                     tree.exportValues());
   tree.splay_(50);
-  assertArrayEquals([50, 30, 60, 10, 40, 90, 20, 70, 100, 15, 80],
+  assertArrayEquals(['50', '30', '60', '10', '40', '90', '20', '70', '100', '15', '80'],
                     tree.exportValues());
   tree.splay_(80);
-  assertArrayEquals([80, 60, 90, 50, 70, 100, 30, 10, 40, 20, 15],
+  assertArrayEquals(['80', '60', '90', '50', '70', '100', '30', '10', '40', '20', '15'],
                     tree.exportValues());
 })();
 
diff --git a/test/sputnik/testcfg.py b/test/sputnik/testcfg.py
index c9eb4f21..c1e3c1bb 100644
--- a/test/sputnik/testcfg.py
+++ b/test/sputnik/testcfg.py
@@ -57,7 +57,7 @@ class SputnikTestCase(test.TestCase):
 
   def AfterRun(self, result):
     # Dispose the temporary file if everything looks okay.
-    if result is None or not result.HasPreciousOutput(): self.tmpfile.Dispose()
+    if not result.HasPreciousOutput(): self.tmpfile.Dispose()
     self.tmpfile = None
 
   def GetCommand(self):
diff --git a/tools/gyp/v8.gyp b/tools/gyp/v8.gyp
index a11d19a8..77a6194c 100644
--- a/tools/gyp/v8.gyp
+++ b/tools/gyp/v8.gyp
@@ -230,8 +230,7 @@
             '../../src',
           ],
           'sources': [
-            '<(SHARED_INTERMEDIATE_DIR)/libraries.cc',
-            '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries.cc',
+            '<(SHARED_INTERMEDIATE_DIR)/libraries-empty.cc',
             '<(INTERMEDIATE_DIR)/snapshot.cc',
           ],
           'actions': [
@@ -260,7 +259,6 @@
           ],
           'sources': [
             '<(SHARED_INTERMEDIATE_DIR)/libraries.cc',
-            '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries.cc',
             '../../src/snapshot-empty.cc',
           ],
           'conditions': [
@@ -724,10 +722,6 @@
               '../../src/regexp.js',
               '../../src/macros.py',
             ],
-	    'experimental_library_files': [
-	      '../../src/proxy.js',
-              '../../src/macros.py',
-	    ],
           },
           'actions': [
             {
@@ -738,6 +732,7 @@
               ],
               'outputs': [
                 '<(SHARED_INTERMEDIATE_DIR)/libraries.cc',
+                '<(SHARED_INTERMEDIATE_DIR)/libraries-empty.cc',
               ],
               'action': [
                 'python',
@@ -747,23 +742,6 @@
                 '<@(library_files)'
               ],
             },
-	    {
-              'action_name': 'js2c_experimental',
-              'inputs': [
-                '../../tools/js2c.py',
-                '<@(experimental_library_files)',
-              ],
-              'outputs': [
-                '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries.cc',
-              ],
-              'action': [
-                'python',
-                '../../tools/js2c.py',
-                '<@(_outputs)',
-                'EXPERIMENTAL',
-                '<@(experimental_library_files)'
-              ],
-            },
           ],
         },
         {
diff --git a/tools/js2c.py b/tools/js2c.py
index 8211ec58..2da132f5 100644..100755
--- a/tools/js2c.py
+++ b/tools/js2c.py
@@ -204,7 +204,7 @@ def ReadMacros(lines):
 
 
 HEADER_TEMPLATE = """\
-// Copyright 2011 Google Inc. All Rights Reserved.
+// Copyright 2008 Google Inc. All Rights Reserved.
 
 // This file was generated from .js source files by SCons.  If you
 // want to make changes to this file you should either change the
@@ -288,6 +288,7 @@ def JS2C(source, target, env):
 
   minifier = jsmin.JavaScriptMinifier()
 
+  source_lines_empty = []
   for module in modules:
     filename = str(module)
     debugger = filename.endswith('-debugger.js')
@@ -304,6 +305,7 @@ def JS2C(source, target, env):
     else:
       ids.append((id, len(lines)))
     source_lines.append(SOURCE_DECLARATION % { 'id': id, 'data': data })
+    source_lines_empty.append(SOURCE_DECLARATION % { 'id': id, 'data': data })
 
   # Build debugger support functions
   get_index_cases = [ ]
@@ -354,11 +356,25 @@ def JS2C(source, target, env):
   })
   output.close()
 
+  if len(target) > 1:
+    output = open(str(target[1]), "w")
+    output.write(HEADER_TEMPLATE % {
+      'builtin_count': len(ids) + len(debugger_ids),
+      'debugger_count': len(debugger_ids),
+      'source_lines': "\n".join(source_lines_empty),
+      'get_index_cases': "".join(get_index_cases),
+      'get_script_source_cases': "".join(get_script_source_cases),
+      'get_script_name_cases': "".join(get_script_name_cases),
+      'type': env['TYPE']
+    })
+    output.close()
+
 def main():
   natives = sys.argv[1]
-  type = sys.argv[2]
-  source_files = sys.argv[3:]
-  JS2C(source_files, [natives], { 'TYPE': type })
+  natives_empty = sys.argv[2]
+  type = sys.argv[3]
+  source_files = sys.argv[4:]
+  JS2C(source_files, [natives, natives_empty], { 'TYPE': type })
 
 if __name__ == "__main__":
   main()
diff --git a/tools/test.py b/tools/test.py
index c1840bb4..707e7254 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -117,8 +117,6 @@ class ProgressIndicator(object):
         start = time.time()
         output = case.Run()
         case.duration = (time.time() - start)
-      except BreakNowException:
-        self.terminate = True
       except IOError, e:
         assert self.terminate
         return
@@ -320,12 +318,6 @@ PROGRESS_INDICATORS = {
 # --- F r a m e w o r k ---
 # -------------------------
 
-class BreakNowException(Exception):
-  def __init__(self, value):
-    self.value = value
-  def __str__(self):
-    return repr(self.value)
-
 
 class CommandOutput(object):
 
@@ -387,12 +379,9 @@ class TestCase(object):
 
   def Run(self):
     self.BeforeRun()
-    result = None
+    result = "exception"
     try:
       result = self.RunCommand(self.GetCommand())
-    except:
-      self.terminate = True
-      raise BreakNowException("Used pressed CTRL+C or IO went wrong")
     finally:
       self.AfterRun(result)
     return result
@@ -434,7 +423,7 @@ class TestOutput(object):
              self.output.exit_code != -signal.SIGABRT
 
   def HasTimedOut(self):
-    return self.output.timed_out
+    return self.output.timed_out;
 
   def HasFailed(self):
     execution_failed = self.test.DidFail(self.output)
@@ -462,7 +451,7 @@ def Win32SetErrorMode(mode):
   prev_error_mode = SEM_INVALID_VALUE
   try:
     import ctypes
-    prev_error_mode = ctypes.windll.kernel32.SetErrorMode(mode)
+    prev_error_mode = ctypes.windll.kernel32.SetErrorMode(mode);
   except ImportError:
     pass
   return prev_error_mode
@@ -470,16 +459,16 @@ def Win32SetErrorMode(mode):
 def RunProcess(context, timeout, args, **rest):
   if context.verbose: print "#", " ".join(args)
   popen_args = args
-  prev_error_mode = SEM_INVALID_VALUE
+  prev_error_mode = SEM_INVALID_VALUE;
   if utils.IsWindows():
     popen_args = '"' + subprocess.list2cmdline(args) + '"'
     if context.suppress_dialogs:
       # Try to change the error mode to avoid dialogs on fatal errors. Don't
       # touch any existing error mode flags by merging the existing error mode.
       # See http://blogs.msdn.com/oldnewthing/archive/2004/07/27/198410.aspx.
-      error_mode = SEM_NOGPFAULTERRORBOX
-      prev_error_mode = Win32SetErrorMode(error_mode)
-      Win32SetErrorMode(error_mode | prev_error_mode)
+      error_mode = SEM_NOGPFAULTERRORBOX;
+      prev_error_mode = Win32SetErrorMode(error_mode);
+      Win32SetErrorMode(error_mode | prev_error_mode);
   process = subprocess.Popen(
     shell = utils.IsWindows(),
     args = popen_args,
@@ -527,7 +516,7 @@ def CheckedUnlink(name):
       os.unlink(name)
       return
     except OSError, e:
-      retry_count += 1
+      retry_count += 1;
       time.sleep(retry_count * 0.1)
   PrintError("os.unlink() " + str(e))
 
@@ -713,12 +702,7 @@ class Context(object):
 
 def RunTestCases(cases_to_run, progress, tasks):
   progress = PROGRESS_INDICATORS[progress](cases_to_run)
-  result = 0
-  try:
-    result = progress.Run(tasks)
-  except Exception, e:
-    print "\n", e
-  return result
+  return progress.Run(tasks)
 
 
 def BuildRequirements(context, requirements, mode, scons_flags):
@@ -1355,11 +1339,11 @@ def ShardTests(tests, options):
     print "shard-run not a valid number, should be in [1:shard-count]"
     print "defaulting back to running all tests"
     return tests
-  count = 0
+  count = 0;
   shard = []
   for test in tests:
     if count % options.shard_count == options.shard_run - 1:
-      shard.append(test)
+      shard.append(test);
     count += 1
   return shard