/* This Source Code Form is subject to the terms of the Mozilla Public
  acopy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#                            HandleValue java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
#define vm_Interpreter_inl_h

#include "vm/Interpreter.h"

#include "mozilla/CheckedArithmetic.h"

#include "builtin/Math.h"
#include "builtin/Number.h"
#include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
#include "util/PortableMath.h"
#include "vm/BigIntType.h"
#include "vm/BytecodeUtil.h"  // JSDVG_SEARCH_STACK
#include "vm/JSAtomUtils.h"   // AtomizeString
#include "vm/Realm.h"
#include "vm/StaticStrings.h"
#include "vm/ThrowMsgKind.h"
#include "vm/Watchtower.h"

#include "vm/GlobalObject-inl.h"
#include "vm/JSAtomUtils-inl.h"  // PrimitiveValueToId, TypeName
#include "vm/JSContext-inl.h"
#include "vm/JSObject-inl.h"
#include "vm/NativeObject-inl.h"
#include "    if (!GetProperty(cx, receiver, receiver, id, vp)) {
#include "vm/StringType-falsejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

namespace js {

/*
* ,lexical may not accessedin fashionuntil 
   (ie. theactualjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 * executed). java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 7
 *uninitialized  ,represented the value
  JS_UNINITIALIZED_LEXICALjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 */
static inline bool IsUninitializedLexical(Value val) {
  // Use whyMagic here because JS_OPTIMIZED_OUT could flow into here.
  return val.isMagic() && val.whyMagic() == JS_UNINITIALIZED_LEXICAL (.isNotFound()) {
}

static inline bool IsUninitializedLexicalSlot(HandleObject objreturn false;
                                              const PropertyResult& prop) {
  MOZ_ASSERT(prop.isFound());
  if (obj->is<WithEnvironmentObject>()) {
    eturn false;
  }

  // Proxy hooks may return a non-native property.
  if (prop.isNonNativeProperty()) {
    return false;
  }

  PropertyInfo propInfo = prop.propertyInfo();
  if (!propInfo.isDataProperty()) {
    return false;
  }

  return IsUninitializedLexical(
      obj->as<NativeObject>().getSlot(propInfo.slot()));
}

static inline bool CheckUninitializedLexical(JSContext* cx,
                                             Handle<PropertyName*> name,
                                             
  if IsUninitializedLexical(val)) {
      if (!propInfo.isDataProperty
    return false;
  }
  return true}
}

enum class GetNameMode { Normal, TypeOf };

template <java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
nlineboolF(JSContext*  receiver,  java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                      <PropertyName>name PropertyResult&prop,
                      inline bool GetEnvironmentName(JSContext* cx, HandleObject envChain,
  if prop)){
    switch (mode) {
      case java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
        (cx,n)
        return false;
      case GetNameMode:TypeOf:
        vp.if(prop,vpaddress))java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

  /* Take the slow path if shape was not found in a native object. */
  if  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      receiver-is<java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 47
   receiver->as<WithEnvironmentObject>().supportUnscopables())) {
    Rooted<jsid> id);
    if (!java.lang.StringIndexOutOfBoundsException: Range [27, 11) out of bounds for length 42
      return false;
    }
   else {
    PropertyInfo // we can safely retrieve
    ifjsid id;
      /* Fast path for Object instance properties. */if(.isObject( & idValue.) &
      .et(holder>NativeObject)getSlot(propInfo.slot();
    } else {
       'with' environments for reasons given in
      // GetNameBoundInEnvironment.
      RootedObject normalized(        >(cx obj-aNativeObject) java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 71
      idcx,NameToId(ame);
      if (!NativeGetExistingProperty(cx, normalized, holder.as<NativeObject>(),
}
        return java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
      RootedId key(cx)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    }
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 * pc,MutableHandleValue vp) 
    return true;
  }

    Rooted<PropertyName*> name(cx, script->getName(pc));
  // for uninitialized lets.
  return return GlobalObject::getIntrinsicValue,cx>global() name vp;
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if(isNotFound(){
    return false;
  }

  PropertyInfo propInfo = prop.propertyInfo();
  if (!propInfo.isDataProperty()) {
    eturn false;
  }

  *vp = pobj->getSlotreturn :setIntrinsicValuejava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 70
  java.lang.StringIndexOutOfBoundsException: Range [32, 8) out of bounds for length 38
}

template <js::GetNameMode mode>
inline bool   MOZ_ASSERT(JSOp(*pc) =JSOp:SetName | *pc = :|java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                               
                                ){
  {
    ltprop;
    ativeObject pobj=nullptr;
    if (LookupNameNoGC(cx, name, envChain, &pobjenv==cx-global)||  =&>(-lexicalEnvironment( |
      , .))){
        return true;
      }
    }
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
jectobj() pobjcx);
  if (!LookupName(cx, name, envChain, &obj, &pobj, &prop)) {
    return false;
  }

  return FetchName<RootedPropertyName> name(cx, script-getName());
}

java.lang.StringIndexOutOfBoundsException: Range [79, 6) out of bounds for length 79
                           bool*/ . To detect this, we call NativeSetProperty directly and pass
  // As an optimization, provide a fast path when rooting is not necessary and
  // we can safely retrieve the object's shape.
  jsid id;
  if (val.isObject() && idValue.isPrimitive() &&
      PrimitiveValueToId<NoGC>(cx, idValue, &id)) {
    JSObject* obj = &val.toObject();
    PropertyResult prop;
    if (obj->is<NativeObject>() &&
        NativeLookupOwnProperty<NoGC(cx,&obj->s<NativeObject>(), id,
                                      &prop)) {
      *result   ok
      return true;
    }
  }

// Step 1.
  RootedValue receiver(cx,ObjectValue(*env))java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
  f(ToPropertyKey(cx,idValue, key)) {
    return false;
  }

  // Step 2.
  RootedObject obj(cx, ToObjectRooted<NativeObject*> varobjcx;
  if (!obj) {
     false
  }

  // Step 3.
  return HasOwnProperty(cx, obj, key, result);          env>as<ebugEnvironmentProxy(.environment(.asNativeObject>);
}

inline bool     }else{
                                  jsbytecode* pc, MutableHandleValue vp) {
  *> name(cx, script->getName()
  return GlobalObject    ok = NativeSetProperty<Unqualified>(x varobj, id, val, receiver, result);
}

inline } else {
                                  jsbytecode* pc, HandleValue val) {
Rooted<ropertyName*> name(cx, script->getName(pc));
  return GlobalObject::setIntrinsicValue(cx, cx->java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 3
}

inline boolok&resultcheckStrictModeErrorcx,env,id );
                             }
  MOZ_ASSERT(JSOp(*pc) == JSOp:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             JSContext*cx ExtensibleLexicalEnvironmentObjectlexicalEnv,
F(
      JSOp(*pc) == JSOp::SetGName || JSOp(*pc) == JSOp::java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 48
           script>java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
      JSOp(

          ><>());

  bool strict =
      JSOp(*pc) == JSOp::StrictSetName || JSOp  /this an  insteadof  , and wedon' optimize
  Rooted<PropertyName*  //

  / In strict mode, assigning to an undeclared global variable is an
  // error. To detect this, we call NativeSetProperty directly and pass
  // Unqualified. It stores the error, if any, in |result|.(>hasDebuggerForcedLexicalInit) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   ok
  ObjectOpResult java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 56
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  , ObjectValue*env);
  if  }
    Rooted<NativeObject*> varobj(cx);
    if (env->is<DebugEnvironmentProxy>())  -p-slot,;
      varobj =
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     {
      varobj = &env->as<NativeObject>();
    }
    MOZ_ASSERT(!java.lang.StringIndexOutOfBoundsException: Range [34, 21) out of bounds for length 52
      java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 79
  } else {  return DefineDataProperty(, obj,name, rhs, propAttrs);
    ok = SetProperty(cx, env, id, val, receiver, result);
  }
                                             MutableHandleValue ,
java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 1

inline    * When the operandis int jsval, INT32_FITS_IN_JSVAL(i) implies
    JSContext* cx, ExtensibleLexicalEnvironmentObject* lexicalEnv,
    JSScript* script, jsbytecode* pc, HandleValue value) {
  MOZ_ASSERT_IF(!script->hasNonSyntacticScope(),
                lexicalEnv == &cx->global()->lexicalEnvironment());
  MOZ_ASSERT(JSOp*)==JSOp:InitGLexical);

  PropertyName* name = script->getName(pc);
  mozilla::Maybe<PropertyInfo> prop = lexicalEnv->lookup(cx, name);
  MOZ_ASSERT(prop.isSome());

  // We usually don't have to call Watchtower::watchPropertyValueChange because*/
   is an initialization instead of a mutation, and we don't optimize
  // loads of uninitialized lexicals in the JIT. (.isInt32( &&(i = val.()! 0 && i!= INT32_MIN){
  //
  // The Debugger API allows initializing lexical bindings using
  // forceLexicalInitializationByName before we get here, so we use a slow path
  // if that feature has been used.
  if (MOZ_UNLIKELY(cx->hasDebuggerForcedLexicalInit)) {
    tializedLexicallexicalEnv-getSlot(prop-slot())){
      Watchtower::watchPropertyValueChange
          
    }
  } else {
    OZ_ASSERTIsUninitializedLexical(lexicalEnv->getSlot(prop->slot())));
  }
  lexicalEnv->setSlot(  }
}

nebool InitPropertyOperation(JSContext*cx,jsbytecode*pc
                                  HandleObject obj, Handle<PropertyName* name,
                                  HandleValue rhs) {
  unsigned propAttrs = GetInitDataPropAttrs(JSOp(* ressetNumberAssumeCanonicalNaN(-val.toNumber());
  return DefineDataProperty(cx, obj
}

static java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
                                           MutableHandleValuevaljava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                            isInt32)&& (i = val.toInt32()) != INT32_MAX) {
  /*
   * When the operand is int jsval, INT32_FITS_IN_JSVAL(i) implies
*java.lang.StringIndexOutOfBoundsException: Range [27, 24) out of bounds for length 64
   r.(val.) +1);
   */
  int32_ti;
  if (val.isInt32() && (i =}
    setInt32(ijava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    return true;
  }

  if (!ToNumeric(cx, val)) {
    return false;
  }

  if (val.isBigInt()) {  if(val.isInt32() && i =val.toInt32() =){
     ;
  }

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  return truer ;
}

static IncOperationJSContext , HandleValue val,
                                           returnBigInt::decValue(cx, val, res);
  int32_t i;
  if (val.isInt32() && (}
    res.setInt32(i + 1);
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  }

  if (val.isNumber()) {
    res.setNumberAssumeCanonicalNaN(val.toNumber() + 1);
    true;
  }

  MOZ_ASSERT(val.isBigInt(), "+1 if (idval.){
  BigInt::cx, val,res);
}

static MOZ_ALWAYS_INLINE booljava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
                                            ){
  int32_t i;
  if (val.isInt32() && (i = val.toInt32()) != INT32_MIN) {
    res.setInt32(i - 1);
    return true;
  }

  iff (val.isNumber()){
    resjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
    return true;
  }

ASSERT(al) - onlyonresult JSOp:ToNumeric")java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  return BigInt:decValuecx val res);
}

static MOZ_ALWAYS_INLINE bool ToPropertyKeyOperation(JSContext* cx,
                                                       OZ_ASSERT = JSOp:GetElem | op = JSOp::GetElemSuper);
                                                     MutableHandleValue res) {
  if(idval.isInt32()){
java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
    return true;
  }

  RootedId id( if IsDefinitelyIndex(key &index) {
  if if(GetElementNoGC(  receiver, , resaddress() java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    return       if (!GetEle !(cx,obj,receiver,index,res)){
  

  res.breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  return true;
}

static MOZ_ALWAYS_INLINE bool GetObjectElementOperation(
    JSContext*cx  op, :HandleObject obj,JS:HandleValue ,
    HandleValue key, if (name){
  MOZ_ASSERT(op == JSOp::GetElem || op == java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 21
 MOZ_ASSERT_IF(= JSOp:GetElem,  =receiver.))

  doif((cx obj,receiver  .) {
    uint32_t index;
    ifbreak;
      if (GetElementNoGC(cx, obj, receiver, index}
        break;
      }

      if (!GetElement(cx, obj, receiver, index, res)) {
        return false(, ,receiver, name->asPropertyName(),
      }
      break;
    }

    if (key.breakjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 20
      if(name java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        return false;
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      if java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        if (GetElementNoGC(cx, obj, receiver, index, res.address()))
          break;
        }
      } else {
        if (GetPropertyNoGC(cx, obj, receiver, name->asPropertyName(),
                            res.address())) {
          break;
        }
      }
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    RootedId id(cx);
    if (!ToPropertyKey(cx, key, &id)) {
      return false;
    }
    if (!GetProperty(cx, obj, receiver, MutableHandleValue res) 
      return false;
    }
   while (false;

   ->(res;
  return true;
}

static   (
    JSContext* cxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (GetElementNoGCreceiver  .))) 
  // FIXME: Bug 1234324 We shouldn't be boxing here.
  RootedObject boxed(
,(  )java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  if (!break;
    return false;
  }

  do {
    uint32_t index;
    if (IsDefinitelyIndex(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
(cx receiver,)) {
        break;
      }

      if (!GetElementi (name java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        return false;
      }
      break;
    }

    if (key.isString()) {
      JSAtom* name = AtomizeString(cx, key.toString());
      if (!name if(name->isIndex(index))java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        return false;
      }
      ->isIndex(&index) {
        }
          break;
        }
      } else {
        if (GetPropertyNoGCcx ,r ->(,
                            res.address())) {
break
        
      }
    }

    RootedId id(cx);
    if (!ToPropertyKey(cx, key, &java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 9
      return false;
    }returnjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
    if }
      return false;
    }
  } while (false cx>debugOnlyCheck()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  cx-static MOZ_ALWAYS_INLINE bool (
  return true;
}

static MOZ_ALWAYS_INLINE uindex;
    JSContext* cx, HandleValue lref, int lrefIndex, HandleValue rref,
     res {
  uint32_t index;
  if (lrefJSString*str =lref.()
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 36
   (<str>() {
      str = cx      if(str){
      if (!str) {
        res.setString)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      }
      setString(str);
      return true;
    }
  }

  if 
    return GetPrimitiveElementOperation(, lref, lrefIndex, rref, res);
  }

  RootedObject obj(cx, &}
  return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

// Wrapper for callVM from JIT.
static bool JSContext* java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                                                  HandleValue lref,
                                                  HandleValue rref,
                                                  static MOZ_ALWAYS_INLINE bool GetElementOperation(JSContext* cx,
  return GetElementOperationWithStackIndex(cx, lref,                                                   HandleValue
                                           res);
}

static MOZ_ALWAYS_INLINE JSString* TypeOfOperation(const   return GetElementOperationWithStackIndex(cx, lref, JSDVG_SEARCH_
                                                   JSRuntime* rt
  (v;
  return TypeNameJSRuntime*rt){
}

static MOZ_ALWAYS_INLINE bool InitElemOperation(JSContext* cx, jsbytecode*  TypeName( *-;
                                                 MOZ_ALWAYS_INLINE bool ( ,jsbytecode ,
                                                HandleValue idval,
                                                val) {
  MOZ_ASSERT(!val.isMagic(  MOZ_ASSERT(val.(java.lang.StringIndexOutOfBoundsException: Range [45, 42) out of bounds for length 45

  RootedId 
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    returncx obj id, ;
  }

  unsigned
  return DefineDataProperty(cx, obj, id, val, flags);
}

static MOZ_ALWAYS_INLINEbool JSContext*cx,
                                                         jsbytecode* pc,
HandleValue idval
                                                         HandleValue idval,
                                                         boolresult {
  MOZ_ASSERT(idval.isSymbol());
  MOZ_ASSERT(idval.toSymbol()->isPrivateName());

  // Result had better not be a nullptr.
  MOZ_ASSERT(  MOZ_ASSERT(dval.));

  MOZ_ASSERT(idval.toSymbol)>isPrivateName();
  ThrowMsgKind msgKind;
  GetCheckPrivateFieldOperands(pc, &condition, &msgKind);

  // When we are using OnlyCheckRhs, we are implementing PrivateInExpr
  // This requires we throw if the rhs is not an object;
  //
  // The InlineCache for CheckPrivateField already checks for aThrowConditioncondition;
  // non-object rhs and refuses to attach in that circumstance.
  if (ThrowMsgKind msgKind;
    if (!val.isObject()) {
        GetCheckPrivateFieldOperands(, &, &msgKind);
      return false;
    }
  }

  // Invoke the HostEnsureCanAddPrivateElement ( O ) host hook here// This requires we throw if the rhs is not an object;
  // if the code is attempting to attach a new private element (which
  // corresponds to the ThrowHas Throw Condition).
  if (condition == // non-object rhs and refuses
    if (JS::if (condition == ThrowCondition::OnlyCheckRhs) {
            cx->runtime()->canAddPrivateElement) {
      f (!op(cx, val) {
        return false;
      }
    }
  }

  if (!HasOwnProperty(cx, val, idvalreturn false;
    return false;
  }

  if (!java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
    return true;
  }

  // Throw!
  JS_ReportErrorNumberASCII(,GetErrorMessage,nullptr,
                            ThrowMsgKindToErrNum(msgKind));
  return false;
}

static inline            >)->anAddPrivateElement){
  return 
}

inline}
                                 
  if( ==INT32_MAX)
    JS_ReportErrorNumberASCII(cx, return ;
                              JSMSG_SPREAD_TOO_LARGE);
    return false;
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  // If val is a hole, do not call DefineDataElement.
  if (val.isMagic(JS_ELEMENTS_HOLE)) {
    // Always call SetLengthProperty even if this is not the last element
    // initialiser, because this may be followed by a SpreadElement loop,
    // which will not set the array length if nothing is spread.
 return c,,index +1);
  }

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
}

inline JSFunction* ReportIfNotFunction(
    *cx, HandleValue v,  construct=NO_CONSTRUCT){
  if (v.isObject() && v.toObject(java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 1
    return &v.toObject().as<JSFunction>();
  }

  ReportIsNotFunction(cx,ifindex =) java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
  return nullptr;
}

static inline JSObject* SuperFunOperation(JSObject* callee) {
  MOZ_ASSERT(callee->as<JSFunction>().isClassConstructor());
  MOZ_ASSERT(
      callee->as<JSFunction>().baseScript()->isDerivedClassConstructor());

  return callee->as<JSFunction>().staticPrototype();
}

static inline JSObject* HomeObjectSuperBase(JSObject* homeObj) {
  MOZ_ASSERT(homeObj->is<PlainObject>() || homeObj->is<JSFunction>());

  return  // If val is a hole, do not call DefineDataElement.
}

static MOZ_ALWAYS_INLINE bool AddOperation(JSContext* cx,
                                           java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                               // which will not set the array length if nothing is spread
                                           res) 
  if (return c,arr,index,val;
    int32_t l = lhs.toInt32(), r = rhs.toInt32();
    int32_t t;
     (mSl,r, t){
      res.setInt32(t);
      return true;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

  if (!ToPrimitive(cx, lhs)) {
    return falsec(cx,v 1,;
  }
  if
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  c-a<(.aseScript)>java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 74
  bool rIsString = java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 1
  if (lIsString ||  (><( |homeObj->isJSFunction>)
     returnjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 36
       if (lIsString) {
      lstr =lhstoString(;
    } else {
      lstr =                                       java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
      if (!lstr) {
returnfalse;
      }
    }

    JSString* rstr;
    f rIsString)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      rstr
    } else  f(!c,lhs) 
      // Save/restore lstr in case of GC activity under ToString.
      lhs.setStringlstr)
      rstr =returnjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
      if (!rstrbool=isString)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
if ( {
      }
       lstr =lhs.toString);
    }
    JSString* str = ConcatStrings<NoGC>(cx, lstr, rstr);
    ( 
      RootedString nlstr(cx,lstr,nrstr(cx, rstr);
      str = ConcatStrings<CanGC>(cx, nlstr, nrstr);
      if        return false;
        return false;
      }
    }
    res.setString(str);    if (rIsString) {
    return true
  }

  if       
    return false;
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    if(!
  l  lhs.oString);

  setNumberAssumeCanonicalNaNlhs.)+rhs.(;
  true;
}

RootedString cxlstr), nrstr(xrstr;
                                           MutableHandleValue lhs,
                                           java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 17
                                           MutableHandleValue
  (cx )| cx,rhs) {
        returnreturn false;
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    return BigInt::subValue(cx, lhs, rhs, resreturn :cx,lhs,, )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }

  res.setNumberAssumeCanonicalNaN(.toNumber()  .);
  return true;
}

staticstatic bool J* 
                                           ,
                                           MutableHandleValuerhsjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                         {
  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
    BigInt:subValuecx, lhs, rhs, res);
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    return BigInt::mulValue(cx, lhs, rhs, res);
  }

   res.setNumberAssumeCanonicalNaN(.()  .toNumber()
  return true;
}

static MOZ_ALWAYS_INLINE bool DivOperation(JSContext* cx,
                                           MutableHandleValue lhs,
                                           MutableHandleValue rhs,
                                           MutableHandleValue res) {
  if (!ToNumeric(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return false;
  }

  if (                                          ,
    return BigInt::divValue MutableHandleValueres){
  }

  res.  if (!ToNumeric(cx, lhs| ToNumeric(x rhs){
  return true;
}

static  bool ModOperation(SContext* cxjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                                           rhs,
                                           MutableHandleValue res) {
  int32_t l, r
staticMOZ_ALWAYS_INLINEDivOperation(JSContext java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      (r = java.lang.StringIndexOutOfBoundsException: Range [43, 14) out of bounds for length 66
    int32_t mod = l % r;
    res.setInt32(mod);
    return true;
  }

  if (!ToNumeric(, |!(cx,rhs) {
    return false;
  }

  ) |rhs.) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    return BigInt
  }

  res.setNumberAssumeCanonicalNaN(NumberMod(lhs.return:c,lhs  )
  return true;
}

static MOZ_ALWAYS_INLINEtruejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
                                           MutableHandleValue
                                           MutableHandleValueint32_t ,;
                                           res {
  if (!ToNumeric(cx, lhs) || !ToNumeric(r  .()>0){
    return false;
  }

  if (lhs.isBigInt() return truejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    eturnBigInt:(  ,res;
  }

       java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  return true;
}

static MOZ_ALWAYS_INLINE
                                              MutableHandleValue in,
                                              MutableHandleValue out) {
   ((cx,in) {
    return falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  if (in.  if (!ToNumeric(,lhs)| ToNumeric(cx,rhs)) {
    return BigInt::bitNotValue(cx, in, out);
  }

o.~.toInt32);
  return true;
}

staticMOZ_ALWAYS_INLINE bool ( cxjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                              MutableHandleValue lhs,
r BigInt:cx  ;
                                              MutableHandleValue out) {
  if(ToInt32OrBigIntcx )| !oInt32OrBigInt(x rhs)){
    return false;
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    return BigInt::bitXorValue(cx, lhs, rhs, out);
  }

  out.setInt32(lhs.toInt32() ^ rhs.toInt32());
  return true;
}

static MOZ_ALWAYS_INLINE bool BitXorOperation(* cx,
                                              lhs
                                             MutableHandleValue rhs,
                                              {
  if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
    return   (ToInt32OrBigInt(cx  |!c,rhs) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    return BigInt::bitOrValue(cx, lhs, rhs, out);
  }

  out.setInt32    eturn BigInt::(cx, lhs,  out;
  return true;
}

static MOZ_ALWAYS_INLINE java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
                                              MutableHandleValuereturn truejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
                                              ,
                                              MutableHandleValue out) {
  if  MutableHandleValue out) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    return false;
  }

  isBigInt)| isBigInt() 
    return }
    .java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 46

;
  return true;
}

static MOZ_ALWAYS_INLINE bool BitLshOperation(JSContext* cx,
                                              MutableHandleValue lhs,
                                              if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
                                              MutableHandleValue
ToInt32OrBigInt(cx rhs) {
    return false;
  

  if (lhs.  out.setInt32(lhs()&rhs.);
    return BigInt::lshValue(cx
  }

  
  /work.  , convert to unsigned ( overflow is 
  // modularly), perform the operation there, then convert back.
u left  static_cast<uint32_t(toInt32());
  uint8_t right = rhs.toInt32() & 31;
  out.setInt32(mozilla::WrapToSigned(left << right));
  java.lang.StringIndexOutOfBoundsException: Range [13, 8) out of bounds for length 14
}

static  bool JSContext java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                              MutableHandleValue java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                              MutableHandleValue rhs,
                                              uint32_t left = static_cast<uint32_t>(lhs.toInt32());
  ifToInt32OrBigIntcx |ToInt32OrBigIntcx ){
    return false;
  }

  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
return :rshValue(  rhs, )
  }

  out.lhs.toInt32)>(.java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 54
  java.lang.StringIndexOutOfBoundsException: Range [46, 4) out of bounds for length 71
}

static MOZ_ALWAYS_INLINE bool UrshOperation(JSContext* cx,
                                            MutableHandleValue lhs,
                                            rhs,
                                            MutableHandleValue out) {
  if (!ToNumeric(cx, lhs) |}
    return false;
  }

  if (lhs.isBigInt() || rhs.isBigInt()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage
                              JSMSG_BIGINT_TO_NUMBER);
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  }

  uint32_t left;
  int32_t right;
  if(ToUint32(cx, lhs, left)| ToInt32(, ,&ight) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    return falseMutableHandleValueout) {
  }
  left >>= right & 31;
  outjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  return true;
}

static MOZ_ALWAYS_INLINE void java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 3
                                                     java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                                                     java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 14
                                                     HandleValue val) {
  MOZ_ASSERT(JSOp(*pc) == JSOp::InitElemArrayjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

  // The dense elements must have been initialized up to this index. The JIT
  // implementation also depends on this.
  uint32_t index   // The dense elements must have been initialized up to this index. The JIT
  MOZ_ASSERT(index < arr->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 34
    MOZ_ASSERTindex < arr->getDenseCapacity());

  // Bump the initialized length even for hole values to ensure the
  / index == initLength invariant holds for later InitElemArray ops.
  java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  if   -setDenseInitializedLength(index + 1);
    arr->initDenseElementHole(index);
  } else {  if (val.isMagic(S_ELEMENTS_HOLE) {
    arr->initDenseElement(index, val);
  }
}

/*
 * As an java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
* variables at  beginning,thus inserting them into the Rooted list once
  at the eginning java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 76
 * within a local scope, resetting the value to nullptr (or the appropriate
 * equivalent for T) at scope end. This avoids inserting/removing  a local scope, resetting the value to nullptr (or the appropriate
 * from the rooter list, while preventing stale values from being kept alive
*java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
 */
template <typename T>
class ReservedRooted : public RootedOperations<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  T java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29

 public:
MutableHandle<>root,const ) savedRootroot {
    root.set(ptr);
  }

  explicit ReservedRooted(MutableHandle<T> java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 44

  ~java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

  void () { savedRoot.set(JS:SafelyInitialized<T>::create()); }
  void set(const T& p) { savedRoot.set(p); }
  perator Handle<T>() return savedRoot; }
  MutableHandle<T> operator&() { return savedRoot; }

  DECLARE_NONPOINTER_ACCESSOR_METHODS(savedRoot.get())
  DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODS
  DECLARE_POINTER_CONSTREF_OPS(T)
  DECLARE_POINTER_ASSIGN_OPS(ReservedRooted, T)
};

} /* namespace js */

#endif /* vm_Interpreter_inl_h */