Added Discord

DiscordCanary/natives_blob.bin

@@ -0,0 +1,19123 @@
+mirrors–t
+(function(a,b){
+"use strict";
+var c;
+var d=a.Array;
+var e=a.isNaN;
+var f=a.JSON.stringify;
+var g;
+var h;
+var i;
+var j=a.Math.min;
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n;
+var o;
+b.Import(function(p){
+c=p.ErrorToString;
+g=p.MakeError;
+h=p.MapEntries;
+i=p.MapIteratorNext;
+m=p.SetIteratorNext;
+n=p.SetValues;
+o=p.SymbolToString;
+});
+var q={
+UNDEFINED_TYPE:'undefined',
+NULL_TYPE:'null',
+BOOLEAN_TYPE:'boolean',
+NUMBER_TYPE:'number',
+STRING_TYPE:'string',
+SYMBOL_TYPE:'symbol',
+OBJECT_TYPE:'object',
+FUNCTION_TYPE:'function',
+REGEXP_TYPE:'regexp',
+ERROR_TYPE:'error',
+PROPERTY_TYPE:'property',
+INTERNAL_PROPERTY_TYPE:'internalProperty',
+FRAME_TYPE:'frame',
+SCRIPT_TYPE:'script',
+CONTEXT_TYPE:'context',
+SCOPE_TYPE:'scope',
+PROMISE_TYPE:'promise',
+MAP_TYPE:'map',
+SET_TYPE:'set',
+ITERATOR_TYPE:'iterator',
+GENERATOR_TYPE:'generator',
+}
+var r=0;
+var s=-1;
+var t=[];
+var u=true;
+function MirrorCacheIsEmpty(){
+return r==0&&t.length==0;
+}
+function ToggleMirrorCache(v){
+u=v;
+ClearMirrorCache();
+}
+function ClearMirrorCache(v){
+r=0;
+t=[];
+}
+function ObjectIsPromise(v){
+return(%_IsJSReceiver(v))&&
+!(%DebugGetProperty(v,k)===(void 0));
+}
+function MakeMirror(v,w){
+var x;
+if(!w&&u){
+for(var y in t){
+x=t[y];
+if(x.value()===v){
+return x;
+}
+if(x.isNumber()&&e(x.value())&&
+typeof v=='number'&&e(v)){
+return x;
+}
+}
+}
+if((v===(void 0))){
+x=new UndefinedMirror();
+}else if((v===null)){
+x=new NullMirror();
+}else if((typeof(v)==='boolean')){
+x=new BooleanMirror(v);
+}else if((typeof(v)==='number')){
+x=new NumberMirror(v);
+}else if((typeof(v)==='string')){
+x=new StringMirror(v);
+}else if((typeof(v)==='symbol')){
+x=new SymbolMirror(v);
+}else if((%_IsArray(v))){
+x=new ArrayMirror(v);
+}else if((%_IsDate(v))){
+x=new DateMirror(v);
+}else if((%_IsFunction(v))){
+x=new FunctionMirror(v);
+}else if((%_IsRegExp(v))){
+x=new RegExpMirror(v);
+}else if((%_ClassOf(v)==='Error')){
+x=new ErrorMirror(v);
+}else if((%_ClassOf(v)==='Script')){
+x=new ScriptMirror(v);
+}else if((%_ClassOf(v)==='Map')||(%_ClassOf(v)==='WeakMap')){
+x=new MapMirror(v);
+}else if((%_ClassOf(v)==='Set')||(%_ClassOf(v)==='WeakSet')){
+x=new SetMirror(v);
+}else if((%_ClassOf(v)==='Map Iterator')||(%_ClassOf(v)==='Set Iterator')){
+x=new IteratorMirror(v);
+}else if(ObjectIsPromise(v)){
+x=new PromiseMirror(v);
+}else if((%_ClassOf(v)==='Generator')){
+x=new GeneratorMirror(v);
+}else{
+x=new ObjectMirror(v,q.OBJECT_TYPE,w);
+}
+if(u)t[x.handle()]=x;
+return x;
+}
+function LookupMirror(z){
+if(!u){
+throw g(2,"Mirror cache is disabled");
+}
+return t[z];
+}
+function GetUndefinedMirror(){
+return MakeMirror((void 0));
+}
+function inherits(A,B){
+var C=function(){};
+C.prototype=B.prototype;
+A.super_=B.prototype;
+A.prototype=new C();
+A.prototype.constructor=A;
+}
+var D=80;
+var E={};
+E.Data=0;
+E.DataConstant=2;
+E.AccessorConstant=3;
+var F={};
+F.None=0;
+F.ReadOnly=1;
+F.DontEnum=2;
+F.DontDelete=4;
+var G={Global:0,
+Local:1,
+With:2,
+Closure:3,
+Catch:4,
+Block:5,
+Script:6};
+function Mirror(H){
+this.type_=H;
+}
+Mirror.prototype.type=function(){
+return this.type_;
+};
+Mirror.prototype.isValue=function(){
+return this instanceof ValueMirror;
+};
+Mirror.prototype.isUndefined=function(){
+return this instanceof UndefinedMirror;
+};
+Mirror.prototype.isNull=function(){
+return this instanceof NullMirror;
+};
+Mirror.prototype.isBoolean=function(){
+return this instanceof BooleanMirror;
+};
+Mirror.prototype.isNumber=function(){
+return this instanceof NumberMirror;
+};
+Mirror.prototype.isString=function(){
+return this instanceof StringMirror;
+};
+Mirror.prototype.isSymbol=function(){
+return this instanceof SymbolMirror;
+};
+Mirror.prototype.isObject=function(){
+return this instanceof ObjectMirror;
+};
+Mirror.prototype.isFunction=function(){
+return this instanceof FunctionMirror;
+};
+Mirror.prototype.isUnresolvedFunction=function(){
+return this instanceof UnresolvedFunctionMirror;
+};
+Mirror.prototype.isArray=function(){
+return this instanceof ArrayMirror;
+};
+Mirror.prototype.isDate=function(){
+return this instanceof DateMirror;
+};
+Mirror.prototype.isRegExp=function(){
+return this instanceof RegExpMirror;
+};
+Mirror.prototype.isError=function(){
+return this instanceof ErrorMirror;
+};
+Mirror.prototype.isPromise=function(){
+return this instanceof PromiseMirror;
+};
+Mirror.prototype.isGenerator=function(){
+return this instanceof GeneratorMirror;
+};
+Mirror.prototype.isProperty=function(){
+return this instanceof PropertyMirror;
+};
+Mirror.prototype.isInternalProperty=function(){
+return this instanceof InternalPropertyMirror;
+};
+Mirror.prototype.isFrame=function(){
+return this instanceof FrameMirror;
+};
+Mirror.prototype.isScript=function(){
+return this instanceof ScriptMirror;
+};
+Mirror.prototype.isContext=function(){
+return this instanceof ContextMirror;
+};
+Mirror.prototype.isScope=function(){
+return this instanceof ScopeMirror;
+};
+Mirror.prototype.isMap=function(){
+return this instanceof MapMirror;
+};
+Mirror.prototype.isSet=function(){
+return this instanceof SetMirror;
+};
+Mirror.prototype.isIterator=function(){
+return this instanceof IteratorMirror;
+};
+Mirror.prototype.allocateHandle_=function(){
+if(u)this.handle_=r++;
+};
+Mirror.prototype.allocateTransientHandle_=function(){
+this.handle_=s--;
+};
+Mirror.prototype.toText=function(){
+return"#<"+this.constructor.name+">";
+};
+function ValueMirror(H,v,I){
+%_Call(Mirror,this,H);
+this.value_=v;
+if(!I){
+this.allocateHandle_();
+}else{
+this.allocateTransientHandle_();
+}
+}
+inherits(ValueMirror,Mirror);
+Mirror.prototype.handle=function(){
+return this.handle_;
+};
+ValueMirror.prototype.isPrimitive=function(){
+var H=this.type();
+return H==='undefined'||
+H==='null'||
+H==='boolean'||
+H==='number'||
+H==='string'||
+H==='symbol';
+};
+ValueMirror.prototype.value=function(){
+return this.value_;
+};
+function UndefinedMirror(){
+%_Call(ValueMirror,this,q.UNDEFINED_TYPE,(void 0));
+}
+inherits(UndefinedMirror,ValueMirror);
+UndefinedMirror.prototype.toText=function(){
+return'undefined';
+};
+function NullMirror(){
+%_Call(ValueMirror,this,q.NULL_TYPE,null);
+}
+inherits(NullMirror,ValueMirror);
+NullMirror.prototype.toText=function(){
+return'null';
+};
+function BooleanMirror(v){
+%_Call(ValueMirror,this,q.BOOLEAN_TYPE,v);
+}
+inherits(BooleanMirror,ValueMirror);
+BooleanMirror.prototype.toText=function(){
+return this.value_?'true':'false';
+};
+function NumberMirror(v){
+%_Call(ValueMirror,this,q.NUMBER_TYPE,v);
+}
+inherits(NumberMirror,ValueMirror);
+NumberMirror.prototype.toText=function(){
+return %_NumberToString(this.value_);
+};
+function StringMirror(v){
+%_Call(ValueMirror,this,q.STRING_TYPE,v);
+}
+inherits(StringMirror,ValueMirror);
+StringMirror.prototype.length=function(){
+return this.value_.length;
+};
+StringMirror.prototype.getTruncatedValue=function(J){
+if(J!=-1&&this.length()>J){
+return this.value_.substring(0,J)+
+'... (length: '+this.length()+')';
+}
+return this.value_;
+};
+StringMirror.prototype.toText=function(){
+return this.getTruncatedValue(D);
+};
+function SymbolMirror(v){
+%_Call(ValueMirror,this,q.SYMBOL_TYPE,v);
+}
+inherits(SymbolMirror,ValueMirror);
+SymbolMirror.prototype.description=function(){
+return %SymbolDescription(%_ValueOf(this.value_));
+}
+SymbolMirror.prototype.toText=function(){
+return %_Call(o,this.value_);
+}
+function ObjectMirror(v,H,I){
+H=H||q.OBJECT_TYPE;
+%_Call(ValueMirror,this,H,v,I);
+}
+inherits(ObjectMirror,ValueMirror);
+ObjectMirror.prototype.className=function(){
+return %_ClassOf(this.value_);
+};
+ObjectMirror.prototype.constructorFunction=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'constructor'));
+};
+ObjectMirror.prototype.prototypeObject=function(){
+return MakeMirror(%DebugGetProperty(this.value_,'prototype'));
+};
+ObjectMirror.prototype.protoObject=function(){
+return MakeMirror(%DebugGetPrototype(this.value_));
+};
+ObjectMirror.prototype.hasNamedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&2)!=0;
+};
+ObjectMirror.prototype.hasIndexedInterceptor=function(){
+var K=%GetInterceptorInfo(this.value_);
+return(K&1)!=0;
+};
+ObjectMirror.prototype.propertyNames=function(){
+return %GetOwnPropertyKeys(this.value_,0);
+};
+ObjectMirror.prototype.properties=function(){
+var L=this.propertyNames();
+var M=new d(L.length);
+for(var N=0;N<L.length;N++){
+M[N]=this.property(L[N]);
+}
+return M;
+};
+ObjectMirror.prototype.internalProperties=function(){
+return ObjectMirror.GetInternalProperties(this.value_);
+}
+ObjectMirror.prototype.property=function(O){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToName(O)));
+if(P){
+return new PropertyMirror(this,O,P);
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.lookupProperty=function(v){
+var M=this.properties();
+for(var N=0;N<M.length;N++){
+var Q=M[N];
+if(Q.propertyType()!=E.AccessorConstant){
+if(%_ObjectEquals(Q.value_,v.value_)){
+return Q;
+}
+}
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.referencedBy=function(R){
+var S=%DebugReferencedBy(this.value_,
+Mirror.prototype,R||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+};
+ObjectMirror.prototype.toText=function(){
+var O;
+var A=this.constructorFunction();
+if(!A.isFunction()){
+O=this.className();
+}else{
+O=A.name();
+if(!O){
+O=this.className();
+}
+}
+return'#<'+O+'>';
+};
+ObjectMirror.GetInternalProperties=function(v){
+var M=%DebugGetInternalProperties(v);
+var S=[];
+for(var N=0;N<M.length;N+=2){
+S.push(new InternalPropertyMirror(M[N],M[N+1]));
+}
+return S;
+}
+function FunctionMirror(v){
+%_Call(ObjectMirror,this,v,q.FUNCTION_TYPE);
+this.resolved_=true;
+}
+inherits(FunctionMirror,ObjectMirror);
+FunctionMirror.prototype.resolved=function(){
+return this.resolved_;
+};
+FunctionMirror.prototype.name=function(){
+return %FunctionGetName(this.value_);
+};
+FunctionMirror.prototype.debugName=function(){
+return %FunctionGetDebugName(this.value_);
+}
+FunctionMirror.prototype.inferredName=function(){
+return %FunctionGetInferredName(this.value_);
+};
+FunctionMirror.prototype.source=function(){
+if(this.resolved()){
+return %FunctionToString(this.value_);
+}
+};
+FunctionMirror.prototype.script=function(){
+if(this.resolved()){
+if(this.script_){
+return this.script_;
+}
+var T=%FunctionGetScript(this.value_);
+if(T){
+return this.script_=MakeMirror(T);
+}
+}
+};
+FunctionMirror.prototype.sourcePosition_=function(){
+if(this.resolved()){
+return %FunctionGetScriptSourcePosition(this.value_);
+}
+};
+FunctionMirror.prototype.sourceLocation=function(){
+if(this.resolved()){
+var T=this.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition_(),true);
+}
+}
+};
+FunctionMirror.prototype.constructedBy=function(U){
+if(this.resolved()){
+var S=%DebugConstructedBy(this.value_,U||0);
+for(var N=0;N<S.length;N++){
+S[N]=MakeMirror(S[N]);
+}
+return S;
+}else{
+return[];
+}
+};
+FunctionMirror.prototype.scopeCount=function(){
+if(this.resolved()){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetFunctionScopeCount(this.value());
+}
+return this.scopeCount_;
+}else{
+return 0;
+}
+};
+FunctionMirror.prototype.scope=function(V){
+if(this.resolved()){
+return new ScopeMirror((void 0),this,V);
+}
+};
+FunctionMirror.prototype.toText=function(){
+return this.source();
+};
+function UnresolvedFunctionMirror(v){
+%_Call(ValueMirror,this,q.FUNCTION_TYPE,v);
+this.propertyCount_=0;
+this.elementCount_=0;
+this.resolved_=false;
+}
+inherits(UnresolvedFunctionMirror,FunctionMirror);
+UnresolvedFunctionMirror.prototype.className=function(){
+return'Function';
+};
+UnresolvedFunctionMirror.prototype.constructorFunction=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.prototypeObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.protoObject=function(){
+return GetUndefinedMirror();
+};
+UnresolvedFunctionMirror.prototype.name=function(){
+return this.value_;
+};
+UnresolvedFunctionMirror.prototype.inferredName=function(){
+return(void 0);
+};
+UnresolvedFunctionMirror.prototype.propertyNames=function(W,X){
+return[];
+};
+function ArrayMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(ArrayMirror,ObjectMirror);
+ArrayMirror.prototype.length=function(){
+return this.value_.length;
+};
+ArrayMirror.prototype.indexedPropertiesFromRange=function(opt_from_index,
+opt_to_index){
+var Y=opt_from_index||0;
+var Z=opt_to_index||this.length()-1;
+if(Y>Z)return new d();
+var aa=new d(Z-Y+1);
+for(var N=Y;N<=Z;N++){
+var P=%DebugGetPropertyDetails(this.value_,(%_ToString(N)));
+var v;
+if(P){
+v=new PropertyMirror(this,N,P);
+}else{
+v=GetUndefinedMirror();
+}
+aa[N-Y]=v;
+}
+return aa;
+};
+function DateMirror(v){
+%_Call(ObjectMirror,this,v);
+}
+inherits(DateMirror,ObjectMirror);
+DateMirror.prototype.toText=function(){
+var ab=f(this.value_);
+return ab.substring(1,ab.length-1);
+};
+function RegExpMirror(v){
+%_Call(ObjectMirror,this,v,q.REGEXP_TYPE);
+}
+inherits(RegExpMirror,ObjectMirror);
+RegExpMirror.prototype.source=function(){
+return this.value_.source;
+};
+RegExpMirror.prototype.global=function(){
+return this.value_.global;
+};
+RegExpMirror.prototype.ignoreCase=function(){
+return this.value_.ignoreCase;
+};
+RegExpMirror.prototype.multiline=function(){
+return this.value_.multiline;
+};
+RegExpMirror.prototype.sticky=function(){
+return this.value_.sticky;
+};
+RegExpMirror.prototype.unicode=function(){
+return this.value_.unicode;
+};
+RegExpMirror.prototype.toText=function(){
+return"/"+this.source()+"/";
+};
+function ErrorMirror(v){
+%_Call(ObjectMirror,this,v,q.ERROR_TYPE);
+}
+inherits(ErrorMirror,ObjectMirror);
+ErrorMirror.prototype.message=function(){
+return this.value_.message;
+};
+ErrorMirror.prototype.toText=function(){
+var ac;
+try{
+ac=%_Call(c,this.value_);
+}catch(e){
+ac='#<Error>';
+}
+return ac;
+};
+function PromiseMirror(v){
+%_Call(ObjectMirror,this,v,q.PROMISE_TYPE);
+}
+inherits(PromiseMirror,ObjectMirror);
+function PromiseGetStatus_(v){
+var ad=%DebugGetProperty(v,k);
+if(ad==0)return"pending";
+if(ad==1)return"resolved";
+return"rejected";
+}
+function PromiseGetValue_(v){
+return %DebugGetProperty(v,l);
+}
+PromiseMirror.prototype.status=function(){
+return PromiseGetStatus_(this.value_);
+};
+PromiseMirror.prototype.promiseValue=function(){
+return MakeMirror(PromiseGetValue_(this.value_));
+};
+function MapMirror(v){
+%_Call(ObjectMirror,this,v,q.MAP_TYPE);
+}
+inherits(MapMirror,ObjectMirror);
+MapMirror.prototype.entries=function(ae){
+var S=[];
+if((%_ClassOf(this.value_)==='WeakMap')){
+var af=%GetWeakMapEntries(this.value_,ae||0);
+for(var N=0;N<af.length;N+=2){
+S.push({
+key:af[N],
+value:af[N+1]
+});
+}
+return S;
+}
+var ag=%_Call(h,this.value_);
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=ag.next()).done){
+S.push({
+key:ah.value[0],
+value:ah.value[1]
+});
+}
+return S;
+};
+function SetMirror(v){
+%_Call(ObjectMirror,this,v,q.SET_TYPE);
+}
+inherits(SetMirror,ObjectMirror);
+function IteratorGetValues_(ag,ai,ae){
+var S=[];
+var ah;
+while((!ae||S.length<ae)&&
+!(ah=%_Call(ai,ag)).done){
+S.push(ah.value);
+}
+return S;
+}
+SetMirror.prototype.values=function(ae){
+if((%_ClassOf(this.value_)==='WeakSet')){
+return %GetWeakSetValues(this.value_,ae||0);
+}
+var ag=%_Call(n,this.value_);
+return IteratorGetValues_(ag,m,ae);
+};
+function IteratorMirror(v){
+%_Call(ObjectMirror,this,v,q.ITERATOR_TYPE);
+}
+inherits(IteratorMirror,ObjectMirror);
+IteratorMirror.prototype.preview=function(ae){
+if((%_ClassOf(this.value_)==='Map Iterator')){
+return IteratorGetValues_(%MapIteratorClone(this.value_),
+i,
+ae);
+}else if((%_ClassOf(this.value_)==='Set Iterator')){
+return IteratorGetValues_(%SetIteratorClone(this.value_),
+m,
+ae);
+}
+};
+function GeneratorMirror(v){
+%_Call(ObjectMirror,this,v,q.GENERATOR_TYPE);
+}
+inherits(GeneratorMirror,ObjectMirror);
+function GeneratorGetStatus_(v){
+var aj=%GeneratorGetContinuation(v);
+if(aj<0)return"running";
+if(aj==0)return"closed";
+return"suspended";
+}
+GeneratorMirror.prototype.status=function(){
+return GeneratorGetStatus_(this.value_);
+};
+GeneratorMirror.prototype.sourcePosition_=function(){
+return %GeneratorGetSourcePosition(this.value_);
+};
+GeneratorMirror.prototype.sourceLocation=function(){
+var ak=this.sourcePosition_();
+if(!(ak===(void 0))){
+var T=this.func().script();
+if(T){
+return T.locationFromPosition(ak,true);
+}
+}
+};
+GeneratorMirror.prototype.func=function(){
+if(!this.func_){
+this.func_=MakeMirror(%GeneratorGetFunction(this.value_));
+}
+return this.func_;
+};
+GeneratorMirror.prototype.context=function(){
+if(!this.context_){
+this.context_=new ContextMirror(%GeneratorGetContext(this.value_));
+}
+return this.context_;
+};
+GeneratorMirror.prototype.receiver=function(){
+if(!this.receiver_){
+this.receiver_=MakeMirror(%GeneratorGetReceiver(this.value_));
+}
+return this.receiver_;
+};
+function PropertyMirror(x,O,P){
+%_Call(Mirror,this,q.PROPERTY_TYPE);
+this.mirror_=x;
+this.name_=O;
+this.value_=P[0];
+this.details_=P[1];
+this.is_interceptor_=P[2];
+if(P.length>3){
+this.exception_=P[3];
+this.getter_=P[4];
+this.setter_=P[5];
+}
+}
+inherits(PropertyMirror,Mirror);
+PropertyMirror.prototype.isReadOnly=function(){
+return(this.attributes()&F.ReadOnly)!=0;
+};
+PropertyMirror.prototype.isEnum=function(){
+return(this.attributes()&F.DontEnum)==0;
+};
+PropertyMirror.prototype.canDelete=function(){
+return(this.attributes()&F.DontDelete)==0;
+};
+PropertyMirror.prototype.name=function(){
+return this.name_;
+};
+PropertyMirror.prototype.isIndexed=function(){
+for(var N=0;N<this.name_.length;N++){
+if(this.name_[N]<'0'||'9'<this.name_[N]){
+return false;
+}
+}
+return true;
+};
+PropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+PropertyMirror.prototype.isException=function(){
+return this.exception_?true:false;
+};
+PropertyMirror.prototype.attributes=function(){
+return %DebugPropertyAttributesFromDetails(this.details_);
+};
+PropertyMirror.prototype.propertyType=function(){
+return %DebugPropertyTypeFromDetails(this.details_);
+};
+PropertyMirror.prototype.insertionIndex=function(){
+return %DebugPropertyIndexFromDetails(this.details_);
+};
+PropertyMirror.prototype.hasGetter=function(){
+return this.getter_?true:false;
+};
+PropertyMirror.prototype.hasSetter=function(){
+return this.setter_?true:false;
+};
+PropertyMirror.prototype.getter=function(){
+if(this.hasGetter()){
+return MakeMirror(this.getter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.setter=function(){
+if(this.hasSetter()){
+return MakeMirror(this.setter_);
+}else{
+return GetUndefinedMirror();
+}
+};
+PropertyMirror.prototype.isNative=function(){
+return this.is_interceptor_||
+((this.propertyType()==E.AccessorConstant)&&
+!this.hasGetter()&&!this.hasSetter());
+};
+function InternalPropertyMirror(O,v){
+%_Call(Mirror,this,q.INTERNAL_PROPERTY_TYPE);
+this.name_=O;
+this.value_=v;
+}
+inherits(InternalPropertyMirror,Mirror);
+InternalPropertyMirror.prototype.name=function(){
+return this.name_;
+};
+InternalPropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+var al=0;
+var am=1;
+var an=2;
+var ao=3;
+var ap=4;
+var aq=5;
+var ar=6;
+var as=7;
+var at=8;
+var au=9;
+var av=0;
+var aw=1;
+var ax=2;
+var ay=1<<0;
+var az=1<<1;
+var aA=7<<2;
+function FrameDetails(aB,V){
+this.break_id_=aB;
+this.details_=%GetFrameDetails(aB,V);
+}
+FrameDetails.prototype.frameId=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[al];
+};
+FrameDetails.prototype.receiver=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[am];
+};
+FrameDetails.prototype.func=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[an];
+};
+FrameDetails.prototype.isConstructCall=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ar];
+};
+FrameDetails.prototype.isAtReturn=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[as];
+};
+FrameDetails.prototype.isDebuggerFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=ay;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isOptimizedFrame=function(){
+%CheckExecutionState(this.break_id_);
+var aC=az;
+return(this.details_[at]&aC)==aC;
+};
+FrameDetails.prototype.isInlinedFrame=function(){
+return this.inlinedFrameIndex()>0;
+};
+FrameDetails.prototype.inlinedFrameIndex=function(){
+%CheckExecutionState(this.break_id_);
+var aC=aA;
+return(this.details_[at]&aC)>>2;
+};
+FrameDetails.prototype.argumentCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ao];
+};
+FrameDetails.prototype.argumentName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.argumentValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.argumentCount()){
+return this.details_[au+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.localCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[ap];
+};
+FrameDetails.prototype.sourcePosition=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[aq];
+};
+FrameDetails.prototype.localName=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+av];
+}
+};
+FrameDetails.prototype.localValue=function(V){
+%CheckExecutionState(this.break_id_);
+if(V>=0&&V<this.localCount()){
+var aD=au+
+this.argumentCount()*ax;
+return this.details_[aD+
+V*ax+
+aw];
+}
+};
+FrameDetails.prototype.returnValue=function(){
+%CheckExecutionState(this.break_id_);
+var aE=
+au+
+(this.argumentCount()+this.localCount())*ax;
+if(this.details_[as]){
+return this.details_[aE];
+}
+};
+FrameDetails.prototype.scopeCount=function(){
+if((this.scopeCount_===(void 0))){
+this.scopeCount_=%GetScopeCount(this.break_id_,this.frameId());
+}
+return this.scopeCount_;
+};
+FrameDetails.prototype.stepInPositionsImpl=function(){
+return %GetStepInPositions(this.break_id_,this.frameId());
+};
+function FrameMirror(aB,V){
+%_Call(Mirror,this,q.FRAME_TYPE);
+this.break_id_=aB;
+this.index_=V;
+this.details_=new FrameDetails(aB,V);
+}
+inherits(FrameMirror,Mirror);
+FrameMirror.prototype.details=function(){
+return this.details_;
+};
+FrameMirror.prototype.index=function(){
+return this.index_;
+};
+FrameMirror.prototype.func=function(){
+if(this.func_){
+return this.func_;
+}
+var aC=this.details_.func();
+if((%_IsFunction(aC))){
+return this.func_=MakeMirror(aC);
+}else{
+return new UnresolvedFunctionMirror(aC);
+}
+};
+FrameMirror.prototype.receiver=function(){
+return MakeMirror(this.details_.receiver());
+};
+FrameMirror.prototype.isConstructCall=function(){
+return this.details_.isConstructCall();
+};
+FrameMirror.prototype.isAtReturn=function(){
+return this.details_.isAtReturn();
+};
+FrameMirror.prototype.isDebuggerFrame=function(){
+return this.details_.isDebuggerFrame();
+};
+FrameMirror.prototype.isOptimizedFrame=function(){
+return this.details_.isOptimizedFrame();
+};
+FrameMirror.prototype.isInlinedFrame=function(){
+return this.details_.isInlinedFrame();
+};
+FrameMirror.prototype.inlinedFrameIndex=function(){
+return this.details_.inlinedFrameIndex();
+};
+FrameMirror.prototype.argumentCount=function(){
+return this.details_.argumentCount();
+};
+FrameMirror.prototype.argumentName=function(V){
+return this.details_.argumentName(V);
+};
+FrameMirror.prototype.argumentValue=function(V){
+return MakeMirror(this.details_.argumentValue(V));
+};
+FrameMirror.prototype.localCount=function(){
+return this.details_.localCount();
+};
+FrameMirror.prototype.localName=function(V){
+return this.details_.localName(V);
+};
+FrameMirror.prototype.localValue=function(V){
+return MakeMirror(this.details_.localValue(V));
+};
+FrameMirror.prototype.returnValue=function(){
+return MakeMirror(this.details_.returnValue());
+};
+FrameMirror.prototype.sourcePosition=function(){
+return this.details_.sourcePosition();
+};
+FrameMirror.prototype.sourceLocation=function(){
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+return T.locationFromPosition(this.sourcePosition(),true);
+}
+}
+};
+FrameMirror.prototype.sourceLine=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.line;
+}
+};
+FrameMirror.prototype.sourceColumn=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.column;
+}
+};
+FrameMirror.prototype.sourceLineText=function(){
+var aG=this.sourceLocation();
+if(aG){
+return aG.sourceText();
+}
+};
+FrameMirror.prototype.scopeCount=function(){
+return this.details_.scopeCount();
+};
+FrameMirror.prototype.scope=function(V){
+return new ScopeMirror(this,(void 0),V);
+};
+FrameMirror.prototype.allScopes=function(aH){
+var aI=%GetAllScopesDetails(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+!!aH);
+var S=[];
+for(var N=0;N<aI.length;++N){
+S.push(new ScopeMirror(this,(void 0),N,aI[N]));
+}
+return S;
+};
+FrameMirror.prototype.stepInPositions=function(){
+var T=this.func().script();
+var aJ=this.func().sourcePosition_();
+var aK=this.details_.stepInPositionsImpl();
+var S=[];
+if(aK){
+for(var N=0;N<aK.length;N++){
+var aL={};
+var aM=T.locationFromPosition(aJ+aK[N],
+true);
+serializeLocationFields(aM,aL);
+var aN={
+position:aL
+};
+S.push(aN);
+}
+}
+return S;
+};
+FrameMirror.prototype.evaluate=function(source,disable_break,
+opt_context_object){
+return MakeMirror(%DebugEvaluate(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+source,
+(!!(disable_break)),
+opt_context_object));
+};
+FrameMirror.prototype.invocationText=function(){
+var S='';
+var aF=this.func();
+var aO=this.receiver();
+if(this.isConstructCall()){
+S+='new ';
+S+=aF.name()?aF.name():'[anonymous]';
+}else if(this.isDebuggerFrame()){
+S+='[debugger]';
+}else{
+var aP=
+!aO.className||(aO.className()!='global');
+if(aP){
+S+=aO.toText();
+}
+var Q=GetUndefinedMirror();
+if(aO.isObject()){
+for(var aQ=aO;
+!aQ.isNull()&&Q.isUndefined();
+aQ=aQ.protoObject()){
+Q=aQ.lookupProperty(aF);
+}
+}
+if(!Q.isUndefined()){
+if(!Q.isIndexed()){
+if(aP){
+S+='.';
+}
+S+=Q.name();
+}else{
+S+='[';
+S+=Q.name();
+S+=']';
+}
+if(aF.name()&&aF.name()!=Q.name()){
+S+='(aka '+aF.name()+')';
+}
+}else{
+if(aP){
+S+='.';
+}
+S+=aF.name()?aF.name():'[anonymous]';
+}
+}
+if(!this.isDebuggerFrame()){
+S+='(';
+for(var N=0;N<this.argumentCount();N++){
+if(N!=0)S+=', ';
+if(this.argumentName(N)){
+S+=this.argumentName(N);
+S+='=';
+}
+S+=this.argumentValue(N).toText();
+}
+S+=')';
+}
+if(this.isAtReturn()){
+S+=' returning ';
+S+=this.returnValue().toText();
+}
+return S;
+};
+FrameMirror.prototype.sourceAndPositionText=function(){
+var S='';
+var aF=this.func();
+if(aF.resolved()){
+var T=aF.script();
+if(T){
+if(T.name()){
+S+=T.name();
+}else{
+S+='[unnamed]';
+}
+if(!this.isDebuggerFrame()){
+var aG=this.sourceLocation();
+S+=' line ';
+S+=!(aG===(void 0))?(aG.line+1):'?';
+S+=' column ';
+S+=!(aG===(void 0))?(aG.column+1):'?';
+if(!(this.sourcePosition()===(void 0))){
+S+=' (position '+(this.sourcePosition()+1)+')';
+}
+}
+}else{
+S+='[no source]';
+}
+}else{
+S+='[unresolved]';
+}
+return S;
+};
+FrameMirror.prototype.localsText=function(){
+var S='';
+var aR=this.localCount();
+if(aR>0){
+for(var N=0;N<aR;++N){
+S+='      var ';
+S+=this.localName(N);
+S+=' = ';
+S+=this.localValue(N).toText();
+if(N<aR-1)S+='\n';
+}
+}
+return S;
+};
+FrameMirror.prototype.restart=function(){
+var S=%LiveEditRestartFrame(this.break_id_,this.index_);
+if((S===(void 0))){
+S="Failed to find requested frame";
+}
+return S;
+};
+FrameMirror.prototype.toText=function(aS){
+var S='';
+S+='#'+(this.index()<=9?'0':'')+this.index();
+S+=' ';
+S+=this.invocationText();
+S+=' ';
+S+=this.sourceAndPositionText();
+if(aS){
+S+='\n';
+S+=this.localsText();
+}
+return S;
+};
+var aT=0;
+var aU=1;
+var aV=2;
+function ScopeDetails(aW,aX,V,aY){
+if(aW){
+this.break_id_=aW.break_id_;
+this.details_=aY||
+%GetScopeDetails(aW.break_id_,
+aW.details_.frameId(),
+aW.details_.inlinedFrameIndex(),
+V);
+this.frame_id_=aW.details_.frameId();
+this.inlined_frame_id_=aW.details_.inlinedFrameIndex();
+}else{
+this.details_=aY||%GetFunctionScopeDetails(aX.value(),V);
+this.fun_value_=aX.value();
+this.break_id_=(void 0);
+}
+this.index_=V;
+}
+ScopeDetails.prototype.type=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aT];
+};
+ScopeDetails.prototype.object=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aU];
+};
+ScopeDetails.prototype.name=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[aV];
+};
+ScopeDetails.prototype.setVariableValueImpl=function(O,aZ){
+var ba;
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+ba=%SetScopeVariableValue(this.break_id_,this.frame_id_,
+this.inlined_frame_id_,this.index_,O,aZ);
+}else{
+ba=%SetScopeVariableValue(this.fun_value_,null,null,this.index_,
+O,aZ);
+}
+if(!ba)throw g(2,"Failed to set variable value");
+};
+function ScopeMirror(aW,aX,V,aY){
+%_Call(Mirror,this,q.SCOPE_TYPE);
+if(aW){
+this.frame_index_=aW.index_;
+}else{
+this.frame_index_=(void 0);
+}
+this.scope_index_=V;
+this.details_=new ScopeDetails(aW,aX,V,aY);
+}
+inherits(ScopeMirror,Mirror);
+ScopeMirror.prototype.details=function(){
+return this.details_;
+};
+ScopeMirror.prototype.frameIndex=function(){
+return this.frame_index_;
+};
+ScopeMirror.prototype.scopeIndex=function(){
+return this.scope_index_;
+};
+ScopeMirror.prototype.scopeType=function(){
+return this.details_.type();
+};
+ScopeMirror.prototype.scopeObject=function(){
+var I=this.scopeType()==G.Local||
+this.scopeType()==G.Closure||
+this.scopeType()==G.Script;
+return MakeMirror(this.details_.object(),I);
+};
+ScopeMirror.prototype.setVariableValue=function(O,aZ){
+this.details_.setVariableValueImpl(O,aZ);
+};
+function ScriptMirror(T){
+%_Call(Mirror,this,q.SCRIPT_TYPE);
+this.script_=T;
+this.context_=new ContextMirror(T.context_data);
+this.allocateHandle_();
+}
+inherits(ScriptMirror,Mirror);
+ScriptMirror.prototype.value=function(){
+return this.script_;
+};
+ScriptMirror.prototype.name=function(){
+return this.script_.name||this.script_.nameOrSourceURL();
+};
+ScriptMirror.prototype.id=function(){
+return this.script_.id;
+};
+ScriptMirror.prototype.source=function(){
+return this.script_.source;
+};
+ScriptMirror.prototype.setSource=function(bb){
+%DebugSetScriptSource(this.script_,bb);
+};
+ScriptMirror.prototype.lineOffset=function(){
+return this.script_.line_offset;
+};
+ScriptMirror.prototype.columnOffset=function(){
+return this.script_.column_offset;
+};
+ScriptMirror.prototype.data=function(){
+return this.script_.data;
+};
+ScriptMirror.prototype.scriptType=function(){
+return this.script_.type;
+};
+ScriptMirror.prototype.compilationType=function(){
+return this.script_.compilation_type;
+};
+ScriptMirror.prototype.lineCount=function(){
+return this.script_.lineCount();
+};
+ScriptMirror.prototype.locationFromPosition=function(
+position,include_resource_offset){
+return this.script_.locationFromPosition(position,include_resource_offset);
+};
+ScriptMirror.prototype.sourceSlice=function(bc,bd){
+return this.script_.sourceSlice(bc,bd);
+};
+ScriptMirror.prototype.context=function(){
+return this.context_;
+};
+ScriptMirror.prototype.evalFromScript=function(){
+return MakeMirror(this.script_.eval_from_script);
+};
+ScriptMirror.prototype.evalFromFunctionName=function(){
+return MakeMirror(this.script_.eval_from_function_name);
+};
+ScriptMirror.prototype.evalFromLocation=function(){
+var be=this.evalFromScript();
+if(!be.isUndefined()){
+var bf=this.script_.eval_from_script_position;
+return be.locationFromPosition(bf,true);
+}
+};
+ScriptMirror.prototype.toText=function(){
+var S='';
+S+=this.name();
+S+=' (lines: ';
+if(this.lineOffset()>0){
+S+=this.lineOffset();
+S+='-';
+S+=this.lineOffset()+this.lineCount()-1;
+}else{
+S+=this.lineCount();
+}
+S+=')';
+return S;
+};
+function ContextMirror(bg){
+%_Call(Mirror,this,q.CONTEXT_TYPE);
+this.data_=bg;
+this.allocateHandle_();
+}
+inherits(ContextMirror,Mirror);
+ContextMirror.prototype.data=function(){
+return this.data_;
+};
+function MakeMirrorSerializer(P,bh){
+return new JSONProtocolSerializer(P,bh);
+}
+function JSONProtocolSerializer(P,bh){
+this.details_=P;
+this.options_=bh;
+this.mirrors_=[];
+}
+JSONProtocolSerializer.prototype.serializeReference=function(x){
+return this.serialize_(x,true,true);
+};
+JSONProtocolSerializer.prototype.serializeValue=function(x){
+var bi=this.serialize_(x,false,true);
+return bi;
+};
+JSONProtocolSerializer.prototype.serializeReferencedObjects=function(){
+var bj=[];
+var bk=this.mirrors_.length;
+for(var N=0;N<bk;N++){
+bj.push(this.serialize_(this.mirrors_[N],false,false));
+}
+return bj;
+};
+JSONProtocolSerializer.prototype.includeSource_=function(){
+return this.options_&&this.options_.includeSource;
+};
+JSONProtocolSerializer.prototype.inlineRefs_=function(){
+return this.options_&&this.options_.inlineRefs;
+};
+JSONProtocolSerializer.prototype.maxStringLength_=function(){
+if((this.options_===(void 0))||
+(this.options_.maxStringLength===(void 0))){
+return D;
+}
+return this.options_.maxStringLength;
+};
+JSONProtocolSerializer.prototype.add_=function(x){
+for(var N=0;N<this.mirrors_.length;N++){
+if(this.mirrors_[N]===x){
+return;
+}
+}
+this.mirrors_.push(x);
+};
+JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_=
+function(x){
+var bl={};
+bl.ref=x.handle();
+bl.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+case q.BOOLEAN_TYPE:
+case q.NUMBER_TYPE:
+bl.value=x.value();
+break;
+case q.STRING_TYPE:
+bl.value=x.getTruncatedValue(this.maxStringLength_());
+break;
+case q.SYMBOL_TYPE:
+bl.description=x.description();
+break;
+case q.FUNCTION_TYPE:
+bl.name=x.name();
+bl.inferredName=x.inferredName();
+if(x.script()){
+bl.scriptId=x.script().id();
+}
+break;
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+bl.value=x.toText();
+break;
+case q.OBJECT_TYPE:
+bl.className=x.className();
+break;
+}
+return bl;
+};
+JSONProtocolSerializer.prototype.serialize_=function(x,reference,
+P){
+if(reference&&
+(x.isValue()||x.isScript()||x.isContext())){
+if(this.inlineRefs_()&&x.isValue()){
+return this.serializeReferenceWithDisplayData_(x);
+}else{
+this.add_(x);
+return{'ref':x.handle()};
+}
+}
+var bj={};
+if(x.isValue()||x.isScript()||x.isContext()){
+bj.handle=x.handle();
+}
+bj.type=x.type();
+switch(x.type()){
+case q.UNDEFINED_TYPE:
+case q.NULL_TYPE:
+break;
+case q.BOOLEAN_TYPE:
+bj.value=x.value();
+break;
+case q.NUMBER_TYPE:
+bj.value=NumberToJSON_(x.value());
+break;
+case q.STRING_TYPE:
+if(this.maxStringLength_()!=-1&&
+x.length()>this.maxStringLength_()){
+var bm=x.getTruncatedValue(this.maxStringLength_());
+bj.value=bm;
+bj.fromIndex=0;
+bj.toIndex=this.maxStringLength_();
+}else{
+bj.value=x.value();
+}
+bj.length=x.length();
+break;
+case q.SYMBOL_TYPE:
+bj.description=x.description();
+break;
+case q.OBJECT_TYPE:
+case q.FUNCTION_TYPE:
+case q.ERROR_TYPE:
+case q.REGEXP_TYPE:
+case q.PROMISE_TYPE:
+case q.GENERATOR_TYPE:
+this.serializeObject_(x,bj,P);
+break;
+case q.PROPERTY_TYPE:
+case q.INTERNAL_PROPERTY_TYPE:
+throw g(2,
+'PropertyMirror cannot be serialized independently');
+break;
+case q.FRAME_TYPE:
+this.serializeFrame_(x,bj);
+break;
+case q.SCOPE_TYPE:
+this.serializeScope_(x,bj);
+break;
+case q.SCRIPT_TYPE:
+if(x.name()){
+bj.name=x.name();
+}
+bj.id=x.id();
+bj.lineOffset=x.lineOffset();
+bj.columnOffset=x.columnOffset();
+bj.lineCount=x.lineCount();
+if(x.data()){
+bj.data=x.data();
+}
+if(this.includeSource_()){
+bj.source=x.source();
+}else{
+var bn=x.source().substring(0,80);
+bj.sourceStart=bn;
+}
+bj.sourceLength=x.source().length;
+bj.scriptType=x.scriptType();
+bj.compilationType=x.compilationType();
+if(x.compilationType()==1&&
+x.evalFromScript()){
+bj.evalFromScript=
+this.serializeReference(x.evalFromScript());
+var bo=x.evalFromLocation();
+if(bo){
+bj.evalFromLocation={line:bo.line,
+column:bo.column};
+}
+if(x.evalFromFunctionName()){
+bj.evalFromFunctionName=x.evalFromFunctionName();
+}
+}
+if(x.context()){
+bj.context=this.serializeReference(x.context());
+}
+break;
+case q.CONTEXT_TYPE:
+bj.data=x.data();
+break;
+}
+bj.text=x.toText();
+return bj;
+};
+JSONProtocolSerializer.prototype.serializeObject_=function(x,bj,
+P){
+bj.className=x.className();
+bj.constructorFunction=
+this.serializeReference(x.constructorFunction());
+bj.protoObject=this.serializeReference(x.protoObject());
+bj.prototypeObject=this.serializeReference(x.prototypeObject());
+if(x.hasNamedInterceptor()){
+bj.namedInterceptor=true;
+}
+if(x.hasIndexedInterceptor()){
+bj.indexedInterceptor=true;
+}
+if(x.isFunction()){
+bj.name=x.name();
+if(!(x.inferredName()===(void 0))){
+bj.inferredName=x.inferredName();
+}
+bj.resolved=x.resolved();
+if(x.resolved()){
+bj.source=x.source();
+}
+if(x.script()){
+bj.script=this.serializeReference(x.script());
+bj.scriptId=x.script().id();
+serializeLocationFields(x.sourceLocation(),bj);
+}
+bj.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bp=x.scope(N);
+bj.scopes.push({
+type:bp.scopeType(),
+index:N
+});
+}
+}
+if(x.isGenerator()){
+bj.status=x.status();
+bj.func=this.serializeReference(x.func())
+bj.receiver=this.serializeReference(x.receiver())
+serializeLocationFields(x.sourceLocation(),bj);
+}
+if(x.isDate()){
+bj.value=x.value();
+}
+if(x.isPromise()){
+bj.status=x.status();
+bj.promiseValue=this.serializeReference(x.promiseValue());
+}
+var M=x.propertyNames();
+for(var N=0;N<M.length;N++){
+var bq=x.property(M[N]);
+M[N]=this.serializeProperty_(bq);
+if(P){
+this.add_(bq.value());
+}
+}
+bj.properties=M;
+var br=x.internalProperties();
+if(br.length>0){
+var bs=[];
+for(var N=0;N<br.length;N++){
+bs.push(this.serializeInternalProperty_(br[N]));
+}
+bj.internalProperties=bs;
+}
+};
+function serializeLocationFields(aG,bj){
+if(!aG){
+return;
+}
+bj.position=aG.position;
+var bt=aG.line;
+if(!(bt===(void 0))){
+bj.line=bt;
+}
+var bu=aG.column;
+if(!(bu===(void 0))){
+bj.column=bu;
+}
+}
+JSONProtocolSerializer.prototype.serializeProperty_=function(bq){
+var S={};
+S.name=bq.name();
+var bv=bq.value();
+if(this.inlineRefs_()&&bv.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bv);
+}else{
+if(bq.attributes()!=F.None){
+S.attributes=bq.attributes();
+}
+S.propertyType=bq.propertyType();
+S.ref=bv.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeInternalProperty_=
+function(bq){
+var S={};
+S.name=bq.name();
+var bv=bq.value();
+if(this.inlineRefs_()&&bv.isValue()){
+S.value=this.serializeReferenceWithDisplayData_(bv);
+}else{
+S.ref=bv.handle();
+}
+return S;
+};
+JSONProtocolSerializer.prototype.serializeFrame_=function(x,bj){
+bj.index=x.index();
+bj.receiver=this.serializeReference(x.receiver());
+var aF=x.func();
+bj.func=this.serializeReference(aF);
+var T=aF.script();
+if(T){
+bj.script=this.serializeReference(T);
+}
+bj.constructCall=x.isConstructCall();
+bj.atReturn=x.isAtReturn();
+if(x.isAtReturn()){
+bj.returnValue=this.serializeReference(x.returnValue());
+}
+bj.debuggerFrame=x.isDebuggerFrame();
+var K=new d(x.argumentCount());
+for(var N=0;N<x.argumentCount();N++){
+var bw={};
+var bx=x.argumentName(N);
+if(bx){
+bw.name=bx;
+}
+bw.value=this.serializeReference(x.argumentValue(N));
+K[N]=bw;
+}
+bj.arguments=K;
+var K=new d(x.localCount());
+for(var N=0;N<x.localCount();N++){
+var by={};
+by.name=x.localName(N);
+by.value=this.serializeReference(x.localValue(N));
+K[N]=by;
+}
+bj.locals=K;
+serializeLocationFields(x.sourceLocation(),bj);
+var bz=x.sourceLineText();
+if(!(bz===(void 0))){
+bj.sourceLineText=bz;
+}
+bj.scopes=[];
+for(var N=0;N<x.scopeCount();N++){
+var bp=x.scope(N);
+bj.scopes.push({
+type:bp.scopeType(),
+index:N
+});
+}
+};
+JSONProtocolSerializer.prototype.serializeScope_=function(x,bj){
+bj.index=x.scopeIndex();
+bj.frameIndex=x.frameIndex();
+bj.type=x.scopeType();
+bj.object=this.inlineRefs_()?
+this.serializeValue(x.scopeObject()):
+this.serializeReference(x.scopeObject());
+};
+function NumberToJSON_(v){
+if(e(v)){
+return'NaN';
+}
+if(!(%_IsSmi(%IS_VAR(v))||((v==v)&&(v!=1/0)&&(v!=-1/0)))){
+if(v>0){
+return'Infinity';
+}else{
+return'-Infinity';
+}
+}
+return v;
+}
+b.InstallFunctions(a,2,[
+"MakeMirror",MakeMirror,
+"MakeMirrorSerializer",MakeMirrorSerializer,
+"LookupMirror",LookupMirror,
+"ToggleMirrorCache",ToggleMirrorCache,
+"MirrorCacheIsEmpty",MirrorCacheIsEmpty,
+]);
+b.InstallConstants(a,[
+"ScopeType",G,
+"PropertyType",E,
+"PropertyAttribute",F,
+"Mirror",Mirror,
+"ValueMirror",ValueMirror,
+"UndefinedMirror",UndefinedMirror,
+"NullMirror",NullMirror,
+"BooleanMirror",BooleanMirror,
+"NumberMirror",NumberMirror,
+"StringMirror",StringMirror,
+"SymbolMirror",SymbolMirror,
+"ObjectMirror",ObjectMirror,
+"FunctionMirror",FunctionMirror,
+"UnresolvedFunctionMirror",UnresolvedFunctionMirror,
+"ArrayMirror",ArrayMirror,
+"DateMirror",DateMirror,
+"RegExpMirror",RegExpMirror,
+"ErrorMirror",ErrorMirror,
+"PromiseMirror",PromiseMirror,
+"MapMirror",MapMirror,
+"SetMirror",SetMirror,
+"IteratorMirror",IteratorMirror,
+"GeneratorMirror",GeneratorMirror,
+"PropertyMirror",PropertyMirror,
+"InternalPropertyMirror",InternalPropertyMirror,
+"FrameMirror",FrameMirror,
+"ScriptMirror",ScriptMirror,
+"ScopeMirror",ScopeMirror,
+"FrameDetails",FrameDetails,
+]);
+b.InstallFunctions(b,2,[
+"ClearMirrorCache",ClearMirrorCache
+]);
+b.Export(function(bA){
+bA.MirrorType=q;
+});
+})
+
+debugNƒ
+(function(a,b){
+"use strict";
+var c=a.FrameMirror;
+var d=a.Array;
+var e=a.RegExp;
+var f=a.isNaN;
+var g=a.JSON.parse;
+var h=a.JSON.stringify;
+var i=a.LookupMirror;
+var j;
+var k;
+var l=a.MakeMirror;
+var m=a.MakeMirrorSerializer;
+var n=a.Math.min;
+var o=a.Mirror;
+var p;
+var q=a.parseInt;
+var r=a.ValueMirror;
+b.Import(function(s){
+j=s.MakeError;
+k=s.MakeTypeError;
+p=s.MirrorType;
+});
+var t=10;
+var u={};
+var v=/^(?:\s*(?:\/\*.*?\*\/)*)*/;
+u.DebugEvent={Break:1,
+Exception:2,
+NewFunction:3,
+BeforeCompile:4,
+AfterCompile:5,
+CompileError:6,
+PromiseEvent:7,
+AsyncTaskEvent:8};
+u.ExceptionBreak={Caught:0,
+Uncaught:1};
+u.StepAction={StepOut:0,
+StepNext:1,
+StepIn:2,
+StepFrame:3};
+u.ScriptType={Native:0,
+Extension:1,
+Normal:2};
+u.ScriptCompilationType={Host:0,
+Eval:1,
+JSON:2};
+u.ScriptBreakPointType={ScriptId:0,
+ScriptName:1,
+ScriptRegExp:2};
+u.BreakPositionAlignment={
+Statement:0,
+BreakPosition:1
+};
+function ScriptTypeFlag(w){
+return(1<<w);
+}
+var x=0;
+var y=1;
+var z=[];
+var A=[];
+var B={
+breakPointsActive:{
+value:true,
+getValue:function(){return this.value;},
+setValue:function(C){
+this.value=!!C;
+%SetBreakPointsActive(this.value);
+}
+},
+breakOnCaughtException:{
+getValue:function(){return u.isBreakOnException();},
+setValue:function(C){
+if(C){
+u.setBreakOnException();
+}else{
+u.clearBreakOnException();
+}
+}
+},
+breakOnUncaughtException:{
+getValue:function(){return u.isBreakOnUncaughtException();},
+setValue:function(C){
+if(C){
+u.setBreakOnUncaughtException();
+}else{
+u.clearBreakOnUncaughtException();
+}
+}
+},
+};
+function MakeBreakPoint(D,E){
+var F=new BreakPoint(D,E);
+z.push(F);
+return F;
+}
+function BreakPoint(D,E){
+this.source_position_=D;
+if(E){
+this.script_break_point_=E;
+}else{
+this.number_=y++;
+}
+this.hit_count_=0;
+this.active_=true;
+this.condition_=null;
+this.ignoreCount_=0;
+}
+BreakPoint.prototype.number=function(){
+return this.number_;
+};
+BreakPoint.prototype.func=function(){
+return this.func_;
+};
+BreakPoint.prototype.source_position=function(){
+return this.source_position_;
+};
+BreakPoint.prototype.hit_count=function(){
+return this.hit_count_;
+};
+BreakPoint.prototype.active=function(){
+if(this.script_break_point()){
+return this.script_break_point().active();
+}
+return this.active_;
+};
+BreakPoint.prototype.condition=function(){
+if(this.script_break_point()&&this.script_break_point().condition()){
+return this.script_break_point().condition();
+}
+return this.condition_;
+};
+BreakPoint.prototype.ignoreCount=function(){
+return this.ignoreCount_;
+};
+BreakPoint.prototype.script_break_point=function(){
+return this.script_break_point_;
+};
+BreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+BreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+BreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+BreakPoint.prototype.setIgnoreCount=function(H){
+this.ignoreCount_=H;
+};
+BreakPoint.prototype.isTriggered=function(I){
+if(!this.active())return false;
+if(this.condition()){
+try{
+var J=I.frame(0).evaluate(this.condition());
+if(!(J instanceof r)||!J.value_){
+return false;
+}
+}catch(e){
+return false;
+}
+}
+this.hit_count_++;
+if(this.script_break_point_){
+this.script_break_point_.hit_count_++;
+}
+if(this.ignoreCount_>0){
+this.ignoreCount_--;
+return false;
+}
+return true;
+};
+function IsBreakPointTriggered(K,F){
+return F.isTriggered(MakeExecutionState(K));
+}
+function ScriptBreakPoint(w,script_id_or_name,opt_line,opt_column,
+opt_groupId,opt_position_alignment){
+this.type_=w;
+if(w==u.ScriptBreakPointType.ScriptId){
+this.script_id_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptName){
+this.script_name_=script_id_or_name;
+}else if(w==u.ScriptBreakPointType.ScriptRegExp){
+this.script_regexp_object_=new e(script_id_or_name);
+}else{
+throw j(2,"Unexpected breakpoint type "+w);
+}
+this.line_=opt_line||0;
+this.column_=opt_column;
+this.groupId_=opt_groupId;
+this.position_alignment_=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+this.hit_count_=0;
+this.active_=true;
+this.condition_=null;
+this.ignoreCount_=0;
+this.break_points_=[];
+}
+ScriptBreakPoint.prototype.cloneForOtherScript=function(L){
+var M=new ScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+L.id,this.line_,this.column_,this.groupId_,
+this.position_alignment_);
+M.number_=y++;
+A.push(M);
+M.hit_count_=this.hit_count_;
+M.active_=this.active_;
+M.condition_=this.condition_;
+M.ignoreCount_=this.ignoreCount_;
+return M;
+};
+ScriptBreakPoint.prototype.number=function(){
+return this.number_;
+};
+ScriptBreakPoint.prototype.groupId=function(){
+return this.groupId_;
+};
+ScriptBreakPoint.prototype.type=function(){
+return this.type_;
+};
+ScriptBreakPoint.prototype.script_id=function(){
+return this.script_id_;
+};
+ScriptBreakPoint.prototype.script_name=function(){
+return this.script_name_;
+};
+ScriptBreakPoint.prototype.script_regexp_object=function(){
+return this.script_regexp_object_;
+};
+ScriptBreakPoint.prototype.line=function(){
+return this.line_;
+};
+ScriptBreakPoint.prototype.column=function(){
+return this.column_;
+};
+ScriptBreakPoint.prototype.actual_locations=function(){
+var N=[];
+for(var O=0;O<this.break_points_.length;O++){
+N.push(this.break_points_[O].actual_location);
+}
+return N;
+};
+ScriptBreakPoint.prototype.update_positions=function(P,Q){
+this.line_=P;
+this.column_=Q;
+};
+ScriptBreakPoint.prototype.hit_count=function(){
+return this.hit_count_;
+};
+ScriptBreakPoint.prototype.active=function(){
+return this.active_;
+};
+ScriptBreakPoint.prototype.condition=function(){
+return this.condition_;
+};
+ScriptBreakPoint.prototype.ignoreCount=function(){
+return this.ignoreCount_;
+};
+ScriptBreakPoint.prototype.enable=function(){
+this.active_=true;
+};
+ScriptBreakPoint.prototype.disable=function(){
+this.active_=false;
+};
+ScriptBreakPoint.prototype.setCondition=function(G){
+this.condition_=G;
+};
+ScriptBreakPoint.prototype.setIgnoreCount=function(H){
+this.ignoreCount_=H;
+for(var O=0;O<this.break_points_.length;O++){
+this.break_points_[O].setIgnoreCount(H);
+}
+};
+ScriptBreakPoint.prototype.matchesScript=function(R){
+if(this.type_==u.ScriptBreakPointType.ScriptId){
+return this.script_id_==R.id;
+}else{
+if(!(R.line_offset<=this.line_&&
+this.line_<R.line_offset+R.lineCount())){
+return false;
+}
+if(this.type_==u.ScriptBreakPointType.ScriptName){
+return this.script_name_==R.nameOrSourceURL();
+}else if(this.type_==u.ScriptBreakPointType.ScriptRegExp){
+return this.script_regexp_object_.test(R.nameOrSourceURL());
+}else{
+throw j(2,"Unexpected breakpoint type "+this.type_);
+}
+}
+};
+ScriptBreakPoint.prototype.set=function(R){
+var Q=this.column();
+var P=this.line();
+if((Q===(void 0))){
+var S=R.sourceLine(this.line());
+if(!R.sourceColumnStart_){
+R.sourceColumnStart_=new d(R.lineCount());
+}
+if((R.sourceColumnStart_[P]===(void 0))){
+R.sourceColumnStart_[P]=
+S.match(v)[0].length;
+}
+Q=R.sourceColumnStart_[P];
+}
+var T=u.findScriptSourcePosition(R,this.line(),Q);
+if((T===null))return;
+var F=MakeBreakPoint(T,this);
+F.setIgnoreCount(this.ignoreCount());
+var U=%SetScriptBreakPoint(R,T,
+this.position_alignment_,
+F);
+if((U===(void 0))){
+U=T;
+}
+var V=R.locationFromPosition(U,true);
+F.actual_location={line:V.line,
+column:V.column,
+script_id:R.id};
+this.break_points_.push(F);
+return F;
+};
+ScriptBreakPoint.prototype.clear=function(){
+var W=[];
+for(var O=0;O<z.length;O++){
+if(z[O].script_break_point()&&
+z[O].script_break_point()===this){
+%ClearBreakPoint(z[O]);
+}else{
+W.push(z[O]);
+}
+}
+z=W;
+this.break_points_=[];
+};
+function UpdateScriptBreakPoints(R){
+for(var O=0;O<A.length;O++){
+var F=A[O];
+if((F.type()==u.ScriptBreakPointType.ScriptName||
+F.type()==u.ScriptBreakPointType.ScriptRegExp)&&
+F.matchesScript(R)){
+F.set(R);
+}
+}
+}
+function GetScriptBreakPoints(R){
+var X=[];
+for(var O=0;O<A.length;O++){
+if(A[O].matchesScript(R)){
+X.push(A[O]);
+}
+}
+return X;
+}
+u.setListener=function(Y,Z){
+if(!(%_IsFunction(Y))&&!(Y===(void 0))&&!(Y===null)){
+throw k(32);
+}
+%SetDebugEventListener(Y,Z);
+};
+u.breakLocations=function(aa,ab){
+if(!(%_IsFunction(aa)))throw k(32);
+var ac=(ab===(void 0))
+?u.BreakPositionAlignment.Statement:ab;
+return %GetBreakLocations(aa,ac);
+};
+u.findScript=function(ad){
+if((%_IsFunction(ad))){
+return %FunctionGetScript(ad);
+}else if((%_IsRegExp(ad))){
+var ae=u.scripts();
+var af=null;
+var ag=0;
+for(var O in ae){
+var R=ae[O];
+if(ad.test(R.name)){
+af=R;
+ag++;
+}
+}
+if(ag==1){
+return af;
+}else{
+return(void 0);
+}
+}else{
+return %GetScript(ad);
+}
+};
+u.scriptSource=function(ad){
+return this.findScript(ad).source;
+};
+u.source=function(aa){
+if(!(%_IsFunction(aa)))throw k(32);
+return %FunctionGetSourceCode(aa);
+};
+u.sourcePosition=function(aa){
+if(!(%_IsFunction(aa)))throw k(32);
+return %FunctionGetScriptSourcePosition(aa);
+};
+u.findFunctionSourceLocation=function(ah,ai,aj){
+var R=%FunctionGetScript(ah);
+var ak=%FunctionGetScriptSourcePosition(ah);
+return R.locationFromLine(ai,aj,ak);
+};
+u.findScriptSourcePosition=function(R,ai,aj){
+var al=R.locationFromLine(ai,aj);
+return al?al.position:null;
+};
+u.findBreakPoint=function(am,an){
+var F;
+for(var O=0;O<z.length;O++){
+if(z[O].number()==am){
+F=z[O];
+if(an){
+z.splice(O,1);
+}
+break;
+}
+}
+if(F){
+return F;
+}else{
+return this.findScriptBreakPoint(am,an);
+}
+};
+u.findBreakPointActualLocations=function(am){
+for(var O=0;O<A.length;O++){
+if(A[O].number()==am){
+return A[O].actual_locations();
+}
+}
+for(var O=0;O<z.length;O++){
+if(z[O].number()==am){
+return[z[O].actual_location];
+}
+}
+return[];
+};
+u.setBreakPoint=function(ah,ai,aj,ao){
+if(!(%_IsFunction(ah)))throw k(32);
+if(%FunctionIsAPIFunction(ah)){
+throw j(2,'Cannot set break point in native code.');
+}
+var ap=
+this.findFunctionSourceLocation(ah,ai,aj).position;
+var D=ap-this.sourcePosition(ah);
+var R=%FunctionGetScript(ah);
+if(R.type==u.ScriptType.Native){
+throw j(2,'Cannot set break point in native code.');
+}
+if(R&&R.id){
+D+=%FunctionGetScriptSourcePosition(ah);
+var al=R.locationFromPosition(D,false);
+return this.setScriptBreakPointById(R.id,
+al.line,al.column,
+ao);
+}else{
+var F=MakeBreakPoint(D);
+var U=
+%SetFunctionBreakPoint(ah,D,F);
+U+=this.sourcePosition(ah);
+var V=R.locationFromPosition(U,true);
+F.actual_location={line:V.line,
+column:V.column,
+script_id:R.id};
+F.setCondition(ao);
+return F.number();
+}
+};
+u.setBreakPointByScriptIdAndPosition=function(script_id,T,
+G,enabled,
+opt_position_alignment)
+{
+var F=MakeBreakPoint(T);
+F.setCondition(G);
+if(!enabled){
+F.disable();
+}
+var ae=this.scripts();
+var aq=(opt_position_alignment===(void 0))
+?u.BreakPositionAlignment.Statement:opt_position_alignment;
+for(var O=0;O<ae.length;O++){
+if(script_id==ae[O].id){
+F.actual_position=%SetScriptBreakPoint(ae[O],T,
+aq,F);
+break;
+}
+}
+return F;
+};
+u.enableBreakPoint=function(am){
+var F=this.findBreakPoint(am,false);
+if(F){
+F.enable();
+}
+};
+u.disableBreakPoint=function(am){
+var F=this.findBreakPoint(am,false);
+if(F){
+F.disable();
+}
+};
+u.changeBreakPointCondition=function(am,G){
+var F=this.findBreakPoint(am,false);
+F.setCondition(G);
+};
+u.changeBreakPointIgnoreCount=function(am,H){
+if(H<0)throw j(2,'Invalid argument');
+var F=this.findBreakPoint(am,false);
+F.setIgnoreCount(H);
+};
+u.clearBreakPoint=function(am){
+var F=this.findBreakPoint(am,true);
+if(F){
+return %ClearBreakPoint(F);
+}else{
+F=this.findScriptBreakPoint(am,true);
+if(!F)throw j(2,'Invalid breakpoint');
+}
+};
+u.clearAllBreakPoints=function(){
+for(var O=0;O<z.length;O++){
+var F=z[O];
+%ClearBreakPoint(F);
+}
+z=[];
+};
+u.disableAllBreakPoints=function(){
+for(var O=1;O<y;O++){
+u.disableBreakPoint(O);
+}
+%ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.findScriptBreakPoint=function(am,an){
+var ar;
+for(var O=0;O<A.length;O++){
+if(A[O].number()==am){
+ar=A[O];
+if(an){
+ar.clear();
+A.splice(O,1);
+}
+break;
+}
+}
+return ar;
+};
+u.setScriptBreakPoint=function(w,script_id_or_name,
+ai,aj,ao,
+opt_groupId,opt_position_alignment){
+var ar=
+new ScriptBreakPoint(w,script_id_or_name,ai,aj,
+opt_groupId,opt_position_alignment);
+ar.number_=y++;
+ar.setCondition(ao);
+A.push(ar);
+var ae=this.scripts();
+for(var O=0;O<ae.length;O++){
+if(ar.matchesScript(ae[O])){
+ar.set(ae[O]);
+}
+}
+return ar.number();
+};
+u.setScriptBreakPointById=function(script_id,
+ai,aj,
+ao,opt_groupId,
+opt_position_alignment){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptId,
+script_id,ai,aj,
+ao,opt_groupId,
+opt_position_alignment);
+};
+u.setScriptBreakPointByName=function(script_name,
+ai,aj,
+ao,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptName,
+script_name,ai,aj,
+ao,opt_groupId);
+};
+u.setScriptBreakPointByRegExp=function(script_regexp,
+ai,aj,
+ao,opt_groupId){
+return this.setScriptBreakPoint(u.ScriptBreakPointType.ScriptRegExp,
+script_regexp,ai,aj,
+ao,opt_groupId);
+};
+u.enableScriptBreakPoint=function(am){
+var ar=this.findScriptBreakPoint(am,false);
+ar.enable();
+};
+u.disableScriptBreakPoint=function(am){
+var ar=this.findScriptBreakPoint(am,false);
+ar.disable();
+};
+u.changeScriptBreakPointCondition=function(
+am,G){
+var ar=this.findScriptBreakPoint(am,false);
+ar.setCondition(G);
+};
+u.changeScriptBreakPointIgnoreCount=function(
+am,H){
+if(H<0)throw j(2,'Invalid argument');
+var ar=this.findScriptBreakPoint(am,false);
+ar.setIgnoreCount(H);
+};
+u.scriptBreakPoints=function(){
+return A;
+};
+u.clearStepping=function(){
+%ClearStepping();
+};
+u.setBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,true);
+};
+u.clearBreakOnException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Caught,false);
+};
+u.isBreakOnException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Caught);
+};
+u.setBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,true);
+};
+u.clearBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(u.ExceptionBreak.Uncaught,false);
+};
+u.isBreakOnUncaughtException=function(){
+return!!%IsBreakOnException(u.ExceptionBreak.Uncaught);
+};
+u.showBreakPoints=function(aa,as,at){
+if(!(%_IsFunction(aa)))throw j(32);
+var au=as?this.scriptSource(aa):this.source(aa);
+var av=as?this.sourcePosition(aa):0;
+var N=this.breakLocations(aa,at);
+if(!N)return au;
+N.sort(function(aw,ax){return aw-ax;});
+var X="";
+var ay=0;
+var az;
+for(var O=0;O<N.length;O++){
+az=N[O]-av;
+X+=au.slice(ay,az);
+X+="[B"+O+"]";
+ay=az;
+}
+az=au.length;
+X+=au.substring(ay,az);
+return X;
+};
+u.scripts=function(){
+return %DebugGetLoadedScripts();
+};
+u.debuggerFlags=function(){
+return B;
+};
+u.MakeMirror=l;
+function MakeExecutionState(K){
+return new ExecutionState(K);
+}
+function ExecutionState(K){
+this.break_id=K;
+this.selected_frame=0;
+}
+ExecutionState.prototype.prepareStep=function(aA){
+if(aA===u.StepAction.StepIn||
+aA===u.StepAction.StepOut||
+aA===u.StepAction.StepNext||
+aA===u.StepAction.StepFrame){
+return %PrepareStep(this.break_id,aA);
+}
+throw k(32);
+};
+ExecutionState.prototype.evaluateGlobal=function(au,disable_break,
+opt_additional_context){
+return l(%DebugEvaluateGlobal(this.break_id,au,
+(!!(disable_break)),
+opt_additional_context));
+};
+ExecutionState.prototype.frameCount=function(){
+return %GetFrameCount(this.break_id);
+};
+ExecutionState.prototype.threadCount=function(){
+return %GetThreadCount(this.break_id);
+};
+ExecutionState.prototype.frame=function(aB){
+if(aB==null)aB=this.selected_frame;
+if(aB<0||aB>=this.frameCount()){
+throw k(31);
+}
+return new c(this.break_id,aB);
+};
+ExecutionState.prototype.setSelectedFrame=function(aC){
+var O=(%_ToNumber(aC));
+if(O<0||O>=this.frameCount()){
+throw k(31);
+}
+this.selected_frame=O;
+};
+ExecutionState.prototype.selectedFrame=function(){
+return this.selected_frame;
+};
+ExecutionState.prototype.debugCommandProcessor=function(aD){
+return new DebugCommandProcessor(this,aD);
+};
+function MakeBreakEvent(K,aE){
+return new BreakEvent(K,aE);
+}
+function BreakEvent(K,aE){
+this.frame_=new c(K,0);
+this.break_points_hit_=aE;
+}
+BreakEvent.prototype.eventType=function(){
+return u.DebugEvent.Break;
+};
+BreakEvent.prototype.func=function(){
+return this.frame_.func();
+};
+BreakEvent.prototype.sourceLine=function(){
+return this.frame_.sourceLine();
+};
+BreakEvent.prototype.sourceColumn=function(){
+return this.frame_.sourceColumn();
+};
+BreakEvent.prototype.sourceLineText=function(){
+return this.frame_.sourceLineText();
+};
+BreakEvent.prototype.breakPointsHit=function(){
+return this.break_points_hit_;
+};
+BreakEvent.prototype.toJSONProtocol=function(){
+var aF={seq:x++,
+type:"event",
+event:"break",
+body:{invocationText:this.frame_.invocationText()}
+};
+var R=this.func().script();
+if(R){
+aF.body.sourceLine=this.sourceLine(),
+aF.body.sourceColumn=this.sourceColumn(),
+aF.body.sourceLineText=this.sourceLineText(),
+aF.body.script=MakeScriptObject_(R,false);
+}
+if(this.breakPointsHit()){
+aF.body.breakpoints=[];
+for(var O=0;O<this.breakPointsHit().length;O++){
+var aG=this.breakPointsHit()[O];
+var ar=aG.script_break_point();
+var aH;
+if(ar){
+aH=ar.number();
+}else{
+aH=aG.number();
+}
+aF.body.breakpoints.push(aH);
+}
+}
+return h(ObjectToProtocolObject_(aF));
+};
+function MakeExceptionEvent(K,aI,aJ,aK){
+return new ExceptionEvent(K,aI,aJ,aK);
+}
+function ExceptionEvent(K,aI,aJ,aK){
+this.exec_state_=new ExecutionState(K);
+this.exception_=aI;
+this.uncaught_=aJ;
+this.promise_=aK;
+}
+ExceptionEvent.prototype.eventType=function(){
+return u.DebugEvent.Exception;
+};
+ExceptionEvent.prototype.exception=function(){
+return this.exception_;
+};
+ExceptionEvent.prototype.uncaught=function(){
+return this.uncaught_;
+};
+ExceptionEvent.prototype.promise=function(){
+return this.promise_;
+};
+ExceptionEvent.prototype.func=function(){
+return this.exec_state_.frame(0).func();
+};
+ExceptionEvent.prototype.sourceLine=function(){
+return this.exec_state_.frame(0).sourceLine();
+};
+ExceptionEvent.prototype.sourceColumn=function(){
+return this.exec_state_.frame(0).sourceColumn();
+};
+ExceptionEvent.prototype.sourceLineText=function(){
+return this.exec_state_.frame(0).sourceLineText();
+};
+ExceptionEvent.prototype.toJSONProtocol=function(){
+var aF=new ProtocolMessage();
+aF.event="exception";
+aF.body={uncaught:this.uncaught_,
+exception:l(this.exception_)
+};
+if(this.exec_state_.frameCount()>0){
+aF.body.sourceLine=this.sourceLine();
+aF.body.sourceColumn=this.sourceColumn();
+aF.body.sourceLineText=this.sourceLineText();
+var R=this.func().script();
+if(R){
+aF.body.script=MakeScriptObject_(R,false);
+}
+}else{
+aF.body.sourceLine=-1;
+}
+return aF.toJSONProtocol();
+};
+function MakeCompileEvent(R,w){
+return new CompileEvent(R,w);
+}
+function CompileEvent(R,w){
+this.script_=l(R);
+this.type_=w;
+}
+CompileEvent.prototype.eventType=function(){
+return this.type_;
+};
+CompileEvent.prototype.script=function(){
+return this.script_;
+};
+CompileEvent.prototype.toJSONProtocol=function(){
+var aF=new ProtocolMessage();
+aF.running=true;
+switch(this.type_){
+case u.DebugEvent.BeforeCompile:
+aF.event="beforeCompile";
+break;
+case u.DebugEvent.AfterCompile:
+aF.event="afterCompile";
+break;
+case u.DebugEvent.CompileError:
+aF.event="compileError";
+break;
+}
+aF.body={};
+aF.body.script=this.script_;
+return aF.toJSONProtocol();
+};
+function MakeScriptObject_(R,aL){
+var aF={id:R.id(),
+name:R.name(),
+lineOffset:R.lineOffset(),
+columnOffset:R.columnOffset(),
+lineCount:R.lineCount(),
+};
+if(!(R.data()===(void 0))){
+aF.data=R.data();
+}
+if(aL){
+aF.source=R.source();
+}
+return aF;
+}
+function MakePromiseEvent(aM){
+return new PromiseEvent(aM);
+}
+function PromiseEvent(aM){
+this.promise_=aM.promise;
+this.parentPromise_=aM.parentPromise;
+this.status_=aM.status;
+this.value_=aM.value;
+}
+PromiseEvent.prototype.promise=function(){
+return l(this.promise_);
+}
+PromiseEvent.prototype.parentPromise=function(){
+return l(this.parentPromise_);
+}
+PromiseEvent.prototype.status=function(){
+return this.status_;
+}
+PromiseEvent.prototype.value=function(){
+return l(this.value_);
+}
+function MakeAsyncTaskEvent(aM){
+return new AsyncTaskEvent(aM);
+}
+function AsyncTaskEvent(aM){
+this.type_=aM.type;
+this.name_=aM.name;
+this.id_=aM.id;
+}
+AsyncTaskEvent.prototype.type=function(){
+return this.type_;
+}
+AsyncTaskEvent.prototype.name=function(){
+return this.name_;
+}
+AsyncTaskEvent.prototype.id=function(){
+return this.id_;
+}
+function DebugCommandProcessor(I,aD){
+this.exec_state_=I;
+this.running_=aD||false;
+}
+DebugCommandProcessor.prototype.processDebugRequest=function(aN){
+return this.processDebugJSONRequest(aN);
+};
+function ProtocolMessage(aN){
+this.seq=x++;
+if(aN){
+this.type='response';
+this.request_seq=aN.seq;
+this.command=aN.command;
+}else{
+this.type='event';
+}
+this.success=true;
+this.running=(void 0);
+}
+ProtocolMessage.prototype.setOption=function(aO,C){
+if(!this.options_){
+this.options_={};
+}
+this.options_[aO]=C;
+};
+ProtocolMessage.prototype.failed=function(aP,aQ){
+this.success=false;
+this.message=aP;
+if((typeof(aQ)==='object')){
+this.error_details=aQ;
+}
+};
+ProtocolMessage.prototype.toJSONProtocol=function(){
+var aR={};
+aR.seq=this.seq;
+if(this.request_seq){
+aR.request_seq=this.request_seq;
+}
+aR.type=this.type;
+if(this.event){
+aR.event=this.event;
+}
+if(this.command){
+aR.command=this.command;
+}
+if(this.success){
+aR.success=this.success;
+}else{
+aR.success=false;
+}
+if(this.body){
+var aS;
+var aT=m(true,this.options_);
+if(this.body instanceof o){
+aS=aT.serializeValue(this.body);
+}else if(this.body instanceof d){
+aS=[];
+for(var O=0;O<this.body.length;O++){
+if(this.body[O]instanceof o){
+aS.push(aT.serializeValue(this.body[O]));
+}else{
+aS.push(ObjectToProtocolObject_(this.body[O],aT));
+}
+}
+}else{
+aS=ObjectToProtocolObject_(this.body,aT);
+}
+aR.body=aS;
+aR.refs=aT.serializeReferencedObjects();
+}
+if(this.message){
+aR.message=this.message;
+}
+if(this.error_details){
+aR.error_details=this.error_details;
+}
+aR.running=this.running;
+return h(aR);
+};
+DebugCommandProcessor.prototype.createResponse=function(aN){
+return new ProtocolMessage(aN);
+};
+DebugCommandProcessor.prototype.processDebugJSONRequest=function(
+json_request){
+var aN;
+var aU;
+try{
+try{
+aN=g(json_request);
+aU=this.createResponse(aN);
+if(!aN.type){
+throw j(2,'Type not specified');
+}
+if(aN.type!='request'){
+throw j(2,
+"Illegal type '"+aN.type+"' in request");
+}
+if(!aN.command){
+throw j(2,'Command not specified');
+}
+if(aN.arguments){
+var aV=aN.arguments;
+if(aV.inlineRefs||aV.compactFormat){
+aU.setOption('inlineRefs',true);
+}
+if(!(aV.maxStringLength===(void 0))){
+aU.setOption('maxStringLength',aV.maxStringLength);
+}
+}
+var aW=aN.command.toLowerCase();
+var aX=DebugCommandProcessor.prototype.dispatch_[aW];
+if((%_IsFunction(aX))){
+%_Call(aX,this,aN,aU);
+}else{
+throw j(2,
+'Unknown command "'+aN.command+'" in request');
+}
+}catch(e){
+if(!aU){
+aU=this.createResponse();
+}
+aU.success=false;
+aU.message=(%_ToString(e));
+}
+try{
+if(!(aU.running===(void 0))){
+this.running_=aU.running;
+}
+aU.running=this.running_;
+return aU.toJSONProtocol();
+}catch(e){
+return'{"seq":'+aU.seq+','+
+'"request_seq":'+aN.seq+','+
+'"type":"response",'+
+'"success":false,'+
+'"message":"Internal error: '+(%_ToString(e))+'"}';
+}
+}catch(e){
+return'{"seq":0,"type":"response","success":false,"message":"Internal error"}';
+}
+};
+DebugCommandProcessor.prototype.continueRequest_=function(aN,aU){
+if(aN.arguments){
+var aA=u.StepAction.StepIn;
+var aY=aN.arguments.stepaction;
+if(aY){
+if(aY=='in'){
+aA=u.StepAction.StepIn;
+}else if(aY=='next'){
+aA=u.StepAction.StepNext;
+}else if(aY=='out'){
+aA=u.StepAction.StepOut;
+}else{
+throw j(2,
+'Invalid stepaction argument "'+aY+'".');
+}
+}
+this.exec_state_.prepareStep(aA);
+}
+aU.running=true;
+};
+DebugCommandProcessor.prototype.breakRequest_=function(aN,aU){
+};
+DebugCommandProcessor.prototype.setBreakPointRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var w=aN.arguments.type;
+var aZ=aN.arguments.target;
+var P=aN.arguments.line;
+var Q=aN.arguments.column;
+var ba=(aN.arguments.enabled===(void 0))?
+true:aN.arguments.enabled;
+var G=aN.arguments.condition;
+var H=aN.arguments.ignoreCount;
+var bb=aN.arguments.groupId;
+if(!w||(aZ===(void 0))){
+aU.failed('Missing argument "type" or "target"');
+return;
+}
+var am;
+if(w=='function'){
+if(!(typeof(aZ)==='string')){
+aU.failed('Argument "target" is not a string value');
+return;
+}
+var aa;
+try{
+aa=this.exec_state_.evaluateGlobal(aZ).value();
+}catch(e){
+aU.failed('Error: "'+(%_ToString(e))+
+'" evaluating "'+aZ+'"');
+return;
+}
+if(!(%_IsFunction(aa))){
+aU.failed('"'+aZ+'" does not evaluate to a function');
+return;
+}
+am=u.setBreakPoint(aa,P,Q,G);
+}else if(w=='handle'){
+var bc=q(aZ,10);
+var J=i(bc);
+if(!J){
+return aU.failed('Object #'+bc+'# not found');
+}
+if(!J.isFunction()){
+return aU.failed('Object #'+bc+'# is not a function');
+}
+am=u.setBreakPoint(J.value(),
+P,Q,G);
+}else if(w=='script'){
+am=
+u.setScriptBreakPointByName(aZ,P,Q,G,
+bb);
+}else if(w=='scriptId'){
+am=
+u.setScriptBreakPointById(aZ,P,Q,G,bb);
+}else if(w=='scriptRegExp'){
+am=
+u.setScriptBreakPointByRegExp(aZ,P,Q,G,
+bb);
+}else{
+aU.failed('Illegal type "'+w+'"');
+return;
+}
+var F=u.findBreakPoint(am);
+if(H){
+u.changeBreakPointIgnoreCount(am,H);
+}
+if(!ba){
+u.disableBreakPoint(am);
+}
+aU.body={type:w,
+breakpoint:am};
+if(F instanceof ScriptBreakPoint){
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+aU.body.type='scriptId';
+aU.body.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+aU.body.type='scriptName';
+aU.body.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+aU.body.type='scriptRegExp';
+aU.body.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+aU.body.line=F.line();
+aU.body.column=F.column();
+aU.body.actual_locations=F.actual_locations();
+}else{
+aU.body.type='function';
+aU.body.actual_locations=[F.actual_location];
+}
+};
+DebugCommandProcessor.prototype.changeBreakPointRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aN.arguments.breakpoint));
+var ba=aN.arguments.enabled;
+var G=aN.arguments.condition;
+var H=aN.arguments.ignoreCount;
+if(!F){
+aU.failed('Missing argument "breakpoint"');
+return;
+}
+if(!(ba===(void 0))){
+if(ba){
+u.enableBreakPoint(F);
+}else{
+u.disableBreakPoint(F);
+}
+}
+if(!(G===(void 0))){
+u.changeBreakPointCondition(F,G);
+}
+if(!(H===(void 0))){
+u.changeBreakPointIgnoreCount(F,H);
+}
+};
+DebugCommandProcessor.prototype.clearBreakPointGroupRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var bd=aN.arguments.groupId;
+if(!bd){
+aU.failed('Missing argument "groupId"');
+return;
+}
+var be=[];
+var bf=[];
+for(var O=0;O<A.length;O++){
+var bg=A[O];
+if(bg.groupId()==bd){
+be.push(bg.number());
+bg.clear();
+}else{
+bf.push(bg);
+}
+}
+A=bf;
+aU.body={breakpoints:be};
+};
+DebugCommandProcessor.prototype.clearBreakPointRequest_=function(
+aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var F=(%_ToNumber(aN.arguments.breakpoint));
+if(!F){
+aU.failed('Missing argument "breakpoint"');
+return;
+}
+u.clearBreakPoint(F);
+aU.body={breakpoint:F};
+};
+DebugCommandProcessor.prototype.listBreakpointsRequest_=function(
+aN,aU){
+var bh=[];
+for(var O=0;O<A.length;O++){
+var F=A[O];
+var bi={
+number:F.number(),
+line:F.line(),
+column:F.column(),
+groupId:F.groupId(),
+hit_count:F.hit_count(),
+active:F.active(),
+condition:F.condition(),
+ignoreCount:F.ignoreCount(),
+actual_locations:F.actual_locations()
+};
+if(F.type()==u.ScriptBreakPointType.ScriptId){
+bi.type='scriptId';
+bi.script_id=F.script_id();
+}else if(F.type()==u.ScriptBreakPointType.ScriptName){
+bi.type='scriptName';
+bi.script_name=F.script_name();
+}else if(F.type()==u.ScriptBreakPointType.ScriptRegExp){
+bi.type='scriptRegExp';
+bi.script_regexp=F.script_regexp_object().source;
+}else{
+throw j(2,
+"Unexpected breakpoint type: "+F.type());
+}
+bh.push(bi);
+}
+aU.body={
+breakpoints:bh,
+breakOnExceptions:u.isBreakOnException(),
+breakOnUncaughtExceptions:u.isBreakOnUncaughtException()
+};
+};
+DebugCommandProcessor.prototype.disconnectRequest_=
+function(aN,aU){
+u.disableAllBreakPoints();
+this.continueRequest_(aN,aU);
+};
+DebugCommandProcessor.prototype.setExceptionBreakRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var w=aN.arguments.type;
+if(!w){
+aU.failed('Missing argument "type"');
+return;
+}
+var ba;
+if(w=='all'){
+ba=!u.isBreakOnException();
+}else if(w=='uncaught'){
+ba=!u.isBreakOnUncaughtException();
+}
+if(!(aN.arguments.enabled===(void 0))){
+ba=aN.arguments.enabled;
+if((ba!=true)&&(ba!=false)){
+aU.failed('Illegal value for "enabled":"'+ba+'"');
+}
+}
+if(w=='all'){
+%ChangeBreakOnException(u.ExceptionBreak.Caught,ba);
+}else if(w=='uncaught'){
+%ChangeBreakOnException(u.ExceptionBreak.Uncaught,ba);
+}else{
+aU.failed('Unknown "type":"'+w+'"');
+}
+aU.body={'type':w,'enabled':ba};
+};
+DebugCommandProcessor.prototype.backtraceRequest_=function(
+aN,aU){
+var bj=this.exec_state_.frameCount();
+if(bj==0){
+aU.body={
+totalFrames:bj
+};
+return;
+}
+var bk=0;
+var bl=t;
+if(aN.arguments){
+if(aN.arguments.fromFrame){
+bk=aN.arguments.fromFrame;
+}
+if(aN.arguments.toFrame){
+bl=aN.arguments.toFrame;
+}
+if(aN.arguments.bottom){
+var bm=bj-bk;
+bk=bj-bl;
+bl=bm;
+}
+if(bk<0||bl<0){
+return aU.failed('Invalid frame number');
+}
+}
+bl=n(bj,bl);
+if(bl<=bk){
+var bn='Invalid frame range';
+return aU.failed(bn);
+}
+var bo=[];
+for(var O=bk;O<bl;O++){
+bo.push(this.exec_state_.frame(O));
+}
+aU.body={
+fromFrame:bk,
+toFrame:bl,
+totalFrames:bj,
+frames:bo
+};
+};
+DebugCommandProcessor.prototype.frameRequest_=function(aN,aU){
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+if(aN.arguments){
+var aC=aN.arguments.number;
+if(aC<0||this.exec_state_.frameCount()<=aC){
+return aU.failed('Invalid frame number');
+}
+this.exec_state_.setSelectedFrame(aN.arguments.number);
+}
+aU.body=this.exec_state_.frame();
+};
+DebugCommandProcessor.prototype.resolveFrameFromScopeDescription_=
+function(bp){
+if(bp&&!(bp.frameNumber===(void 0))){
+var bq=bp.frameNumber;
+if(bq<0||this.exec_state_.frameCount()<=bq){
+throw k(31);
+}
+return this.exec_state_.frame(bq);
+}else{
+return this.exec_state_.frame();
+}
+};
+DebugCommandProcessor.prototype.resolveScopeHolder_=
+function(bp){
+if(bp&&"functionHandle"in bp){
+if(!(typeof(bp.functionHandle)==='number')){
+throw j(2,'Function handle must be a number');
+}
+var br=i(bp.functionHandle);
+if(!br){
+throw j(2,'Failed to find function object by handle');
+}
+if(!br.isFunction()){
+throw j(2,
+'Value of non-function type is found by handle');
+}
+return br;
+}else{
+if(this.exec_state_.frameCount()==0){
+throw j(2,'No scopes');
+}
+var bs=this.resolveFrameFromScopeDescription_(bp);
+return bs;
+}
+}
+DebugCommandProcessor.prototype.scopesRequest_=function(aN,aU){
+var bt=this.resolveScopeHolder_(aN.arguments);
+var bu=bt.scopeCount();
+var bv=[];
+for(var O=0;O<bu;O++){
+bv.push(bt.scope(O));
+}
+aU.body={
+fromScope:0,
+toScope:bu,
+totalScopes:bu,
+scopes:bv
+};
+};
+DebugCommandProcessor.prototype.scopeRequest_=function(aN,aU){
+var bt=this.resolveScopeHolder_(aN.arguments);
+var bw=0;
+if(aN.arguments&&!(aN.arguments.number===(void 0))){
+bw=(%_ToNumber(aN.arguments.number));
+if(bw<0||bt.scopeCount()<=bw){
+return aU.failed('Invalid scope number');
+}
+}
+aU.body=bt.scope(bw);
+};
+DebugCommandProcessor.resolveValue_=function(bx){
+if("handle"in bx){
+var by=i(bx.handle);
+if(!by){
+throw j(2,"Failed to resolve value by handle, ' #"+
+bx.handle+"# not found");
+}
+return by.value();
+}else if("stringDescription"in bx){
+if(bx.type==p.BOOLEAN_TYPE){
+return(!!(bx.stringDescription));
+}else if(bx.type==p.NUMBER_TYPE){
+return(%_ToNumber(bx.stringDescription));
+}if(bx.type==p.STRING_TYPE){
+return(%_ToString(bx.stringDescription));
+}else{
+throw j(2,"Unknown type");
+}
+}else if("value"in bx){
+return bx.value;
+}else if(bx.type==p.UNDEFINED_TYPE){
+return(void 0);
+}else if(bx.type==p.NULL_TYPE){
+return null;
+}else{
+throw j(2,"Failed to parse value description");
+}
+};
+DebugCommandProcessor.prototype.setVariableValueRequest_=
+function(aN,aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+if((aN.arguments.name===(void 0))){
+aU.failed('Missing variable name');
+}
+var bz=aN.arguments.name;
+var bp=aN.arguments.scope;
+var bt=this.resolveScopeHolder_(bp);
+if((bp.number===(void 0))){
+aU.failed('Missing scope number');
+}
+var bw=(%_ToNumber(bp.number));
+var bA=bt.scope(bw);
+var bB=
+DebugCommandProcessor.resolveValue_(aN.arguments.newValue);
+bA.setVariableValue(bz,bB);
+var bC=l(bB);
+aU.body={
+newValue:bC
+};
+};
+DebugCommandProcessor.prototype.evaluateRequest_=function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bD=aN.arguments.expression;
+var bs=aN.arguments.frame;
+var a=aN.arguments.global;
+var bE=aN.arguments.disable_break;
+var bF=aN.arguments.additional_context;
+try{
+bD=(%_ToString(bD));
+}catch(e){
+return aU.failed('Failed to convert expression argument to string');
+}
+if(!(bs===(void 0))&&a){
+return aU.failed('Arguments "frame" and "global" are exclusive');
+}
+var bG;
+if(bF){
+bG={};
+for(var O=0;O<bF.length;O++){
+var bH=bF[O];
+if(!(typeof(bH.name)==='string')){
+return aU.failed("Context element #"+O+
+" doesn't contain name:string property");
+}
+var bI=DebugCommandProcessor.resolveValue_(bH);
+bG[bH.name]=bI;
+}
+}
+if(a){
+aU.body=this.exec_state_.evaluateGlobal(
+bD,(!!(bE)),bG);
+return;
+}
+if((bE===(void 0))){
+bE=true;
+}
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+if(!(bs===(void 0))){
+var bJ=(%_ToNumber(bs));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+aU.body=this.exec_state_.frame(bJ).evaluate(
+bD,(!!(bE)),bG);
+return;
+}else{
+aU.body=this.exec_state_.frame().evaluate(
+bD,(!!(bE)),bG);
+return;
+}
+};
+DebugCommandProcessor.prototype.lookupRequest_=function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bK=aN.arguments.handles;
+if((bK===(void 0))){
+return aU.failed('Argument "handles" missing');
+}
+if(!(aN.arguments.includeSource===(void 0))){
+var bL=(!!(aN.arguments.includeSource));
+aU.setOption('includeSource',bL);
+}
+var bM={};
+for(var O=0;O<bK.length;O++){
+var bc=bK[O];
+var J=i(bc);
+if(!J){
+return aU.failed('Object #'+bc+'# not found');
+}
+bM[bc]=J;
+}
+aU.body=bM;
+};
+DebugCommandProcessor.prototype.referencesRequest_=
+function(aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var w=aN.arguments.type;
+var bc=aN.arguments.handle;
+if((w===(void 0))){
+return aU.failed('Argument "type" missing');
+}
+if((bc===(void 0))){
+return aU.failed('Argument "handle" missing');
+}
+if(w!='referencedBy'&&w!='constructedBy'){
+return aU.failed('Invalid type "'+w+'"');
+}
+var J=i(bc);
+if(J){
+if(w=='referencedBy'){
+aU.body=J.referencedBy();
+}else{
+aU.body=J.constructedBy();
+}
+}else{
+return aU.failed('Object #'+bc+'# not found');
+}
+};
+DebugCommandProcessor.prototype.sourceRequest_=function(aN,aU){
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No source');
+}
+var bN;
+var bO;
+var bs=this.exec_state_.frame();
+if(aN.arguments){
+bN=aN.arguments.fromLine;
+bO=aN.arguments.toLine;
+if(!(aN.arguments.frame===(void 0))){
+var bJ=(%_ToNumber(aN.arguments.frame));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+bs=this.exec_state_.frame(bJ);
+}
+}
+var R=bs.func().script();
+if(!R){
+return aU.failed('No source');
+}
+var bP=R.sourceSlice(bN,bO);
+if(!bP){
+return aU.failed('Invalid line interval');
+}
+aU.body={};
+aU.body.source=bP.sourceText();
+aU.body.fromLine=bP.from_line;
+aU.body.toLine=bP.to_line;
+aU.body.fromPosition=bP.from_position;
+aU.body.toPosition=bP.to_position;
+aU.body.totalLines=R.lineCount();
+};
+DebugCommandProcessor.prototype.scriptsRequest_=function(aN,aU){
+var bQ=ScriptTypeFlag(u.ScriptType.Normal);
+var bL=false;
+var bR=null;
+if(aN.arguments){
+if(!(aN.arguments.types===(void 0))){
+bQ=(%_ToNumber(aN.arguments.types));
+if(f(bQ)||bQ<0){
+return aU.failed('Invalid types "'+
+aN.arguments.types+'"');
+}
+}
+if(!(aN.arguments.includeSource===(void 0))){
+bL=(!!(aN.arguments.includeSource));
+aU.setOption('includeSource',bL);
+}
+if((%_IsArray(aN.arguments.ids))){
+bR={};
+var bS=aN.arguments.ids;
+for(var O=0;O<bS.length;O++){
+bR[bS[O]]=true;
+}
+}
+var bT=null;
+var bU=null;
+if(!(aN.arguments.filter===(void 0))){
+var bV=(%_ToNumber(aN.arguments.filter));
+if(!f(bV)){
+bU=bV;
+}
+bT=aN.arguments.filter;
+}
+}
+var ae=%DebugGetLoadedScripts();
+aU.body=[];
+for(var O=0;O<ae.length;O++){
+if(bR&&!bR[ae[O].id]){
+continue;
+}
+if(bT||bU){
+var R=ae[O];
+var bW=false;
+if(bU&&!bW){
+if(R.id&&R.id===bU){
+bW=true;
+}
+}
+if(bT&&!bW){
+if(R.name&&R.name.indexOf(bT)>=0){
+bW=true;
+}
+}
+if(!bW)continue;
+}
+if(bQ&ScriptTypeFlag(ae[O].type)){
+aU.body.push(l(ae[O]));
+}
+}
+};
+DebugCommandProcessor.prototype.threadsRequest_=function(aN,aU){
+var bX=this.exec_state_.threadCount();
+var bY=[];
+for(var O=0;O<bX;O++){
+var bZ=%GetThreadDetails(this.exec_state_.break_id,O);
+var ca={current:bZ[0],
+id:bZ[1]
+};
+bY.push(ca);
+}
+aU.body={
+totalThreads:bX,
+threads:bY
+};
+};
+DebugCommandProcessor.prototype.suspendRequest_=function(aN,aU){
+aU.running=false;
+};
+DebugCommandProcessor.prototype.versionRequest_=function(aN,aU){
+aU.body={
+V8Version:%GetV8Version()
+};
+};
+DebugCommandProcessor.prototype.changeLiveRequest_=function(
+aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var cb=aN.arguments.script_id;
+var cc=!!aN.arguments.preview_only;
+var ae=%DebugGetLoadedScripts();
+var cd=null;
+for(var O=0;O<ae.length;O++){
+if(ae[O].id==cb){
+cd=ae[O];
+}
+}
+if(!cd){
+aU.failed('Script not found');
+return;
+}
+var ce=new d();
+if(!(typeof(aN.arguments.new_source)==='string')){
+throw"new_source argument expected";
+}
+var cf=aN.arguments.new_source;
+var cg;
+try{
+cg=u.LiveEdit.SetScriptSource(cd,
+cf,cc,ce);
+}catch(e){
+if(e instanceof u.LiveEdit.Failure&&"details"in e){
+aU.failed(e.message,e.details);
+return;
+}
+throw e;
+}
+aU.body={change_log:ce,result:cg};
+if(!cc&&!this.running_&&cg.stack_modified){
+aU.body.stepin_recommended=true;
+}
+};
+DebugCommandProcessor.prototype.restartFrameRequest_=function(
+aN,aU){
+if(!aN.arguments){
+return aU.failed('Missing arguments');
+}
+var bs=aN.arguments.frame;
+if(this.exec_state_.frameCount()==0){
+return aU.failed('No frames');
+}
+var ch;
+if(!(bs===(void 0))){
+var bJ=(%_ToNumber(bs));
+if(bJ<0||bJ>=this.exec_state_.frameCount()){
+return aU.failed('Invalid frame "'+bs+'"');
+}
+ch=this.exec_state_.frame(bJ);
+}else{
+ch=this.exec_state_.frame();
+}
+var cg=u.LiveEdit.RestartFrame(ch);
+aU.body={result:cg};
+};
+DebugCommandProcessor.prototype.debuggerFlagsRequest_=function(aN,
+aU){
+if(!aN.arguments){
+aU.failed('Missing arguments');
+return;
+}
+var ci=aN.arguments.flags;
+aU.body={flags:[]};
+if(!(ci===(void 0))){
+for(var O=0;O<ci.length;O++){
+var aO=ci[O].name;
+var cj=B[aO];
+if(!cj){
+continue;
+}
+if('value'in ci[O]){
+cj.setValue(ci[O].value);
+}
+aU.body.flags.push({name:aO,value:cj.getValue()});
+}
+}else{
+for(var aO in B){
+var C=B[aO].getValue();
+aU.body.flags.push({name:aO,value:C});
+}
+}
+};
+DebugCommandProcessor.prototype.v8FlagsRequest_=function(aN,aU){
+var ci=aN.arguments.flags;
+if(!ci)ci='';
+%SetFlags(ci);
+};
+DebugCommandProcessor.prototype.gcRequest_=function(aN,aU){
+var w=aN.arguments.type;
+if(!w)w='all';
+var ck=%GetHeapUsage();
+%CollectGarbage(w);
+var cl=%GetHeapUsage();
+aU.body={"before":ck,"after":cl};
+};
+DebugCommandProcessor.prototype.dispatch_=(function(){
+var cm=DebugCommandProcessor.prototype;
+return{
+"continue":cm.continueRequest_,
+"break":cm.breakRequest_,
+"setbreakpoint":cm.setBreakPointRequest_,
+"changebreakpoint":cm.changeBreakPointRequest_,
+"clearbreakpoint":cm.clearBreakPointRequest_,
+"clearbreakpointgroup":cm.clearBreakPointGroupRequest_,
+"disconnect":cm.disconnectRequest_,
+"setexceptionbreak":cm.setExceptionBreakRequest_,
+"listbreakpoints":cm.listBreakpointsRequest_,
+"backtrace":cm.backtraceRequest_,
+"frame":cm.frameRequest_,
+"scopes":cm.scopesRequest_,
+"scope":cm.scopeRequest_,
+"setvariablevalue":cm.setVariableValueRequest_,
+"evaluate":cm.evaluateRequest_,
+"lookup":cm.lookupRequest_,
+"references":cm.referencesRequest_,
+"source":cm.sourceRequest_,
+"scripts":cm.scriptsRequest_,
+"threads":cm.threadsRequest_,
+"suspend":cm.suspendRequest_,
+"version":cm.versionRequest_,
+"changelive":cm.changeLiveRequest_,
+"restartframe":cm.restartFrameRequest_,
+"flags":cm.debuggerFlagsRequest_,
+"v8flag":cm.v8FlagsRequest_,
+"gc":cm.gcRequest_,
+};
+})();
+DebugCommandProcessor.prototype.isRunning=function(){
+return this.running_;
+};
+DebugCommandProcessor.prototype.systemBreak=function(cn,aV){
+return %SystemBreak();
+};
+function ObjectToProtocolObject_(co,cp){
+var cq={};
+for(var aW in co){
+if(typeof aW=='string'){
+var cr=ValueToProtocolValue_(co[aW],
+cp);
+if(!(cr===(void 0))){
+cq[aW]=cr;
+}
+}
+}
+return cq;
+}
+function ArrayToProtocolArray_(bh,cp){
+var aR=[];
+for(var O=0;O<bh.length;O++){
+aR.push(ValueToProtocolValue_(bh[O],cp));
+}
+return aR;
+}
+function ValueToProtocolValue_(C,cp){
+var aR;
+switch(typeof C){
+case'object':
+if(C instanceof o){
+aR=cp.serializeValue(C);
+}else if((%_IsArray(C))){
+aR=ArrayToProtocolArray_(C,cp);
+}else{
+aR=ObjectToProtocolObject_(C,cp);
+}
+break;
+case'boolean':
+case'string':
+case'number':
+aR=C;
+break;
+default:
+aR=null;
+}
+return aR;
+}
+b.InstallConstants(a,[
+"Debug",u,
+"DebugCommandProcessor",DebugCommandProcessor,
+"BreakEvent",BreakEvent,
+"CompileEvent",CompileEvent,
+"BreakPoint",BreakPoint,
+]);
+b.InstallFunctions(b,2,[
+"MakeExecutionState",MakeExecutionState,
+"MakeExceptionEvent",MakeExceptionEvent,
+"MakeBreakEvent",MakeBreakEvent,
+"MakeCompileEvent",MakeCompileEvent,
+"MakePromiseEvent",MakePromiseEvent,
+"MakeAsyncTaskEvent",MakeAsyncTaskEvent,
+"IsBreakPointTriggered",IsBreakPointTriggered,
+"UpdateScriptBreakPoints",UpdateScriptBreakPoints,
+]);
+b.Export(function(cs){
+cs.GetScriptBreakPoints=GetScriptBreakPoints;
+});
+})
+
+ liveedit%ú
+(function(a,b){
+"use strict";
+var c=a.Debug.findScriptSourcePosition;
+var d;
+var e=a.Array;
+var f=a.Math.floor;
+var g=a.SyntaxError;
+b.Import(function(h){
+d=h.GetScriptBreakPoints;
+});
+var i;
+function ApplyPatchMultiChunk(script,diff_array,new_source,preview_only,
+change_log){
+var j=script.source;
+var k=GatherCompileInfo(j,script);
+var l=BuildCodeInfoTree(k);
+var m=new PosTranslator(diff_array);
+MarkChangedFunctions(l,m.GetChunks());
+FindLiveSharedInfos(l,script);
+var n;
+try{
+n=GatherCompileInfo(new_source,script);
+}catch(e){
+var o=
+new Failure("Failed to compile new version of script: "+e);
+if(e instanceof g){
+var p={
+type:"liveedit_compile_error",
+syntaxErrorMessage:e.message
+};
+CopyErrorPositionToDetails(e,p);
+o.details=p;
+}
+throw o;
+}
+var q=BuildCodeInfoTree(n);
+FindCorrespondingFunctions(l,q);
+var r=new e();
+var s=new e();
+var t=new e();
+var u=new e();
+function HarvestTodo(v){
+function CollectDamaged(w){
+s.push(w);
+for(var x=0;x<w.children.length;x++){
+CollectDamaged(w.children[x]);
+}
+}
+function CollectNew(y){
+for(var x=0;x<y.length;x++){
+t.push(y[x]);
+CollectNew(y[x].children);
+}
+}
+if(v.status==i.DAMAGED){
+CollectDamaged(v);
+return;
+}
+if(v.status==i.UNCHANGED){
+u.push(v);
+}else if(v.status==i.SOURCE_CHANGED){
+u.push(v);
+}else if(v.status==i.CHANGED){
+r.push(v);
+CollectNew(v.unmatched_new_nodes);
+}
+for(var x=0;x<v.children.length;x++){
+HarvestTodo(v.children[x]);
+}
+}
+var z={
+change_tree:DescribeChangeTree(l),
+textual_diff:{
+old_len:j.length,
+new_len:new_source.length,
+chunks:diff_array
+},
+updated:false
+};
+if(preview_only){
+return z;
+}
+HarvestTodo(l);
+var A=new e();
+var B=new e();
+for(var x=0;x<r.length;x++){
+var C=r[x].live_shared_function_infos;
+var D=
+r[x].corresponding_node.info.shared_function_info;
+if(C){
+for(var E=0;E<C.length;E++){
+A.push(C[E]);
+B.push(D);
+}
+}
+}
+var F=
+CheckStackActivations(A,
+B,
+change_log);
+z.stack_modified=F!=0;
+var G=TemporaryRemoveBreakPoints(script,change_log);
+var H;
+if(s.length==0){
+%LiveEditReplaceScript(script,new_source,null);
+H=(void 0);
+}else{
+var I=CreateNameForOldScript(script);
+H=%LiveEditReplaceScript(script,new_source,
+I);
+var J=new e();
+change_log.push({linked_to_old_script:J});
+for(var x=0;x<s.length;x++){
+LinkToOldScript(s[x],H,
+J);
+}
+z.created_script_name=I;
+}
+for(var x=0;x<t.length;x++){
+%LiveEditFunctionSetScript(
+t[x].info.shared_function_info,script);
+}
+for(var x=0;x<r.length;x++){
+PatchFunctionCode(r[x],change_log);
+}
+var K=new e();
+change_log.push({position_patched:K});
+for(var x=0;x<u.length;x++){
+PatchPositions(u[x],diff_array,
+K);
+if(u[x].live_shared_function_infos){
+u[x].live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSourceUpdated(L.raw_array);
+});
+}
+}
+G(m,H);
+z.updated=true;
+return z;
+}
+function GatherCompileInfo(M,N){
+var O=%LiveEditGatherCompileInfo(N,M);
+var P=new e();
+var Q=new e();
+for(var x=0;x<O.length;x++){
+var L=new FunctionCompileInfo(O[x]);
+%LiveEditFunctionSetScript(L.shared_function_info,(void 0));
+P.push(L);
+Q.push(x);
+}
+for(var x=0;x<P.length;x++){
+var R=x;
+for(var E=x+1;E<P.length;E++){
+if(P[R].start_position>P[E].start_position){
+R=E;
+}
+}
+if(R!=x){
+var S=P[R];
+var T=Q[R];
+P[R]=P[x];
+Q[R]=Q[x];
+P[x]=S;
+Q[x]=T;
+}
+}
+var U=0;
+function ResetIndexes(V,W){
+var X=-1;
+while(U<P.length&&
+P[U].outer_index==W){
+var Y=U;
+P[Y].outer_index=V;
+if(X!=-1){
+P[X].next_sibling_index=Y;
+}
+X=Y;
+U++;
+ResetIndexes(Y,Q[Y]);
+}
+if(X!=-1){
+P[X].next_sibling_index=-1;
+}
+}
+ResetIndexes(-1,-1);
+Assert(U==P.length);
+return P;
+}
+function PatchFunctionCode(v,Z){
+var D=v.corresponding_node.info;
+if(v.live_shared_function_infos){
+v.live_shared_function_infos.forEach(function(aa){
+%LiveEditReplaceFunctionCode(D.raw_array,
+aa.raw_array);
+for(var x=0;x<v.children.length;x++){
+if(v.children[x].corresponding_node){
+var ab=
+v.children[x].corresponding_node.info.
+shared_function_info;
+if(v.children[x].live_shared_function_infos){
+v.children[x].live_shared_function_infos.
+forEach(function(ac){
+%LiveEditReplaceRefToNestedFunction(
+aa.info,
+ab,
+ac.info);
+});
+}
+}
+}
+});
+Z.push({function_patched:D.function_name});
+}else{
+Z.push({function_patched:D.function_name,
+function_info_not_found:true});
+}
+}
+function LinkToOldScript(ad,H,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.
+forEach(function(L){
+%LiveEditFunctionSetScript(L.info,H);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,not_found:true});
+}
+}
+function TemporaryRemoveBreakPoints(af,Z){
+var ag=d(af);
+var ah=[];
+Z.push({break_points_update:ah});
+var ai=[];
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+aj.clear();
+var ak=c(af,
+aj.line(),aj.column());
+var al={
+position:ak,
+line:aj.line(),
+column:aj.column()
+};
+ai.push(al);
+}
+return function(m,am){
+for(var x=0;x<ag.length;x++){
+var aj=ag[x];
+if(am){
+var an=aj.cloneForOtherScript(am);
+an.set(am);
+ah.push({
+type:"copied_to_old",
+id:aj.number(),
+new_id:an.number(),
+positions:ai[x]
+});
+}
+var ao=m.Translate(
+ai[x].position,
+PosTranslator.ShiftWithTopInsideChunkHandler);
+var ap=
+af.locationFromPosition(ao,false);
+aj.update_positions(ap.line,ap.column);
+var aq={
+position:ao,
+line:ap.line,
+column:ap.column
+};
+aj.set(af);
+ah.push({type:"position_changed",
+id:aj.number(),
+old_positions:ai[x],
+new_positions:aq
+});
+}
+};
+}
+function Assert(ar,as){
+if(!ar){
+if(as){
+throw"Assert "+as;
+}else{
+throw"Assert";
+}
+}
+}
+function DiffChunk(at,au,av,aw){
+this.pos1=at;
+this.pos2=au;
+this.len1=av;
+this.len2=aw;
+}
+function PosTranslator(ax){
+var ay=new e();
+var az=0;
+for(var x=0;x<ax.length;x+=3){
+var aA=ax[x];
+var aB=aA+az;
+var aC=ax[x+1];
+var aD=ax[x+2];
+ay.push(new DiffChunk(aA,aB,aC-aA,
+aD-aB));
+az=aD-aC;
+}
+this.chunks=ay;
+}
+PosTranslator.prototype.GetChunks=function(){
+return this.chunks;
+};
+PosTranslator.prototype.Translate=function(aE,aF){
+var aG=this.chunks;
+if(aG.length==0||aE<aG[0].pos1){
+return aE;
+}
+var aH=0;
+var aI=aG.length-1;
+while(aH<aI){
+var aJ=f((aH+aI)/2);
+if(aE<aG[aJ+1].pos1){
+aI=aJ;
+}else{
+aH=aJ+1;
+}
+}
+var aK=aG[aH];
+if(aE>=aK.pos1+aK.len1){
+return aE+aK.pos2+aK.len2-aK.pos1-aK.len1;
+}
+if(!aF){
+aF=PosTranslator.DefaultInsideChunkHandler;
+}
+return aF(aE,aK);
+};
+PosTranslator.DefaultInsideChunkHandler=function(aE,aL){
+Assert(false,"Cannot translate position in changed area");
+};
+PosTranslator.ShiftWithTopInsideChunkHandler=
+function(aE,aL){
+return aE-aL.pos1+aL.pos2;
+};
+var i={
+UNCHANGED:"unchanged",
+SOURCE_CHANGED:"source changed",
+CHANGED:"changed",
+DAMAGED:"damaged"
+};
+function CodeInfoTreeNode(aM,aN,aO){
+this.info=aM;
+this.children=aN;
+this.array_index=aO;
+this.parent=(void 0);
+this.status=i.UNCHANGED;
+this.status_explanation=(void 0);
+this.new_start_pos=(void 0);
+this.new_end_pos=(void 0);
+this.corresponding_node=(void 0);
+this.unmatched_new_nodes=(void 0);
+this.textual_corresponding_node=(void 0);
+this.textually_unmatched_new_nodes=(void 0);
+this.live_shared_function_infos=(void 0);
+}
+function BuildCodeInfoTree(aP){
+var aQ=0;
+function BuildNode(){
+var aR=aQ;
+aQ++;
+var aS=new e();
+while(aQ<aP.length&&
+aP[aQ].outer_index==aR){
+aS.push(BuildNode());
+}
+var w=new CodeInfoTreeNode(aP[aR],aS,
+aR);
+for(var x=0;x<aS.length;x++){
+aS[x].parent=w;
+}
+return w;
+}
+var aT=BuildNode();
+Assert(aQ==aP.length);
+return aT;
+}
+function MarkChangedFunctions(aU,ay){
+var aV=new function(){
+var aW=0;
+var aX=0;
+this.current=function(){return ay[aW];};
+this.next=function(){
+var aK=ay[aW];
+aX=aK.pos2+aK.len2-(aK.pos1+aK.len1);
+aW++;
+};
+this.done=function(){return aW>=ay.length;};
+this.TranslatePos=function(aE){return aE+aX;};
+};
+function ProcessInternals(aY){
+aY.new_start_pos=aV.TranslatePos(
+aY.info.start_position);
+var aZ=0;
+var ba=false;
+var bb=false;
+while(!aV.done()&&
+aV.current().pos1<aY.info.end_position){
+if(aZ<aY.children.length){
+var bc=aY.children[aZ];
+if(bc.info.end_position<=aV.current().pos1){
+ProcessUnchangedChild(bc);
+aZ++;
+continue;
+}else if(bc.info.start_position>=
+aV.current().pos1+aV.current().len1){
+ba=true;
+aV.next();
+continue;
+}else if(bc.info.start_position<=aV.current().pos1&&
+bc.info.end_position>=aV.current().pos1+
+aV.current().len1){
+ProcessInternals(bc);
+bb=bb||
+(bc.status!=i.UNCHANGED);
+ba=ba||
+(bc.status==i.DAMAGED);
+aZ++;
+continue;
+}else{
+ba=true;
+bc.status=i.DAMAGED;
+bc.status_explanation=
+"Text diff overlaps with function boundary";
+aZ++;
+continue;
+}
+}else{
+if(aV.current().pos1+aV.current().len1<=
+aY.info.end_position){
+aY.status=i.CHANGED;
+aV.next();
+continue;
+}else{
+aY.status=i.DAMAGED;
+aY.status_explanation=
+"Text diff overlaps with function boundary";
+return;
+}
+}
+Assert("Unreachable",false);
+}
+while(aZ<aY.children.length){
+var bc=aY.children[aZ];
+ProcessUnchangedChild(bc);
+aZ++;
+}
+if(ba){
+aY.status=i.CHANGED;
+}else if(bb){
+aY.status=i.SOURCE_CHANGED;
+}
+aY.new_end_pos=
+aV.TranslatePos(aY.info.end_position);
+}
+function ProcessUnchangedChild(w){
+w.new_start_pos=aV.TranslatePos(w.info.start_position);
+w.new_end_pos=aV.TranslatePos(w.info.end_position);
+}
+ProcessInternals(aU);
+}
+function FindCorrespondingFunctions(bd,be){
+function ProcessNode(v,bf){
+var bg=
+IsFunctionContextLocalsChanged(v.info,bf.info);
+if(bg){
+v.status=i.CHANGED;
+}
+var bh=v.children;
+var bi=bf.children;
+var bj=[];
+var bk=[];
+var bl=0;
+var bm=0;
+while(bl<bh.length){
+if(bh[bl].status==i.DAMAGED){
+bl++;
+}else if(bm<bi.length){
+if(bi[bm].info.start_position<
+bh[bl].new_start_pos){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}else if(bi[bm].info.start_position==
+bh[bl].new_start_pos){
+if(bi[bm].info.end_position==
+bh[bl].new_end_pos){
+bh[bl].corresponding_node=
+bi[bm];
+bh[bl].textual_corresponding_node=
+bi[bm];
+if(bg){
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"Enclosing function is now incompatible. "+
+bg;
+bh[bl].corresponding_node=(void 0);
+}else if(bh[bl].status!=
+i.UNCHANGED){
+ProcessNode(bh[bl],
+bi[bm]);
+if(bh[bl].status==i.DAMAGED){
+bj.push(
+bh[bl].corresponding_node);
+bh[bl].corresponding_node=(void 0);
+v.status=i.CHANGED;
+}
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+}
+bm++;
+bl++;
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}else{
+bh[bl].status=i.DAMAGED;
+bh[bl].status_explanation=
+"No corresponding function in new script found";
+v.status=i.CHANGED;
+bl++;
+}
+}
+while(bm<bi.length){
+bj.push(bi[bm]);
+bk.push(bi[bm]);
+bm++;
+}
+if(v.status==i.CHANGED){
+if(v.info.param_num!=bf.info.param_num){
+v.status=i.DAMAGED;
+v.status_explanation="Changed parameter number: "+
+v.info.param_num+" and "+bf.info.param_num;
+}
+}
+v.unmatched_new_nodes=bj;
+v.textually_unmatched_new_nodes=
+bk;
+}
+ProcessNode(bd,be);
+bd.corresponding_node=be;
+bd.textual_corresponding_node=be;
+Assert(bd.status!=i.DAMAGED,
+"Script became damaged");
+}
+function FindLiveSharedInfos(bd,N){
+var bn=%LiveEditFindSharedFunctionInfosForScript(N);
+var bo=new e();
+for(var x=0;x<bn.length;x++){
+bo.push(new SharedInfoWrapper(bn[x]));
+}
+function FindFunctionInfos(P){
+var bp=[];
+for(var x=0;x<bo.length;x++){
+var bq=bo[x];
+if(bq.start_position==P.start_position&&
+bq.end_position==P.end_position){
+bp.push(bq);
+}
+}
+if(bp.length>0){
+return bp;
+}
+}
+function TraverseTree(w){
+w.live_shared_function_infos=FindFunctionInfos(w.info);
+for(var x=0;x<w.children.length;x++){
+TraverseTree(w.children[x]);
+}
+}
+TraverseTree(bd);
+}
+function FunctionCompileInfo(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.param_num=br[3];
+this.code=br[4];
+this.code_scope_info=br[5];
+this.scope_info=br[6];
+this.outer_index=br[7];
+this.shared_function_info=br[8];
+this.next_sibling_index=null;
+this.raw_array=br;
+}
+function SharedInfoWrapper(br){
+this.function_name=br[0];
+this.start_position=br[1];
+this.end_position=br[2];
+this.info=br[3];
+this.raw_array=br;
+}
+function PatchPositions(ad,ax,ae){
+if(ad.live_shared_function_infos){
+ad.live_shared_function_infos.forEach(function(L){
+%LiveEditPatchFunctionPositions(L.raw_array,
+ax);
+});
+ae.push({name:ad.info.function_name});
+}else{
+ae.push(
+{name:ad.info.function_name,info_not_found:true});
+}
+}
+function CreateNameForOldScript(N){
+return N.name+" (old)";
+}
+function IsFunctionContextLocalsChanged(bs,bt){
+var bu=bs.scope_info;
+var bv=bt.scope_info;
+var bw;
+var bx;
+if(bu){
+bw=bu.toString();
+}else{
+bw="";
+}
+if(bv){
+bx=bv.toString();
+}else{
+bx="";
+}
+if(bw!=bx){
+return"Variable map changed: ["+bw+
+"] => ["+bx+"]";
+}
+return;
+}
+var by;
+function CheckStackActivations(old_shared_wrapper_list,
+new_shared_list,
+Z){
+var bz=new e();
+for(var x=0;x<old_shared_wrapper_list.length;x++){
+bz[x]=old_shared_wrapper_list[x].info;
+}
+var bA=%LiveEditCheckAndDropActivations(
+bz,new_shared_list,true);
+if(bA[old_shared_wrapper_list.length]){
+throw new Failure(bA[old_shared_wrapper_list.length]);
+}
+var bB=new e();
+var bC=new e();
+for(var x=0;x<bz.length;x++){
+var bD=old_shared_wrapper_list[x];
+if(bA[x]==by.REPLACED_ON_ACTIVE_STACK){
+bC.push({name:bD.function_name});
+}else if(bA[x]!=by.AVAILABLE_FOR_PATCH){
+var bE={
+name:bD.function_name,
+start_pos:bD.start_position,
+end_pos:bD.end_position,
+replace_problem:
+by.SymbolName(bA[x])
+};
+bB.push(bE);
+}
+}
+if(bC.length>0){
+Z.push({dropped_from_stack:bC});
+}
+if(bB.length>0){
+Z.push({functions_on_stack:bB});
+throw new Failure("Blocked by functions on stack");
+}
+return bC.length;
+}
+var by={
+AVAILABLE_FOR_PATCH:1,
+BLOCKED_ON_ACTIVE_STACK:2,
+BLOCKED_ON_OTHER_STACK:3,
+BLOCKED_UNDER_NATIVE_CODE:4,
+REPLACED_ON_ACTIVE_STACK:5,
+BLOCKED_UNDER_GENERATOR:6,
+BLOCKED_ACTIVE_GENERATOR:7,
+BLOCKED_NO_NEW_TARGET_ON_RESTART:8
+};
+by.SymbolName=function(bF){
+var bG=by;
+for(var bH in bG){
+if(bG[bH]==bF){
+return bH;
+}
+}
+};
+function Failure(as){
+this.message=as;
+}
+Failure.prototype.toString=function(){
+return"LiveEdit Failure: "+this.message;
+};
+function CopyErrorPositionToDetails(bI,p){
+function createPositionStruct(N,bJ){
+if(bJ==-1)return;
+var bK=N.locationFromPosition(bJ,true);
+if(bK==null)return;
+return{
+line:bK.line+1,
+column:bK.column+1,
+position:bJ
+};
+}
+if(!("scriptObject"in bI)||!("startPosition"in bI)){
+return;
+}
+var N=bI.scriptObject;
+var bL={
+start:createPositionStruct(N,bI.startPosition),
+end:createPositionStruct(N,bI.endPosition)
+};
+p.position=bL;
+}
+function GetPcFromSourcePos(bM,bN){
+return %GetFunctionCodePositionFromSource(bM,bN);
+}
+function SetScriptSource(N,bO,bP,Z){
+var j=N.source;
+var bQ=CompareStrings(j,bO);
+return ApplyPatchMultiChunk(N,bQ,bO,bP,
+Z);
+}
+function CompareStrings(bR,bS){
+return %LiveEditCompareStrings(bR,bS);
+}
+function ApplySingleChunkPatch(N,change_pos,change_len,new_str,
+Z){
+var j=N.source;
+var bO=j.substring(0,change_pos)+
+new_str+j.substring(change_pos+change_len);
+return ApplyPatchMultiChunk(N,
+[change_pos,change_pos+change_len,change_pos+new_str.length],
+bO,false,Z);
+}
+function DescribeChangeTree(bd){
+function ProcessOldNode(w){
+var bT=[];
+for(var x=0;x<w.children.length;x++){
+var bc=w.children[x];
+if(bc.status!=i.UNCHANGED){
+bT.push(ProcessOldNode(bc));
+}
+}
+var bU=[];
+if(w.textually_unmatched_new_nodes){
+for(var x=0;x<w.textually_unmatched_new_nodes.length;x++){
+var bc=w.textually_unmatched_new_nodes[x];
+bU.push(ProcessNewNode(bc));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+status:w.status,
+children:bT,
+new_children:bU
+};
+if(w.status_explanation){
+bV.status_explanation=w.status_explanation;
+}
+if(w.textual_corresponding_node){
+bV.new_positions=DescribePositions(w.textual_corresponding_node);
+}
+return bV;
+}
+function ProcessNewNode(w){
+var bT=[];
+if(false){
+for(var x=0;x<w.children.length;x++){
+bT.push(ProcessNewNode(w.children[x]));
+}
+}
+var bV={
+name:w.info.function_name,
+positions:DescribePositions(w),
+children:bT,
+};
+return bV;
+}
+function DescribePositions(w){
+return{
+start_position:w.info.start_position,
+end_position:w.info.end_position
+};
+}
+return ProcessOldNode(bd);
+}
+var bW={};
+bW.SetScriptSource=SetScriptSource;
+bW.ApplyPatchMultiChunk=ApplyPatchMultiChunk;
+bW.Failure=Failure;
+bW.GetPcFromSourcePos=GetPcFromSourcePos;
+bW.TestApi={
+PosTranslator:PosTranslator,
+CompareStrings:CompareStrings,
+ApplySingleChunkPatch:ApplySingleChunkPatch
+};
+a.Debug.LiveEdit=bW;
+})
+
+h prologueK
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=(void 0);
+var e=(void 0);
+var f=%ExportFromRuntime({});
+var g=(void 0);
+function SetupTypedArray(h){
+h.next=g;
+g=h;
+}
+function Export(h){
+h(f);
+}
+function Import(h){
+h.next=d;
+d=h;
+}
+function ImportNow(i){
+return f[i];
+}
+function ImportFromExperimental(h){
+h.next=e;
+e=h;
+}
+function SetFunctionName(h,i,j){
+if((typeof(i)==='symbol')){
+i="["+%SymbolDescription(i)+"]";
+}
+if((j===(void 0))){
+%FunctionSetName(h,i);
+}else{
+%FunctionSetName(h,j+" "+i);
+}
+}
+function InstallConstants(k,l){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,l.length>>1);
+var m=2|4|1;
+for(var n=0;n<l.length;n+=2){
+var i=l[n];
+var o=l[n+1];
+%AddNamedProperty(k,i,o,m);
+}
+%ToFastProperties(k);
+}
+function InstallFunctions(k,m,p){
+%CheckIsBootstrapping();
+%OptimizeObjectForAddingMultipleProperties(k,p.length>>1);
+for(var n=0;n<p.length;n+=2){
+var q=p[n];
+var h=p[n+1];
+SetFunctionName(h,q);
+%FunctionRemovePrototype(h);
+%AddNamedProperty(k,q,h,m);
+%SetNativeFlag(h);
+}
+%ToFastProperties(k);
+}
+function InstallGetter(k,i,r,m,j){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,(j===(void 0))?"get":j);
+%FunctionRemovePrototype(r);
+%DefineGetterPropertyUnchecked(k,i,r,m);
+%SetNativeFlag(r);
+}
+function InstallGetterSetter(k,i,r,s,m){
+%CheckIsBootstrapping();
+if((m===(void 0)))m=2;
+SetFunctionName(r,i,"get");
+SetFunctionName(s,i,"set");
+%FunctionRemovePrototype(r);
+%FunctionRemovePrototype(s);
+%DefineAccessorPropertyUnchecked(k,i,r,s,2);
+%SetNativeFlag(r);
+%SetNativeFlag(s);
+}
+function SetUpLockedPrototype(
+constructor,fields,methods){
+%CheckIsBootstrapping();
+var t=constructor.prototype;
+var u=(methods.length>>1)+(fields?fields.length:0);
+if(u>=4){
+%OptimizeObjectForAddingMultipleProperties(t,u);
+}
+if(fields){
+for(var n=0;n<fields.length;n++){
+%AddNamedProperty(t,fields[n],
+(void 0),2|4);
+}
+}
+for(var n=0;n<methods.length;n+=2){
+var q=methods[n];
+var h=methods[n+1];
+%AddNamedProperty(t,q,h,2|4|1);
+%SetNativeFlag(h);
+}
+%InternalSetPrototype(t,null);
+%ToFastProperties(t);
+}
+function PostNatives(b){
+%CheckIsBootstrapping();
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+var v=[
+"ArrayToString",
+"ErrorToString",
+"GetIterator",
+"GetMethod",
+"IsNaN",
+"MakeError",
+"MakeTypeError",
+"MapEntries",
+"MapIterator",
+"MapIteratorNext",
+"MathMax",
+"MathMin",
+"MaxSimple",
+"MinSimple",
+"ObjectDefineProperty",
+"ObserveArrayMethods",
+"ObserveObjectMethods",
+"PromiseChain",
+"PromiseDeferred",
+"PromiseResolved",
+"SameValueZero",
+"SetIterator",
+"SetIteratorNext",
+"SetValues",
+"SymbolToString",
+"ToPositiveInteger",
+"is_concat_spreadable_symbol",
+"iterator_symbol",
+"promise_status_symbol",
+"promise_value_symbol",
+"object_freeze",
+"object_is_frozen",
+"object_is_sealed",
+"reflect_apply",
+"reflect_construct",
+"regexp_flags_symbol",
+"to_string_tag_symbol",
+"object_to_string",
+"species_symbol",
+];
+var w={};
+%OptimizeObjectForAddingMultipleProperties(
+w,v.length);
+for(var q of v){
+w[q]=f[q];
+}
+%ToFastProperties(w);
+f=w;
+b.PostNatives=(void 0);
+b.ImportFromExperimental=(void 0);
+}
+function PostExperimentals(b){
+%CheckIsBootstrapping();
+%ExportExperimentalFromRuntime(f);
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+for(;!(e===(void 0));
+e=e.next){
+e(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+b.Export=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function PostDebug(b){
+for(;!(d===(void 0));d=d.next){
+d(f);
+}
+b.CreateDoubleResultArray();
+b.CreateDoubleResultArray=(void 0);
+f=(void 0);
+b.Export=(void 0);
+b.Import=(void 0);
+b.ImportNow=(void 0);
+b.PostDebug=(void 0);
+b.PostExperimentals=(void 0);
+g=(void 0);
+}
+function InitializeBuiltinTypedArrays(b,x,y){
+var z=g;
+for(;!(z===(void 0));z=z.next){
+z(x,y);
+}
+}
+%OptimizeObjectForAddingMultipleProperties(b,14);
+b.Import=Import;
+b.ImportNow=ImportNow;
+b.Export=Export;
+b.ImportFromExperimental=ImportFromExperimental;
+b.SetFunctionName=SetFunctionName;
+b.InstallConstants=InstallConstants;
+b.InstallFunctions=InstallFunctions;
+b.InstallGetter=InstallGetter;
+b.InstallGetterSetter=InstallGetterSetter;
+b.SetUpLockedPrototype=SetUpLockedPrototype;
+b.PostNatives=PostNatives;
+b.PostExperimentals=PostExperimentals;
+b.PostDebug=PostDebug;
+%ToFastProperties(b);
+%OptimizeObjectForAddingMultipleProperties(c,5);
+c.logStackTrace=function logStackTrace(){
+%DebugTrace();
+};
+c.log=function log(){
+let message='';
+for(const arg of arguments){
+message+=arg;
+}
+%GlobalPrint(message);
+};
+c.createPrivateSymbol=function createPrivateSymbol(i){
+return %CreatePrivateSymbol(i);
+};
+c.simpleBind=function simpleBind(A,B){
+return function(){
+return %Apply(A,B,arguments,0,arguments.length);
+};
+};
+c.uncurryThis=function uncurryThis(A){
+return function(B){
+return %Apply(A,B,arguments,1,arguments.length-1);
+};
+};
+%ToFastProperties(c);
+})
+
+runtime9"
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Boolean;
+var f=a.String;
+var g;
+var h;
+var i;
+b.Import(function(j){
+g=j.MakeRangeError;
+h=j.MakeTypeError;
+i=j.species_symbol;
+});
+b.ImportFromExperimental(function(j){
+c=j.FLAG_harmony_species;
+});
+function CONCAT_ITERABLE_TO_ARRAY(k){
+return %concat_iterable_to_array(this,k);
+};
+function SameValue(l,m){
+if(typeof l!=typeof m)return false;
+if((typeof(l)==='number')){
+if((!%_IsSmi(%IS_VAR(l))&&!(l==l))&&(!%_IsSmi(%IS_VAR(m))&&!(m==m)))return true;
+if(l===0&&m===0&&%_IsMinusZero(l)!=%_IsMinusZero(m)){
+return false;
+}
+}
+if((%_IsSimdValue(l)))return %SimdSameValue(l,m);
+return l===m;
+}
+function SameValueZero(l,m){
+if(typeof l!=typeof m)return false;
+if((typeof(l)==='number')){
+if((!%_IsSmi(%IS_VAR(l))&&!(l==l))&&(!%_IsSmi(%IS_VAR(m))&&!(m==m)))return true;
+}
+if((%_IsSimdValue(l)))return %SimdSameValueZero(l,m);
+return l===m;
+}
+function ConcatIterableToArray(n,k){
+var o=n.length;
+for(var p of k){
+AddIndexedProperty(n,o++,p);
+}
+return n;
+}
+function AddIndexedProperty(q,o,r){
+if(o===((o)>>>0)&&o!==4294967295){
+%AddElement(q,o,r);
+}else{
+%AddNamedProperty(q,(%_ToString(o)),r,0);
+}
+}
+%SetForceInlineFlag(AddIndexedProperty);
+function ToPositiveInteger(l,s){
+var t=(%_IsSmi(%IS_VAR(l))?l:%NumberToIntegerMapMinusZero(l));
+if(t<0)throw g(s);
+return t;
+}
+function MaxSimple(u,v){
+return u>v?u:v;
+}
+function MinSimple(u,v){
+return u>v?v:u;
+}
+%SetForceInlineFlag(MaxSimple);
+%SetForceInlineFlag(MinSimple);
+function SpeciesConstructor(w,x,y){
+if(c){
+var z=w.constructor;
+if((z===(void 0))){
+return x;
+}
+if(!(%_IsJSReceiver(z))){
+throw h(27);
+}
+var A=z[i];
+if((A==null)){
+return x;
+}
+if(%IsConstructor(A)){
+return A;
+}
+throw h(235);
+}else{
+return y?x:w.constructor;
+}
+}
+%FunctionSetPrototype(d,new d(0));
+b.Export(function(B){
+B.AddIndexedProperty=AddIndexedProperty;
+B.MaxSimple=MaxSimple;
+B.MinSimple=MinSimple;
+B.SameValue=SameValue;
+B.SameValueZero=SameValueZero;
+B.ToPositiveInteger=ToPositiveInteger;
+B.SpeciesConstructor=SpeciesConstructor;
+});
+%InstallToContext([
+"concat_iterable_to_array_builtin",CONCAT_ITERABLE_TO_ARRAY,
+]);
+%InstallToContext([
+"concat_iterable_to_array",ConcatIterableToArray,
+]);
+})
+
+$v8nativesÚ#

+(function(a,b){
+%CheckIsBootstrapping();
+var c=a.Array;
+var d=a.Boolean;
+var e=a.Number;
+var f=a.Object;
+var g=b.InternalArray;
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j;
+var k;
+var l;
+var m=%GetRootNaN();
+var n=b.ImportNow("object_to_string");
+var o;
+var p;
+var q;
+var r=b.ImportNow("SameValue");
+var s=b.ImportNow("to_string_tag_symbol");
+b.Import(function(t){
+i=t.MakeRangeError;
+j=t.MakeSyntaxError;
+k=t.MakeTypeError;
+l=t.MathAbs;
+o=t.ObserveBeginPerformSplice;
+p=t.ObserveEndPerformSplice;
+q=t.ObserveEnqueueSpliceRecord;
+});
+function GlobalIsNaN(u){
+u=(%_ToNumber(u));
+return(!%_IsSmi(%IS_VAR(u))&&!(u==u));
+}
+function GlobalIsFinite(u){
+u=(%_ToNumber(u));
+return(%_IsSmi(%IS_VAR(u))||((u==u)&&(u!=1/0)&&(u!=-1/0)));
+}
+function GlobalParseInt(v,w){
+if((w===(void 0))||w===10||w===0){
+if(%_IsSmi(v))return v;
+if((typeof(v)==='number')&&
+((0.01<v&&v<1e9)||
+(-1e9<v&&v<-0.01))){
+return v|0;
+}
+v=(%_ToString(v));
+w=w|0;
+}else{
+v=(%_ToString(v));
+w=((w)|0);
+if(!(w==0||(2<=w&&w<=36))){
+return m;
+}
+}
+if(%_HasCachedArrayIndex(v)&&
+(w==0||w==10)){
+return %_GetCachedArrayIndex(v);
+}
+return %StringParseInt(v,w);
+}
+function GlobalParseFloat(v){
+v=(%_ToString(v));
+if(%_HasCachedArrayIndex(v))return %_GetCachedArrayIndex(v);
+return %StringParseFloat(v);
+}
+var x=2|4|1;
+b.InstallConstants(a,[
+"Infinity",(1/0),
+"NaN",m,
+"undefined",(void 0),
+]);
+b.InstallFunctions(a,2,[
+"isNaN",GlobalIsNaN,
+"isFinite",GlobalIsFinite,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat,
+]);
+function ObjectToLocaleString(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(17,"Object.prototype.toLocaleString");
+return this.toString();
+}
+function ObjectValueOf(){
+return(%_ToObject(this));
+}
+function ObjectHasOwnProperty(y){
+var z=(%_ToName(y));
+var A=(%_ToObject(this));
+return %HasOwnProperty(A,z);
+}
+function ObjectIsPrototypeOf(B){
+if(!(%_IsJSReceiver(B)))return false;
+var C=(%_ToObject(this));
+return %HasInPrototypeChain(B,C);
+}
+function ObjectPropertyIsEnumerable(B){
+var D=(%_ToName(B));
+return %PropertyIsEnumerable((%_ToObject(this)),D);
+}
+function ObjectDefineGetter(z,E){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectDefineGetter);
+}
+if(!(typeof(E)==='function')){
+throw k(72);
+}
+var G=new PropertyDescriptor();
+G.setGet(E);
+G.setEnumerable(true);
+G.setConfigurable(true);
+DefineOwnProperty((%_ToObject(F)),(%_ToName(z)),G,false);
+}
+function ObjectLookupGetter(z){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectLookupGetter);
+}
+return %LookupAccessor((%_ToObject(F)),(%_ToName(z)),0);
+}
+function ObjectDefineSetter(z,E){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectDefineSetter);
+}
+if(!(typeof(E)==='function')){
+throw k(75);
+}
+var G=new PropertyDescriptor();
+G.setSet(E);
+G.setEnumerable(true);
+G.setConfigurable(true);
+DefineOwnProperty((%_ToObject(F)),(%_ToName(z)),G,false);
+}
+function ObjectLookupSetter(z){
+var F=this;
+if((F===null)||(F===(void 0))){
+F=%GlobalProxy(ObjectLookupSetter);
+}
+return %LookupAccessor((%_ToObject(F)),(%_ToName(z)),1);
+}
+function IsAccessorDescriptor(G){
+if((G===(void 0)))return false;
+return G.hasGetter()||G.hasSetter();
+}
+function IsDataDescriptor(G){
+if((G===(void 0)))return false;
+return G.hasValue()||G.hasWritable();
+}
+function IsGenericDescriptor(G){
+if((G===(void 0)))return false;
+return!(IsAccessorDescriptor(G)||IsDataDescriptor(G));
+}
+function IsInconsistentDescriptor(G){
+return IsAccessorDescriptor(G)&&IsDataDescriptor(G);
+}
+function FromGenericPropertyDescriptor(G){
+if((G===(void 0)))return G;
+var H=new f();
+if(G.hasValue()){
+%AddNamedProperty(H,"value",G.getValue(),0);
+}
+if(G.hasWritable()){
+%AddNamedProperty(H,"writable",G.isWritable(),0);
+}
+if(G.hasGetter()){
+%AddNamedProperty(H,"get",G.getGet(),0);
+}
+if(G.hasSetter()){
+%AddNamedProperty(H,"set",G.getSet(),0);
+}
+if(G.hasEnumerable()){
+%AddNamedProperty(H,"enumerable",G.isEnumerable(),0);
+}
+if(G.hasConfigurable()){
+%AddNamedProperty(H,"configurable",G.isConfigurable(),0);
+}
+return H;
+}
+function ToPropertyDescriptor(H){
+if(!(%_IsJSReceiver(H)))throw k(90,H);
+var G=new PropertyDescriptor();
+if("enumerable"in H){
+G.setEnumerable((!!(H.enumerable)));
+}
+if("configurable"in H){
+G.setConfigurable((!!(H.configurable)));
+}
+if("value"in H){
+G.setValue(H.value);
+}
+if("writable"in H){
+G.setWritable((!!(H.writable)));
+}
+if("get"in H){
+var I=H.get;
+if(!(I===(void 0))&&!(typeof(I)==='function')){
+throw k(73,I);
+}
+G.setGet(I);
+}
+if("set"in H){
+var J=H.set;
+if(!(J===(void 0))&&!(typeof(J)==='function')){
+throw k(76,J);
+}
+G.setSet(J);
+}
+if(IsInconsistentDescriptor(G)){
+throw k(153,H);
+}
+return G;
+}
+function ToCompletePropertyDescriptor(H){
+var G=ToPropertyDescriptor(H);
+if(IsGenericDescriptor(G)||IsDataDescriptor(G)){
+if(!G.hasValue())G.setValue((void 0));
+if(!G.hasWritable())G.setWritable(false);
+}else{
+if(!G.hasGetter())G.setGet((void 0));
+if(!G.hasSetter())G.setSet((void 0));
+}
+if(!G.hasEnumerable())G.setEnumerable(false);
+if(!G.hasConfigurable())G.setConfigurable(false);
+return G;
+}
+function PropertyDescriptor(){
+this.value_=(void 0);
+this.hasValue_=false;
+this.writable_=false;
+this.hasWritable_=false;
+this.enumerable_=false;
+this.hasEnumerable_=false;
+this.configurable_=false;
+this.hasConfigurable_=false;
+this.get_=(void 0);
+this.hasGetter_=false;
+this.set_=(void 0);
+this.hasSetter_=false;
+}
+b.SetUpLockedPrototype(PropertyDescriptor,[
+"value_",
+"hasValue_",
+"writable_",
+"hasWritable_",
+"enumerable_",
+"hasEnumerable_",
+"configurable_",
+"hasConfigurable_",
+"get_",
+"hasGetter_",
+"set_",
+"hasSetter_"
+],[
+"toString",function PropertyDescriptor_ToString(){
+return"[object PropertyDescriptor]";
+},
+"setValue",function PropertyDescriptor_SetValue(y){
+this.value_=y;
+this.hasValue_=true;
+},
+"getValue",function PropertyDescriptor_GetValue(){
+return this.value_;
+},
+"hasValue",function PropertyDescriptor_HasValue(){
+return this.hasValue_;
+},
+"setEnumerable",function PropertyDescriptor_SetEnumerable(K){
+this.enumerable_=K;
+this.hasEnumerable_=true;
+},
+"isEnumerable",function PropertyDescriptor_IsEnumerable(){
+return this.enumerable_;
+},
+"hasEnumerable",function PropertyDescriptor_HasEnumerable(){
+return this.hasEnumerable_;
+},
+"setWritable",function PropertyDescriptor_SetWritable(L){
+this.writable_=L;
+this.hasWritable_=true;
+},
+"isWritable",function PropertyDescriptor_IsWritable(){
+return this.writable_;
+},
+"hasWritable",function PropertyDescriptor_HasWritable(){
+return this.hasWritable_;
+},
+"setConfigurable",
+function PropertyDescriptor_SetConfigurable(M){
+this.configurable_=M;
+this.hasConfigurable_=true;
+},
+"hasConfigurable",function PropertyDescriptor_HasConfigurable(){
+return this.hasConfigurable_;
+},
+"isConfigurable",function PropertyDescriptor_IsConfigurable(){
+return this.configurable_;
+},
+"setGet",function PropertyDescriptor_SetGetter(I){
+this.get_=I;
+this.hasGetter_=true;
+},
+"getGet",function PropertyDescriptor_GetGetter(){
+return this.get_;
+},
+"hasGetter",function PropertyDescriptor_HasGetter(){
+return this.hasGetter_;
+},
+"setSet",function PropertyDescriptor_SetSetter(J){
+this.set_=J;
+this.hasSetter_=true;
+},
+"getSet",function PropertyDescriptor_GetSetter(){
+return this.set_;
+},
+"hasSetter",function PropertyDescriptor_HasSetter(){
+return this.hasSetter_;
+}
+]);
+function ConvertDescriptorArrayToDescriptor(N){
+if((N===(void 0))){
+return(void 0);
+}
+var G=new PropertyDescriptor();
+if(N[0]){
+G.setGet(N[2]);
+G.setSet(N[3]);
+}else{
+G.setValue(N[1]);
+G.setWritable(N[4]);
+}
+G.setEnumerable(N[5]);
+G.setConfigurable(N[6]);
+return G;
+}
+function GetTrap(O,z,P){
+var Q=O[z];
+if((Q===(void 0))){
+if((P===(void 0))){
+throw k(41);
+}
+Q=P;
+}else if(!(typeof(Q)==='function')){
+throw k(41);
+}
+return Q;
+}
+function CallTrap1(O,z,P,R){
+return %_Call(GetTrap(O,z,P),O,R);
+}
+function CallTrap2(O,z,P,R,S){
+return %_Call(GetTrap(O,z,P),O,R,S);
+}
+function GetOwnPropertyJS(H,T){
+var U=(%_ToName(T));
+if((%_IsJSProxy(H))){
+if((typeof(T)==='symbol'))return(void 0);
+var O=%JSProxyGetHandler(H);
+var V=CallTrap1(
+O,"getOwnPropertyDescriptor",(void 0),U);
+if((V===(void 0)))return V;
+var G=ToCompletePropertyDescriptor(V);
+if(!G.isConfigurable()){
+throw k(41);
+}
+return G;
+}
+var W=%GetOwnProperty_Legacy((%_ToObject(H)),U);
+return ConvertDescriptorArrayToDescriptor(W);
+}
+function GetMethod(H,U){
+var X=H[U];
+if((X==null))return(void 0);
+if((typeof(X)==='function'))return X;
+throw k(15,typeof X);
+}
+function DefineProxyProperty(H,U,x,Y){
+if((typeof(U)==='symbol'))return false;
+var O=%JSProxyGetHandler(H);
+var Z=CallTrap2(O,"defineProperty",(void 0),U,x);
+if(!Z){
+if(Y){
+throw k(41);
+}else{
+return false;
+}
+}
+return true;
+}
+function DefineObjectProperty(H,U,G,Y){
+var aa=%GetOwnProperty_Legacy(H,(%_ToName(U)));
+var ab=ConvertDescriptorArrayToDescriptor(aa);
+var ac=%object_is_extensible(H);
+if((ab===(void 0))&&!ac){
+if(Y){
+throw k(34,U);
+}else{
+return false;
+}
+}
+if(!(ab===(void 0))){
+if((IsGenericDescriptor(G)||
+IsDataDescriptor(G)==IsDataDescriptor(ab))&&
+(!G.hasEnumerable()||
+r(G.isEnumerable(),ab.isEnumerable()))&&
+(!G.hasConfigurable()||
+r(G.isConfigurable(),ab.isConfigurable()))&&
+(!G.hasWritable()||
+r(G.isWritable(),ab.isWritable()))&&
+(!G.hasValue()||
+r(G.getValue(),ab.getValue()))&&
+(!G.hasGetter()||
+r(G.getGet(),ab.getGet()))&&
+(!G.hasSetter()||
+r(G.getSet(),ab.getSet()))){
+return true;
+}
+if(!ab.isConfigurable()){
+if(G.isConfigurable()||
+(G.hasEnumerable()&&
+G.isEnumerable()!=ab.isEnumerable())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(!IsGenericDescriptor(G)){
+if(IsDataDescriptor(ab)!=IsDataDescriptor(G)){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(IsDataDescriptor(ab)&&IsDataDescriptor(G)){
+var ad=ab.isWritable();
+if(ad!=G.isWritable()){
+if(!ad||(%IsStrong(H))){
+if(Y){
+throw ad
+?k(146,H,U)
+:k(126,U);
+}else{
+return false;
+}
+}
+}
+if(!ad&&G.hasValue()&&
+!r(G.getValue(),ab.getValue())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+}
+if(IsAccessorDescriptor(G)&&IsAccessorDescriptor(ab)){
+if(G.hasSetter()&&
+!r(G.getSet(),ab.getSet())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+if(G.hasGetter()&&!r(G.getGet(),ab.getGet())){
+if(Y){
+throw k(126,U);
+}else{
+return false;
+}
+}
+}
+}
+}
+}
+var ae=0;
+if(G.hasEnumerable()){
+ae|=G.isEnumerable()?0:2;
+}else if(!(ab===(void 0))){
+ae|=ab.isEnumerable()?0:2;
+}else{
+ae|=2;
+}
+if(G.hasConfigurable()){
+ae|=G.isConfigurable()?0:4;
+}else if(!(ab===(void 0))){
+ae|=ab.isConfigurable()?0:4;
+}else
+ae|=4;
+if(IsDataDescriptor(G)||
+(IsGenericDescriptor(G)&&
+((ab===(void 0))||IsDataDescriptor(ab)))){
+if(G.hasWritable()){
+ae|=G.isWritable()?0:1;
+}else if(!(ab===(void 0))){
+ae|=ab.isWritable()?0:1;
+}else{
+ae|=1;
+}
+var y=(void 0);
+if(G.hasValue()){
+y=G.getValue();
+}else if(!(ab===(void 0))&&IsDataDescriptor(ab)){
+y=ab.getValue();
+}
+%DefineDataPropertyUnchecked(H,U,y,ae);
+}else{
+var af=null;
+if(G.hasGetter()){
+af=G.getGet();
+}else if(IsAccessorDescriptor(ab)&&ab.hasGetter()){
+af=ab.getGet();
+}
+var ag=null;
+if(G.hasSetter()){
+ag=G.getSet();
+}else if(IsAccessorDescriptor(ab)&&ab.hasSetter()){
+ag=ab.getSet();
+}
+%DefineAccessorPropertyUnchecked(H,U,af,ag,ae);
+}
+return true;
+}
+function DefineArrayProperty(H,U,G,Y){
+if(!(typeof(U)==='symbol')){
+var ah=((U)>>>0);
+var ai=false;
+if((%_ToString(ah))==U&&ah!=4294967295){
+var aj=H.length;
+if(ah>=aj&&%IsObserved(H)){
+ai=true;
+o(H);
+}
+var ak=GetOwnPropertyJS(H,"length");
+if((ah>=aj&&!ak.isWritable())||
+!DefineObjectProperty(H,U,G,true)){
+if(ai)
+p(H);
+if(Y){
+throw k(34,U);
+}else{
+return false;
+}
+}
+if(ah>=aj){
+H.length=ah+1;
+}
+if(ai){
+p(H);
+q(H,aj,[],ah+1-aj);
+}
+return true;
+}
+}
+return DefineObjectProperty(H,U,G,Y);
+}
+function DefineOwnProperty(H,U,G,Y){
+if((%_IsJSProxy(H))){
+if((typeof(U)==='symbol'))return false;
+var x=FromGenericPropertyDescriptor(G);
+return DefineProxyProperty(H,U,x,Y);
+}else if((%_IsArray(H))){
+return DefineArrayProperty(H,U,G,Y);
+}else{
+return DefineObjectProperty(H,U,G,Y);
+}
+}
+function ObjectGetPrototypeOf(H){
+return %_GetPrototype((%_ToObject(H)));
+}
+function ObjectSetPrototypeOf(H,al){
+if((%IS_VAR(H)===null)||(H===(void 0)))throw k(17,"Object.setPrototypeOf");
+if(al!==null&&!(%_IsJSReceiver(al))){
+throw k(92,al);
+}
+if((%_IsJSReceiver(H))){
+%SetPrototype(H,al);
+}
+return H;
+}
+function ObjectGetOwnPropertyDescriptor(H,U){
+return %GetOwnProperty(H,U);
+}
+function ObjectGetOwnPropertyNames(H){
+H=(%_ToObject(H));
+return %GetOwnPropertyKeys(H,16);
+}
+function ObjectDefineProperty(H,U,x){
+if(%IsObserved(H)){
+if(!(%_IsJSReceiver(H))){
+throw k(16,"Object.defineProperty");
+}
+var z=(%_ToName(U));
+var G=ToPropertyDescriptor(x);
+DefineOwnProperty(H,z,G,true);
+return H;
+}
+return %ObjectDefineProperty(H,U,x);
+}
+function GetOwnEnumerablePropertyNames(A){
+return %GetOwnPropertyKeys(A,2);
+}
+function ObjectDefineProperties(H,am){
+if(%IsObserved(H)){
+if(!(%_IsJSReceiver(H))){
+throw k(16,"Object.defineProperties");
+}
+var W=(%_ToObject(am));
+var an=GetOwnEnumerablePropertyNames(W);
+var ao=new g();
+for(var ap=0;ap<an.length;ap++){
+ao.push(ToPropertyDescriptor(W[an[ap]]));
+}
+for(var ap=0;ap<an.length;ap++){
+DefineOwnProperty(H,an[ap],ao[ap],true);
+}
+return H;
+}
+return %ObjectDefineProperties(H,am);
+}
+function ObjectGetProto(){
+return %_GetPrototype((%_ToObject(this)));
+}
+function ObjectSetProto(al){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw k(17,"Object.prototype.__proto__");
+if(((%_IsJSReceiver(al))||(al===null))&&(%_IsJSReceiver(this))){
+%SetPrototype(this,al);
+}
+}
+function ObjectConstructor(R){
+if(f!=new.target&&!(new.target===(void 0))){
+return this;
+}
+if((R===null)||(R===(void 0)))return{};
+return(%_ToObject(R));
+}
+%SetNativeFlag(f);
+%SetCode(f,ObjectConstructor);
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+b.InstallFunctions(f.prototype,2,[
+"toString",n,
+"toLocaleString",ObjectToLocaleString,
+"valueOf",ObjectValueOf,
+"hasOwnProperty",ObjectHasOwnProperty,
+"isPrototypeOf",ObjectIsPrototypeOf,
+"propertyIsEnumerable",ObjectPropertyIsEnumerable,
+"__defineGetter__",ObjectDefineGetter,
+"__lookupGetter__",ObjectLookupGetter,
+"__defineSetter__",ObjectDefineSetter,
+"__lookupSetter__",ObjectLookupSetter
+]);
+b.InstallGetterSetter(f.prototype,"__proto__",ObjectGetProto,
+ObjectSetProto);
+b.InstallFunctions(f,2,[
+"defineProperty",ObjectDefineProperty,
+"defineProperties",ObjectDefineProperties,
+"getPrototypeOf",ObjectGetPrototypeOf,
+"setPrototypeOf",ObjectSetPrototypeOf,
+"getOwnPropertyDescriptor",ObjectGetOwnPropertyDescriptor,
+"getOwnPropertyNames",ObjectGetOwnPropertyNames,
+"is",r,
+]);
+function BooleanConstructor(R){
+"use strict";
+if(!(new.target===(void 0))){
+%_SetValueOf(this,(!!(R)));
+}else{
+return(!!(R));
+}
+}
+function BooleanToString(){
+var aq=this;
+if(!(typeof(aq)==='boolean')){
+if(!(%_ClassOf(aq)==='Boolean')){
+throw k(65,'Boolean.prototype.toString');
+}
+aq=%_ValueOf(aq);
+}
+return aq?'true':'false';
+}
+function BooleanValueOf(){
+if(!(typeof(this)==='boolean')&&!(%_ClassOf(this)==='Boolean')){
+throw k(65,'Boolean.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+%SetCode(d,BooleanConstructor);
+%FunctionSetPrototype(d,new d(false));
+%AddNamedProperty(d.prototype,"constructor",d,
+2);
+b.InstallFunctions(d.prototype,2,[
+"toString",BooleanToString,
+"valueOf",BooleanValueOf
+]);
+function NumberToStringJS(w){
+var u=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(65,'Number.prototype.toString');
+}
+u=%_ValueOf(this);
+}
+if((w===(void 0))||w===10){
+return %_NumberToString(u);
+}
+w=(%_ToInteger(w));
+if(w<2||w>36)throw i(189);
+return %NumberToRadixString(u,w);
+}
+function NumberToLocaleString(){
+return %_Call(NumberToStringJS,this);
+}
+function NumberValueOf(){
+if(!(typeof(this)==='number')&&!(%_ClassOf(this)==='Number')){
+throw k(65,'Number.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function NumberToFixedJS(ar){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toFixed",this);
+}
+R=%_ValueOf(this);
+}
+var as=(%_ToInteger(ar));
+if(as<0||as>20){
+throw i(185,"toFixed() digits");
+}
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+return %NumberToFixed(R,as);
+}
+function NumberToExponentialJS(ar){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toExponential",this);
+}
+R=%_ValueOf(this);
+}
+var as=(ar===(void 0))?(void 0):(%_ToInteger(ar));
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+if((as===(void 0))){
+as=-1;
+}else if(as<0||as>20){
+throw i(185,"toExponential()");
+}
+return %NumberToExponential(R,as);
+}
+function NumberToPrecisionJS(at){
+var R=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw k(42,
+"Number.prototype.toPrecision",this);
+}
+R=%_ValueOf(this);
+}
+if((at===(void 0)))return(%_ToString(R));
+var U=(%_ToInteger(at));
+if((!%_IsSmi(%IS_VAR(R))&&!(R==R)))return"NaN";
+if(R==(1/0))return"Infinity";
+if(R==-(1/0))return"-Infinity";
+if(U<1||U>21){
+throw i(188);
+}
+return %NumberToPrecision(R,U);
+}
+function NumberIsFinite(u){
+return(typeof(u)==='number')&&(%_IsSmi(%IS_VAR(u))||((u==u)&&(u!=1/0)&&(u!=-1/0)));
+}
+function NumberIsInteger(u){
+return NumberIsFinite(u)&&(%_ToInteger(u))==u;
+}
+function NumberIsNaN(u){
+return(typeof(u)==='number')&&(!%_IsSmi(%IS_VAR(u))&&!(u==u));
+}
+function NumberIsSafeInteger(u){
+if(NumberIsFinite(u)){
+var au=(%_ToInteger(u));
+if(au==u){
+return l(au)<=9007199254740991;
+}
+}
+return false;
+}
+%FunctionSetPrototype(e,new e(0));
+%OptimizeObjectForAddingMultipleProperties(e.prototype,8);
+%AddNamedProperty(e.prototype,"constructor",e,
+2);
+b.InstallConstants(e,[
+"MAX_VALUE",1.7976931348623157e+308,
+"MIN_VALUE",5e-324,
+"NaN",m,
+"NEGATIVE_INFINITY",-(1/0),
+"POSITIVE_INFINITY",(1/0),
+"MAX_SAFE_INTEGER",%_MathPow(2,53)-1,
+"MIN_SAFE_INTEGER",-%_MathPow(2,53)+1,
+"EPSILON",%_MathPow(2,-52)
+]);
+b.InstallFunctions(e.prototype,2,[
+"toString",NumberToStringJS,
+"toLocaleString",NumberToLocaleString,
+"valueOf",NumberValueOf,
+"toFixed",NumberToFixedJS,
+"toExponential",NumberToExponentialJS,
+"toPrecision",NumberToPrecisionJS
+]);
+b.InstallFunctions(e,2,[
+"isFinite",NumberIsFinite,
+"isInteger",NumberIsInteger,
+"isNaN",NumberIsNaN,
+"isSafeInteger",NumberIsSafeInteger,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat
+]);
+%SetForceInlineFlag(NumberIsNaN);
+function GetIterator(H,av){
+if((av===(void 0))){
+av=H[h];
+}
+if(!(typeof(av)==='function')){
+throw k(66,H);
+}
+var aw=%_Call(av,H);
+if(!(%_IsJSReceiver(aw))){
+throw k(60,aw);
+}
+return aw;
+}
+b.Export(function(ax){
+ax.GetIterator=GetIterator;
+ax.GetMethod=GetMethod;
+ax.IsFinite=GlobalIsFinite;
+ax.IsNaN=GlobalIsNaN;
+ax.NumberIsNaN=NumberIsNaN;
+ax.ObjectDefineProperties=ObjectDefineProperties;
+ax.ObjectDefineProperty=ObjectDefineProperty;
+ax.ObjectHasOwnProperty=ObjectHasOwnProperty;
+});
+%InstallToContext([
+"object_value_of",ObjectValueOf,
+]);
+})
+
+symbol9
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=a.Symbol;
+var e=b.ImportNow("has_instance_symbol");
+var f=
+b.ImportNow("is_concat_spreadable_symbol");
+var g=b.ImportNow("iterator_symbol");
+var h;
+var i=b.ImportNow("to_primitive_symbol");
+var j=b.ImportNow("to_string_tag_symbol");
+var k=b.ImportNow("unscopables_symbol");
+b.Import(function(l){
+h=l.MakeTypeError;
+});
+function SymbolToPrimitive(m){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype [ @@toPrimitive ]",this);
+}
+return %_ValueOf(this);
+}
+function SymbolToString(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype.toString",this);
+}
+return %SymbolDescriptiveString(%_ValueOf(this));
+}
+function SymbolValueOf(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw h(42,
+"Symbol.prototype.valueOf",this);
+}
+return %_ValueOf(this);
+}
+function SymbolFor(n){
+n=(%_ToString(n));
+var o=%SymbolRegistry();
+if((o.for[n]===(void 0))){
+var p=%CreateSymbol(n);
+o.for[n]=p;
+o.keyFor[p]=n;
+}
+return o.for[n];
+}
+function SymbolKeyFor(p){
+if(!(typeof(p)==='symbol'))throw h(148,p);
+return %SymbolRegistry().keyFor[p];
+}
+function ObjectGetOwnPropertySymbols(q){
+q=(%_ToObject(q));
+return %GetOwnPropertyKeys(q,8);
+}
+%FunctionSetPrototype(d,new c());
+b.InstallConstants(d,[
+"iterator",g,
+"toPrimitive",i,
+"unscopables",k,
+]);
+b.InstallFunctions(d,2,[
+"for",SymbolFor,
+"keyFor",SymbolKeyFor
+]);
+%AddNamedProperty(
+d.prototype,"constructor",d,2);
+%AddNamedProperty(
+d.prototype,j,"Symbol",2|1);
+b.InstallFunctions(d.prototype,2|1,[
+i,SymbolToPrimitive
+]);
+b.InstallFunctions(d.prototype,2,[
+"toString",SymbolToString,
+"valueOf",SymbolValueOf
+]);
+b.InstallFunctions(c,2,[
+"getOwnPropertySymbols",ObjectGetOwnPropertySymbols
+]);
+b.Export(function(r){
+r.SymbolToString=SymbolToString;
+})
+})
+
+array¦±

+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d;
+var e;
+var f;
+var g;
+var h;
+var i=a.Array;
+var j=b.InternalArray;
+var k=b.InternalPackedArray;
+var l;
+var m;
+var n;
+var o;
+var p;
+var q=b.ImportNow("object_to_string");
+var r;
+var s;
+var t;
+var u;
+var v=b.ImportNow("iterator_symbol");
+var w=b.ImportNow("unscopables_symbol");
+b.Import(function(x){
+d=x.AddIndexedProperty;
+g=x.GetIterator;
+h=x.GetMethod;
+l=x.MakeTypeError;
+m=x.MaxSimple;
+n=x.MinSimple;
+o=x.ObjectDefineProperty;
+p=x.ObjectHasOwnProperty;
+r=x.ObserveBeginPerformSplice;
+s=x.ObserveEndPerformSplice;
+t=x.ObserveEnqueueSpliceRecord;
+u=x.SameValueZero;
+});
+b.ImportFromExperimental(function(x){
+e=x.FLAG_harmony_tolength;
+f=x.FLAG_harmony_species;
+});
+function ArraySpeciesCreate(y,z){
+var A;
+if(f){
+A=%ArraySpeciesConstructor(y);
+}else{
+A=i;
+}
+return new A(z);
+}
+function DefineIndexedProperty(y,B,C){
+if(f){
+var D=o(y,B,{
+value:C,writable:true,configurable:true,enumerable:true
+});
+if(!D)throw l(137,B);
+}else{
+d(y,B,C);
+}
+}
+var E=new j();
+function GetSortedArrayKeys(y,F){
+var G=new j();
+if((typeof(F)==='number')){
+var H=F;
+for(var B=0;B<H;++B){
+var I=y[B];
+if(!(I===(void 0))||B in y){
+G.push(B);
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+var I=y[K];
+if(!(I===(void 0))||K in y){
+G.push(K);
+}
+}
+}
+G.sort(function(L,M){return L-M;});
+}
+return G;
+}
+function SparseJoinWithSeparatorJS(y,N,O,P){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var Q=0;
+var R=new j(G.length*2);
+var S=-1;
+for(var B=0;B<G.length;B++){
+var K=G[B];
+if(K!=S){
+var I=y[K];
+if(!(typeof(I)==='string'))I=O(I);
+R[B*2]=K;
+R[B*2+1]=I;
+S=K;
+}
+}
+return %SparseJoinWithSeparator(R,N,P);
+}
+function SparseJoin(y,N,O){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var T=-1;
+var U=G.length;
+var R=new j(U);
+var V=0;
+for(var B=0;B<U;B++){
+var K=G[B];
+if(K!=T){
+var I=y[K];
+if(!(typeof(I)==='string'))I=O(I);
+R[V++]=I;
+T=K;
+}
+}
+return %StringBuilderConcat(R,V,'');
+}
+function UseSparseVariant(y,z,W,X){
+if(!W||z<1000||%IsObserved(y)||
+%HasComplexElements(y)){
+return false;
+}
+if(!%_IsSmi(z)){
+return true;
+}
+var Y=z>>2;
+var Z=%EstimateNumberOfElements(y);
+return(Z<Y)&&
+(X>Z*4);
+}
+function Join(y,z,P,O){
+if(z==0)return'';
+var W=(%_IsArray(y));
+if(W){
+if(!%PushIfAbsent(E,y))return'';
+}
+try{
+if(UseSparseVariant(y,z,W,z)){
+%NormalizeElements(y);
+if(P.length==0){
+return SparseJoin(y,z,O);
+}else{
+return SparseJoinWithSeparatorJS(y,z,O,P);
+}
+}
+if(z==1){
+var I=y[0];
+if((typeof(I)==='string'))return I;
+return O(I);
+}
+var R=new j(z);
+if(P.length==0){
+var V=0;
+for(var B=0;B<z;B++){
+var I=y[B];
+if(!(typeof(I)==='string'))I=O(I);
+R[V++]=I;
+}
+R.length=V;
+var D=%_FastOneByteArrayJoin(R,'');
+if(!(D===(void 0)))return D;
+return %StringBuilderConcat(R,V,'');
+}
+if(!(typeof(y[0])==='number')){
+for(var B=0;B<z;B++){
+var I=y[B];
+if(!(typeof(I)==='string'))I=O(I);
+R[B]=I;
+}
+}else{
+for(var B=0;B<z;B++){
+var I=y[B];
+if((typeof(I)==='number')){
+I=%_NumberToString(I);
+}else if(!(typeof(I)==='string')){
+I=O(I);
+}
+R[B]=I;
+}
+}
+var D=%_FastOneByteArrayJoin(R,P);
+if(!(D===(void 0)))return D;
+return %StringBuilderJoin(R,z,P);
+}finally{
+if(W)E.length=E.length-1;
+}
+}
+function ConvertToString(aa){
+if((aa==null)){
+return'';
+}else{
+return(%_ToString(aa));
+}
+}
+function ConvertToLocaleString(I){
+if((I==null)){
+return'';
+}else{
+return(%_ToString(I.toLocaleString()));
+}
+}
+function SparseSlice(y,ab,ac,N,ad){
+var F=%GetArrayKeys(y,ab+ac);
+if((typeof(F)==='number')){
+var H=F;
+for(var B=ab;B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+DefineIndexedProperty(ad,B-ab,ae);
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+if(K>=ab){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+DefineIndexedProperty(ad,K-ab,ae);
+}
+}
+}
+}
+}
+}
+function SparseMove(y,ab,ac,N,af){
+if(af===ac)return;
+var ag=new j(
+n(N-ac+af,0xffffffff));
+var ah;
+var F=%GetArrayKeys(y,N);
+if((typeof(F)==='number')){
+var H=F;
+for(var B=0;B<ab&&B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+ag[B]=ae;
+}
+}
+for(var B=ab+ac;B<H;++B){
+var ae=y[B];
+if(!(ae===(void 0))||B in y){
+ag[B-ac+af]=ae;
+}
+}
+}else{
+var z=F.length;
+for(var J=0;J<z;++J){
+var K=F[J];
+if(!(K===(void 0))){
+if(K<ab){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+ag[K]=ae;
+}
+}else if(K>=ab+ac){
+var ae=y[K];
+if(!(ae===(void 0))||K in y){
+var ai=K-ac+af;
+ag[ai]=ae;
+if(ai>0xfffffffe){
+ah=ah||new j();
+ah.push(ai);
+}
+}
+}
+}
+}
+}
+%MoveArrayContents(ag,y);
+if(!(ah===(void 0))){
+var z=ah.length;
+for(var B=0;B<z;++B){
+var K=ah[B];
+y[K]=ag[K];
+}
+}
+}
+function SimpleSlice(y,ab,ac,N,ad){
+var W=(%_IsArray(y));
+for(var B=0;B<ac;B++){
+var aj=ab+B;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(aj<y.length):(aj in y))){
+var ae=y[aj];
+DefineIndexedProperty(ad,B,ae);
+}
+}
+}
+function SimpleMove(y,ab,ac,N,af){
+var W=(%_IsArray(y));
+if(af!==ac){
+if(af>ac){
+for(var B=N-ac;B>ab;B--){
+var ak=B+ac-1;
+var al=B+af-1;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(ak<y.length):(ak in y))){
+y[al]=y[ak];
+}else{
+delete y[al];
+}
+}
+}else{
+for(var B=ab;B<N-ac;B++){
+var ak=B+ac;
+var al=B+af;
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(ak<y.length):(ak in y))){
+y[al]=y[ak];
+}else{
+delete y[al];
+}
+}
+for(var B=N;B>N-ac+af;B--){
+delete y[B-1];
+}
+}
+}
+}
+function ArrayToString(){
+var y;
+var am;
+if((%_IsArray(this))){
+am=this.join;
+if(am===ArrayJoin){
+return Join(this,this.length,',',ConvertToString);
+}
+y=this;
+}else{
+y=(%_ToObject(this));
+am=y.join;
+}
+if(!(typeof(am)==='function')){
+return %_Call(q,y);
+}
+return %_Call(am,y);
+}
+function InnerArrayToLocaleString(y,z){
+var N=(e?(%_ToLength(z)):((z)>>>0));
+if(N===0)return"";
+return Join(y,N,',',ConvertToLocaleString);
+}
+function ArrayToLocaleString(){
+var y=(%_ToObject(this));
+var an=y.length;
+return InnerArrayToLocaleString(y,an);
+}
+function InnerArrayJoin(P,y,z){
+if((P===(void 0))){
+P=',';
+}else{
+P=(%_ToString(P));
+}
+var D=%_FastOneByteArrayJoin(y,P);
+if(!(D===(void 0)))return D;
+if(z===1){
+var I=y[0];
+if((I==null))return'';
+return(%_ToString(I));
+}
+return Join(y,z,P,ConvertToString);
+}
+function ArrayJoin(P){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.join");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayJoin(P,y,z);
+}
+function ObservedArrayPop(ao){
+ao--;
+var C=this[ao];
+try{
+r(this);
+delete this[ao];
+this.length=ao;
+}finally{
+s(this);
+t(this,ao,[C],0);
+}
+return C;
+}
+function ArrayPop(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.pop");
+var y=(%_ToObject(this));
+var ao=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(ao==0){
+y.length=ao;
+return;
+}
+if(%IsObserved(y))
+return ObservedArrayPop.call(y,ao);
+ao--;
+var C=y[ao];
+%DeleteProperty_Strict(y,ao);
+y.length=ao;
+return C;
+}
+function ObservedArrayPush(){
+var ao=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var ap=%_ArgumentsLength();
+try{
+r(this);
+for(var B=0;B<ap;B++){
+this[B+ao]=%_Arguments(B);
+}
+var aq=ao+ap;
+this.length=aq;
+}finally{
+s(this);
+t(this,ao,[],ap);
+}
+return aq;
+}
+function ArrayPush(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.push");
+if(%IsObserved(this))
+return ObservedArrayPush.apply(this,arguments);
+var y=(%_ToObject(this));
+var ao=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ap=%_ArgumentsLength();
+if(ap>(1<<30)||(ao-(1<<30))+ap>9007199254740991-(1<<30)){
+throw l(228,ap,ao);
+}
+for(var B=0;B<ap;B++){
+y[B+ao]=%_Arguments(B);
+}
+var aq=ao+ap;
+y.length=aq;
+return aq;
+}
+function SparseReverse(y,N){
+var G=GetSortedArrayKeys(y,%GetArrayKeys(y,N));
+var ar=G.length-1;
+var as=0;
+while(as<=ar){
+var B=G[as];
+var at=G[ar];
+var au=N-at-1;
+var av,aw;
+if(au<=B){
+aw=at;
+while(G[--ar]==at){}
+av=au;
+}
+if(au>=B){
+av=B;
+while(G[++as]==B){}
+aw=N-B-1;
+}
+var ax=y[av];
+if(!(ax===(void 0))||av in y){
+var ay=y[aw];
+if(!(ay===(void 0))||aw in y){
+y[av]=ay;
+y[aw]=ax;
+}else{
+y[aw]=ax;
+delete y[av];
+}
+}else{
+var ay=y[aw];
+if(!(ay===(void 0))||aw in y){
+y[av]=ay;
+delete y[aw];
+}
+}
+}
+}
+function PackedArrayReverse(y,N){
+var at=N-1;
+for(var B=0;B<at;B++,at--){
+var ax=y[B];
+var ay=y[at];
+y[B]=ay;
+y[at]=ax;
+}
+return y;
+}
+function GenericArrayReverse(y,N){
+var at=N-1;
+for(var B=0;B<at;B++,at--){
+if(B in y){
+var ax=y[B];
+if(at in y){
+var ay=y[at];
+y[B]=ay;
+y[at]=ax;
+}else{
+y[at]=ax;
+delete y[B];
+}
+}else{
+if(at in y){
+var ay=y[at];
+y[B]=ay;
+delete y[at];
+}
+}
+}
+return y;
+}
+function ArrayReverse(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reverse");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var az=(%_IsArray(y));
+if(UseSparseVariant(y,N,az,N)){
+%NormalizeElements(y);
+SparseReverse(y,N);
+return y;
+}else if(az&&%_HasFastPackedElements(y)){
+return PackedArrayReverse(y,N);
+}else{
+return GenericArrayReverse(y,N);
+}
+}
+function ObservedArrayShift(N){
+var aA=this[0];
+try{
+r(this);
+SimpleMove(this,0,1,N,0);
+this.length=N-1;
+}finally{
+s(this);
+t(this,0,[aA],0);
+}
+return aA;
+}
+function ArrayShift(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.shift");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(N===0){
+y.length=0;
+return;
+}
+if(%object_is_sealed(y))throw l(13);
+if(%IsObserved(y))
+return ObservedArrayShift.call(y,N);
+var aA=y[0];
+if(UseSparseVariant(y,N,(%_IsArray(y)),N)){
+SparseMove(y,0,1,N,0);
+}else{
+SimpleMove(y,0,1,N,0);
+}
+y.length=N-1;
+return aA;
+}
+function ObservedArrayUnshift(){
+var N=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var aB=%_ArgumentsLength();
+try{
+r(this);
+SimpleMove(this,0,0,N,aB);
+for(var B=0;B<aB;B++){
+this[B]=%_Arguments(B);
+}
+var aq=N+aB;
+this.length=aq;
+}finally{
+s(this);
+t(this,0,[],aB);
+}
+return aq;
+}
+function ArrayUnshift(aC){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.unshift");
+if(%IsObserved(this))
+return ObservedArrayUnshift.apply(this,arguments);
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var aB=%_ArgumentsLength();
+if(N>0&&UseSparseVariant(y,N,(%_IsArray(y)),N)&&
+!%object_is_sealed(y)){
+SparseMove(y,0,0,N,aB);
+}else{
+SimpleMove(y,0,0,N,aB);
+}
+for(var B=0;B<aB;B++){
+y[B]=%_Arguments(B);
+}
+var aq=N+aB;
+y.length=aq;
+return aq;
+}
+function ArraySlice(aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.slice");
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ab=(%_ToInteger(aD));
+var aF=N;
+if(!(aE===(void 0)))aF=(%_ToInteger(aE));
+if(ab<0){
+ab+=N;
+if(ab<0)ab=0;
+}else{
+if(ab>N)ab=N;
+}
+if(aF<0){
+aF+=N;
+if(aF<0)aF=0;
+}else{
+if(aF>N)aF=N;
+}
+var D=ArraySpeciesCreate(y,m(aF-ab,0));
+if(aF<ab)return D;
+if(UseSparseVariant(y,N,(%_IsArray(y)),aF-ab)){
+%NormalizeElements(y);
+%NormalizeElements(D);
+SparseSlice(y,ab,aF-ab,N,D);
+}else{
+SimpleSlice(y,ab,aF-ab,N,D);
+}
+D.length=aF-ab;
+return D;
+}
+function ComputeSpliceStartIndex(ab,N){
+if(ab<0){
+ab+=N;
+return ab<0?0:ab;
+}
+return ab>N?N:ab;
+}
+function ComputeSpliceDeleteCount(aG,aB,N,ab){
+var ac=0;
+if(aB==1)
+return N-ab;
+ac=(%_ToInteger(aG));
+if(ac<0)
+return 0;
+if(ac>N-ab)
+return N-ab;
+return ac;
+}
+function ObservedArraySplice(aD,aG){
+var aB=%_ArgumentsLength();
+var N=(e?(%_ToLength(this.length)):((this.length)>>>0));
+var ab=ComputeSpliceStartIndex((%_ToInteger(aD)),N);
+var ac=ComputeSpliceDeleteCount(aG,aB,N,
+ab);
+var ad=[];
+ad.length=ac;
+var aH=aB>2?aB-2:0;
+try{
+r(this);
+SimpleSlice(this,ab,ac,N,ad);
+SimpleMove(this,ab,ac,N,aH);
+var B=ab;
+var aI=2;
+var aJ=%_ArgumentsLength();
+while(aI<aJ){
+this[B++]=%_Arguments(aI++);
+}
+this.length=N-ac+aH;
+}finally{
+s(this);
+if(ad.length||aH){
+t(this,
+ab,
+ad.slice(),
+aH);
+}
+}
+return ad;
+}
+function ArraySplice(aD,aG){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.splice");
+if(%IsObserved(this))
+return ObservedArraySplice.apply(this,arguments);
+var aB=%_ArgumentsLength();
+var y=(%_ToObject(this));
+var N=(e?(%_ToLength(y.length)):((y.length)>>>0));
+var ab=ComputeSpliceStartIndex((%_ToInteger(aD)),N);
+var ac=ComputeSpliceDeleteCount(aG,aB,N,
+ab);
+var ad=ArraySpeciesCreate(y,ac);
+ad.length=ac;
+var aH=aB>2?aB-2:0;
+if(ac!=aH&&%object_is_sealed(y)){
+throw l(13);
+}else if(ac>0&&%object_is_frozen(y)){
+throw l(12);
+}
+var aK=ac;
+if(aH!=ac){
+aK+=N-ab-ac;
+}
+if(UseSparseVariant(y,N,(%_IsArray(y)),aK)){
+%NormalizeElements(y);
+%NormalizeElements(ad);
+SparseSlice(y,ab,ac,N,ad);
+SparseMove(y,ab,ac,N,aH);
+}else{
+SimpleSlice(y,ab,ac,N,ad);
+SimpleMove(y,ab,ac,N,aH);
+}
+var B=ab;
+var aI=2;
+var aJ=%_ArgumentsLength();
+while(aI<aJ){
+y[B++]=%_Arguments(aI++);
+}
+y.length=N-ac+aH;
+return ad;
+}
+function InnerArraySort(y,z,aL){
+if(!(typeof(aL)==='function')){
+aL=function(aa,aM){
+if(aa===aM)return 0;
+if(%_IsSmi(aa)&&%_IsSmi(aM)){
+return %SmiLexicographicCompare(aa,aM);
+}
+aa=(%_ToString(aa));
+aM=(%_ToString(aM));
+if(aa==aM)return 0;
+else return aa<aM?-1:1;
+};
+}
+var aN=function InsertionSort(L,x,aO){
+for(var B=x+1;B<aO;B++){
+var aP=L[B];
+for(var at=B-1;at>=x;at--){
+var aQ=L[at];
+var aR=aL(aQ,aP);
+if(aR>0){
+L[at+1]=aQ;
+}else{
+break;
+}
+}
+L[at+1]=aP;
+}
+};
+var aS=function(L,x,aO){
+var aT=new j();
+var aU=200+((aO-x)&15);
+var at=0;
+x+=1;
+aO-=1;
+for(var B=x;B<aO;B+=aU){
+aT[at]=[B,L[B]];
+at++;
+}
+aT.sort(function(L,M){
+return aL(L[1],M[1]);
+});
+var aV=aT[aT.length>>1][0];
+return aV;
+}
+var aW=function QuickSort(L,x,aO){
+var aV=0;
+while(true){
+if(aO-x<=10){
+aN(L,x,aO);
+return;
+}
+if(aO-x>1000){
+aV=aS(L,x,aO);
+}else{
+aV=x+((aO-x)>>1);
+}
+var aX=L[x];
+var aY=L[aO-1];
+var aZ=L[aV];
+var ba=aL(aX,aY);
+if(ba>0){
+var aQ=aX;
+aX=aY;
+aY=aQ;
+}
+var bb=aL(aX,aZ);
+if(bb>=0){
+var aQ=aX;
+aX=aZ;
+aZ=aY;
+aY=aQ;
+}else{
+var bc=aL(aY,aZ);
+if(bc>0){
+var aQ=aY;
+aY=aZ;
+aZ=aQ;
+}
+}
+L[x]=aX;
+L[aO-1]=aZ;
+var bd=aY;
+var be=x+1;
+var bf=aO-1;
+L[aV]=L[be];
+L[be]=bd;
+partition:for(var B=be+1;B<bf;B++){
+var aP=L[B];
+var aR=aL(aP,bd);
+if(aR<0){
+L[B]=L[be];
+L[be]=aP;
+be++;
+}else if(aR>0){
+do{
+bf--;
+if(bf==B)break partition;
+var bg=L[bf];
+aR=aL(bg,bd);
+}while(aR>0);
+L[B]=L[bf];
+L[bf]=aP;
+if(aR<0){
+aP=L[B];
+L[B]=L[be];
+L[be]=aP;
+be++;
+}
+}
+}
+if(aO-bf<be-x){
+aW(L,bf,aO);
+aO=be;
+}else{
+aW(L,x,be);
+x=bf;
+}
+}
+};
+var bh=function CopyFromPrototype(bi,z){
+var bj=0;
+for(var bk=%_GetPrototype(bi);bk;bk=%_GetPrototype(bk)){
+var F=%GetArrayKeys(bk,z);
+if((typeof(F)==='number')){
+var bl=F;
+for(var B=0;B<bl;B++){
+if(!(%_Call(p,bi,B))&&(%_Call(p,bk,B))){
+bi[B]=bk[B];
+if(B>=bj){bj=B+1;}
+}
+}
+}else{
+for(var B=0;B<F.length;B++){
+var aj=F[B];
+if(!(aj===(void 0))&&!(%_Call(p,bi,aj))
+&&(%_Call(p,bk,aj))){
+bi[aj]=bk[aj];
+if(aj>=bj){bj=aj+1;}
+}
+}
+}
+}
+return bj;
+};
+var bm=function(bi,x,aO){
+for(var bk=%_GetPrototype(bi);bk;bk=%_GetPrototype(bk)){
+var F=%GetArrayKeys(bk,aO);
+if((typeof(F)==='number')){
+var bl=F;
+for(var B=x;B<bl;B++){
+if((%_Call(p,bk,B))){
+bi[B]=(void 0);
+}
+}
+}else{
+for(var B=0;B<F.length;B++){
+var aj=F[B];
+if(!(aj===(void 0))&&x<=aj&&
+(%_Call(p,bk,aj))){
+bi[aj]=(void 0);
+}
+}
+}
+}
+};
+var bn=function SafeRemoveArrayHoles(bi){
+var bo=0;
+var bp=z-1;
+var bq=0;
+while(bo<bp){
+while(bo<bp&&
+!(bi[bo]===(void 0))){
+bo++;
+}
+if(!(%_Call(p,bi,bo))){
+bq++;
+}
+while(bo<bp&&
+(bi[bp]===(void 0))){
+if(!(%_Call(p,bi,bp))){
+bq++;
+}
+bp--;
+}
+if(bo<bp){
+bi[bo]=bi[bp];
+bi[bp]=(void 0);
+}
+}
+if(!(bi[bo]===(void 0)))bo++;
+var B;
+for(B=bo;B<z-bq;B++){
+bi[B]=(void 0);
+}
+for(B=z-bq;B<z;B++){
+if(B in %_GetPrototype(bi)){
+bi[B]=(void 0);
+}else{
+delete bi[B];
+}
+}
+return bo;
+};
+if(z<2)return y;
+var W=(%_IsArray(y));
+var br;
+if(!W){
+br=bh(y,z);
+}
+var bs=%RemoveArrayHoles(y,z);
+if(bs==-1){
+bs=bn(y);
+}
+aW(y,0,bs);
+if(!W&&(bs+1<br)){
+bm(y,bs,br);
+}
+return y;
+}
+function ArraySort(aL){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.sort");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArraySort(y,z,aL);
+}
+function InnerArrayFilter(bt,bu,y,z,D){
+var bv=0;
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(%_Call(bt,bu,aP,B,y)){
+DefineIndexedProperty(D,bv,aP);
+bv++;
+}
+}
+}
+return D;
+}
+function ArrayFilter(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.filter");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var D=ArraySpeciesCreate(y,0);
+return InnerArrayFilter(bt,bu,y,z,D);
+}
+function InnerArrayForEach(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+%_Call(bt,bu,aP,B,y);
+}
+}
+}
+function ArrayForEach(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.forEach");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+InnerArrayForEach(bt,bu,y,z);
+}
+function InnerArraySome(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(%_Call(bt,bu,aP,B,y))return true;
+}
+}
+return false;
+}
+function ArraySome(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.some");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArraySome(bt,bu,y,z);
+}
+function InnerArrayEvery(bt,bu,y,z){
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+if(!%_Call(bt,bu,aP,B,y))return false;
+}
+}
+return true;
+}
+function ArrayEvery(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.every");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayEvery(bt,bu,y,z);
+}
+function ArrayMap(bt,bu){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.map");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+if(!(typeof(bt)==='function'))throw l(15,bt);
+var D=ArraySpeciesCreate(y,z);
+var W=(%_IsArray(y));
+for(var B=0;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+DefineIndexedProperty(D,B,%_Call(bt,bu,aP,B,y));
+}
+}
+return D;
+}
+function InnerArrayIndexOf(y,aP,aj,z){
+if(z==0)return-1;
+if((aj===(void 0))){
+aj=0;
+}else{
+aj=(%_ToInteger(aj));
+if(aj<0){
+aj=z+aj;
+if(aj<0)aj=0;
+}
+}
+var bw=aj;
+var bj=z;
+if(UseSparseVariant(y,z,(%_IsArray(y)),bj-bw)){
+%NormalizeElements(y);
+var F=%GetArrayKeys(y,z);
+if((typeof(F)==='number')){
+bj=F;
+}else{
+if(F.length==0)return-1;
+var bx=GetSortedArrayKeys(y,F);
+var ao=bx.length;
+var B=0;
+while(B<ao&&bx[B]<aj)B++;
+while(B<ao){
+var K=bx[B];
+if(!(K===(void 0))&&y[K]===aP)return K;
+B++;
+}
+return-1;
+}
+}
+if(!(aP===(void 0))){
+for(var B=bw;B<bj;B++){
+if(y[B]===aP)return B;
+}
+return-1;
+}
+for(var B=bw;B<bj;B++){
+if((y[B]===(void 0))&&B in y){
+return B;
+}
+}
+return-1;
+}
+function ArrayIndexOf(aP,aj){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.indexOf");
+var z=(e?(%_ToLength(this.length)):((this.length)>>>0));
+return InnerArrayIndexOf(this,aP,aj,z);
+}
+function InnerArrayLastIndexOf(y,aP,aj,z,by){
+if(z==0)return-1;
+if(by<2){
+aj=z-1;
+}else{
+aj=(%_ToInteger(aj));
+if(aj<0)aj+=z;
+if(aj<0)return-1;
+else if(aj>=z)aj=z-1;
+}
+var bw=0;
+var bj=aj;
+if(UseSparseVariant(y,z,(%_IsArray(y)),aj)){
+%NormalizeElements(y);
+var F=%GetArrayKeys(y,aj+1);
+if((typeof(F)==='number')){
+bj=F;
+}else{
+if(F.length==0)return-1;
+var bx=GetSortedArrayKeys(y,F);
+var B=bx.length-1;
+while(B>=0){
+var K=bx[B];
+if(!(K===(void 0))&&y[K]===aP)return K;
+B--;
+}
+return-1;
+}
+}
+if(!(aP===(void 0))){
+for(var B=bj;B>=bw;B--){
+if(y[B]===aP)return B;
+}
+return-1;
+}
+for(var B=bj;B>=bw;B--){
+if((y[B]===(void 0))&&B in y){
+return B;
+}
+}
+return-1;
+}
+function ArrayLastIndexOf(aP,aj){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.lastIndexOf");
+var z=(e?(%_ToLength(this.length)):((this.length)>>>0));
+return InnerArrayLastIndexOf(this,aP,aj,z,
+%_ArgumentsLength());
+}
+function InnerArrayReduce(bz,ae,y,z,by){
+if(!(typeof(bz)==='function')){
+throw l(15,bz);
+}
+var W=(%_IsArray(y));
+var B=0;
+find_initial:if(by<2){
+for(;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+ae=y[B++];
+break find_initial;
+}
+}
+throw l(128);
+}
+for(;B<z;B++){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+ae=bz(ae,aP,B,y);
+}
+}
+return ae;
+}
+function ArrayReduce(bz,ae){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reduce");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayReduce(bz,ae,y,z,
+%_ArgumentsLength());
+}
+function InnerArrayReduceRight(bz,ae,y,z,
+by){
+if(!(typeof(bz)==='function')){
+throw l(15,bz);
+}
+var W=(%_IsArray(y));
+var B=z-1;
+find_initial:if(by<2){
+for(;B>=0;B--){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+ae=y[B--];
+break find_initial;
+}
+}
+throw l(128);
+}
+for(;B>=0;B--){
+if(((W&&%_HasFastPackedElements(%IS_VAR(y)))?(B<y.length):(B in y))){
+var aP=y[B];
+ae=bz(ae,aP,B,y);
+}
+}
+return ae;
+}
+function ArrayReduceRight(bz,ae){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.reduceRight");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayReduceRight(bz,ae,y,z,
+%_ArgumentsLength());
+}
+function InnerArrayCopyWithin(bA,aD,aE,y,z){
+bA=(%_ToInteger(bA));
+var aO;
+if(bA<0){
+aO=m(z+bA,0);
+}else{
+aO=n(bA,z);
+}
+aD=(%_ToInteger(aD));
+var x;
+if(aD<0){
+x=m(z+aD,0);
+}else{
+x=n(aD,z);
+}
+aE=(aE===(void 0))?z:(%_ToInteger(aE));
+var bB;
+if(aE<0){
+bB=m(z+aE,0);
+}else{
+bB=n(aE,z);
+}
+var bC=n(bB-x,z-aO);
+var bD=1;
+if(x<aO&&aO<(x+bC)){
+bD=-1;
+x=x+bC-1;
+aO=aO+bC-1;
+}
+while(bC>0){
+if(x in y){
+y[aO]=y[x];
+}else{
+delete y[aO];
+}
+x=x+bD;
+aO=aO+bD;
+bC--;
+}
+return y;
+}
+function ArrayCopyWithin(bA,aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.copyWithin");
+var y=(%_ToObject(this));
+var z=(%_ToLength(y.length));
+return InnerArrayCopyWithin(bA,aD,aE,y,z);
+}
+function InnerArrayFind(bE,bF,y,z){
+if(!(typeof(bE)==='function')){
+throw l(15,bE);
+}
+for(var B=0;B<z;B++){
+var aP=y[B];
+if(%_Call(bE,bF,aP,B,y)){
+return aP;
+}
+}
+return;
+}
+function ArrayFind(bE,bF){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.find");
+var y=(%_ToObject(this));
+var z=(%_ToInteger(y.length));
+return InnerArrayFind(bE,bF,y,z);
+}
+function InnerArrayFindIndex(bE,bF,y,z){
+if(!(typeof(bE)==='function')){
+throw l(15,bE);
+}
+for(var B=0;B<z;B++){
+var aP=y[B];
+if(%_Call(bE,bF,aP,B,y)){
+return B;
+}
+}
+return-1;
+}
+function ArrayFindIndex(bE,bF){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.findIndex");
+var y=(%_ToObject(this));
+var z=(%_ToInteger(y.length));
+return InnerArrayFindIndex(bE,bF,y,z);
+}
+function InnerArrayFill(C,aD,aE,y,z){
+var B=(aD===(void 0))?0:(%_ToInteger(aD));
+var aE=(aE===(void 0))?z:(%_ToInteger(aE));
+if(B<0){
+B+=z;
+if(B<0)B=0;
+}else{
+if(B>z)B=z;
+}
+if(aE<0){
+aE+=z;
+if(aE<0)aE=0;
+}else{
+if(aE>z)aE=z;
+}
+if((aE-B)>0&&%object_is_frozen(y)){
+throw l(12);
+}
+for(;B<aE;B++)
+y[B]=C;
+return y;
+}
+function ArrayFill(C,aD,aE){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.fill");
+var y=(%_ToObject(this));
+var z=(e?(%_ToLength(y.length)):((y.length)>>>0));
+return InnerArrayFill(C,aD,aE,y,z);
+}
+function InnerArrayIncludes(bG,bH,y,z){
+if(z===0){
+return false;
+}
+var ao=(%_ToInteger(bH));
+var J;
+if(ao>=0){
+J=ao;
+}else{
+J=z+ao;
+if(J<0){
+J=0;
+}
+}
+while(J<z){
+var bI=y[J];
+if(u(bG,bI)){
+return true;
+}
+++J;
+}
+return false;
+}
+function ArrayIncludes(bG,bH){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw l(17,"Array.prototype.includes");
+var y=(%_ToObject(this));
+var z=(%_ToLength(y.length));
+return InnerArrayIncludes(bG,bH,y,z);
+}
+function AddArrayElement(A,y,B,C){
+if(A===i){
+d(y,B,C);
+}else{
+o(y,B,{
+value:C,writable:true,configurable:true,enumerable:true
+});
+}
+}
+function ArrayFrom(bJ,bK,bu){
+var bL=(%_ToObject(bJ));
+var bM=!(bK===(void 0));
+if(bM){
+if(!(typeof(bK)==='function')){
+throw l(15,bK);
+}
+}
+var bN=h(bL,v);
+var J;
+var D;
+var bO;
+var bP;
+if(!(bN===(void 0))){
+D=%IsConstructor(this)?new this():[];
+var bQ=g(bL,bN);
+J=0;
+while(true){
+var bR=bQ.next();
+if(!(%_IsJSReceiver(bR))){
+throw l(48,bR);
+}
+if(bR.done){
+D.length=J;
+return D;
+}
+bP=bR.value;
+if(bM){
+bO=%_Call(bK,bu,bP,J);
+}else{
+bO=bP;
+}
+AddArrayElement(this,D,J,bO);
+J++;
+}
+}else{
+var N=(%_ToLength(bL.length));
+D=%IsConstructor(this)?new this(N):new i(N);
+for(J=0;J<N;++J){
+bP=bL[J];
+if(bM){
+bO=%_Call(bK,bu,bP,J);
+}else{
+bO=bP;
+}
+AddArrayElement(this,D,J,bO);
+}
+D.length=J;
+return D;
+}
+}
+function ArrayOf(){
+var z=%_ArgumentsLength();
+var A=this;
+var y=%IsConstructor(A)?new A(z):[];
+for(var B=0;B<z;B++){
+AddArrayElement(A,y,B,%_Arguments(B));
+}
+y.length=z;
+return y;
+}
+%AddNamedProperty(i.prototype,"constructor",i,
+2);
+var bS={
+__proto__:null,
+copyWithin:true,
+entries:true,
+fill:true,
+find:true,
+findIndex:true,
+keys:true,
+};
+%AddNamedProperty(i.prototype,w,bS,
+2|1);
+%FunctionSetLength(ArrayFrom,1);
+b.InstallFunctions(i,2,[
+"from",ArrayFrom,
+"of",ArrayOf
+]);
+var bT=%SpecialArrayFunctions();
+var bU=function(bV,bW,N){
+var bt=bW;
+if(bT.hasOwnProperty(bV)){
+bt=bT[bV];
+}
+if(!(N===(void 0))){
+%FunctionSetLength(bt,N);
+}
+return bt;
+};
+b.InstallFunctions(i.prototype,2,[
+"toString",bU("toString",ArrayToString),
+"toLocaleString",bU("toLocaleString",ArrayToLocaleString),
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush,1),
+"reverse",bU("reverse",ArrayReverse),
+"shift",bU("shift",ArrayShift),
+"unshift",bU("unshift",ArrayUnshift,1),
+"slice",bU("slice",ArraySlice,2),
+"splice",bU("splice",ArraySplice,2),
+"sort",bU("sort",ArraySort),
+"filter",bU("filter",ArrayFilter,1),
+"forEach",bU("forEach",ArrayForEach,1),
+"some",bU("some",ArraySome,1),
+"every",bU("every",ArrayEvery,1),
+"map",bU("map",ArrayMap,1),
+"indexOf",bU("indexOf",ArrayIndexOf,1),
+"lastIndexOf",bU("lastIndexOf",ArrayLastIndexOf,1),
+"reduce",bU("reduce",ArrayReduce,1),
+"reduceRight",bU("reduceRight",ArrayReduceRight,1),
+"copyWithin",bU("copyWithin",ArrayCopyWithin,2),
+"find",bU("find",ArrayFind,1),
+"findIndex",bU("findIndex",ArrayFindIndex,1),
+"fill",bU("fill",ArrayFill,1),
+"includes",bU("includes",ArrayIncludes,1),
+]);
+%FinishArrayPrototypeSetup(i.prototype);
+b.SetUpLockedPrototype(j,i(),[
+"indexOf",bU("indexOf",ArrayIndexOf),
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush),
+"shift",bU("shift",ArrayShift),
+"sort",bU("sort",ArraySort),
+"splice",bU("splice",ArraySplice)
+]);
+b.SetUpLockedPrototype(k,i(),[
+"join",bU("join",ArrayJoin),
+"pop",bU("pop",ArrayPop),
+"push",bU("push",ArrayPush),
+"shift",bU("shift",ArrayShift)
+]);
+b.SetUpLockedPrototype(c.InternalPackedArray,i(),[
+"push",bU("push",ArrayPush),
+"pop",bU("pop",ArrayPop),
+"shift",bU("shift",ArrayShift),
+"unshift",bU("unshift",ArrayUnshift),
+"splice",bU("splice",ArraySplice),
+"slice",bU("slice",ArraySlice)
+]);
+b.Export(function(aO){
+aO.ArrayFrom=ArrayFrom;
+aO.ArrayIndexOf=ArrayIndexOf;
+aO.ArrayJoin=ArrayJoin;
+aO.ArrayPush=ArrayPush;
+aO.ArrayToString=ArrayToString;
+aO.InnerArrayCopyWithin=InnerArrayCopyWithin;
+aO.InnerArrayEvery=InnerArrayEvery;
+aO.InnerArrayFill=InnerArrayFill;
+aO.InnerArrayFilter=InnerArrayFilter;
+aO.InnerArrayFind=InnerArrayFind;
+aO.InnerArrayFindIndex=InnerArrayFindIndex;
+aO.InnerArrayForEach=InnerArrayForEach;
+aO.InnerArrayIncludes=InnerArrayIncludes;
+aO.InnerArrayIndexOf=InnerArrayIndexOf;
+aO.InnerArrayJoin=InnerArrayJoin;
+aO.InnerArrayLastIndexOf=InnerArrayLastIndexOf;
+aO.InnerArrayReduce=InnerArrayReduce;
+aO.InnerArrayReduceRight=InnerArrayReduceRight;
+aO.InnerArraySome=InnerArraySome;
+aO.InnerArraySort=InnerArraySort;
+aO.InnerArrayToLocaleString=InnerArrayToLocaleString;
+aO.PackedArrayReverse=PackedArrayReverse;
+});
+%InstallToContext([
+"array_pop",ArrayPop,
+"array_push",ArrayPush,
+"array_shift",ArrayShift,
+"array_splice",ArraySplice,
+"array_slice",ArraySlice,
+"array_unshift",ArrayUnshift,
+]);
+});
+
+string:

+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.RegExp;
+var f=a.String;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j;
+var k;
+var l;
+var m=b.ImportNow("match_symbol");
+var n;
+var o;
+var p;
+var q=b.ImportNow("search_symbol");
+var r=b.ImportNow("split_symbol");
+b.Import(function(s){
+c=s.ArrayIndexOf;
+d=s.ArrayJoin;
+i=s.MakeRangeError;
+j=s.MakeTypeError;
+k=s.MathMax;
+l=s.MathMin;
+n=s.RegExpExec;
+o=s.RegExpExecNoTests;
+p=s.RegExpLastMatchInfo;
+});
+function StringToString(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw j(65,'String.prototype.toString');
+}
+return %_ValueOf(this);
+}
+function StringValueOf(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw j(65,'String.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function StringCharAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.charAt");
+var u=%_StringCharAt(this,t);
+if(%_IsSmi(u)){
+u=%_StringCharAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringCharCodeAtJS(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.charCodeAt");
+var u=%_StringCharCodeAt(this,t);
+if(!%_IsSmi(u)){
+u=%_StringCharCodeAt((%_ToString(this)),(%_ToInteger(t)));
+}
+return u;
+}
+function StringConcat(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.concat");
+var w=%_ArgumentsLength();
+var x=(%_ToString(this));
+if(w===1){
+return x+(%_ToString(v));
+}
+var y=new g(w+1);
+y[0]=x;
+for(var z=0;z<w;z++){
+var A=%_Arguments(z);
+y[z+1]=(%_ToString(A));
+}
+return %StringBuilderConcat(y,w+1,"");
+}
+function StringIndexOfJS(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.indexOf");
+var C=(%_ToString(this));
+B=(%_ToString(B));
+var D=0;
+if(%_ArgumentsLength()>1){
+D=%_Arguments(1);
+D=(%_ToInteger(D));
+if(D<0)D=0;
+if(D>C.length)D=C.length;
+}
+return %StringIndexOf(C,B,D);
+}
+function StringLastIndexOfJS(E){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.lastIndexOf");
+var F=(%_ToString(this));
+var G=F.length;
+var E=(%_ToString(E));
+var H=E.length;
+var D=G-H;
+if(%_ArgumentsLength()>1){
+var I=(%_ToNumber(%_Arguments(1)));
+if(!(!%_IsSmi(%IS_VAR(I))&&!(I==I))){
+I=(%_ToInteger(I));
+if(I<0){
+I=0;
+}
+if(I+H<G){
+D=I;
+}
+}
+}
+if(D<0){
+return-1;
+}
+return %StringLastIndexOf(F,E,D);
+}
+function StringLocaleCompareJS(v){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.localeCompare");
+return %StringLocaleCompare((%_ToString(this)),(%_ToString(v)));
+}
+function StringMatchJS(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.match");
+if(!(B==null)){
+var J=B[m];
+if(!(J===(void 0))){
+return %_Call(J,B,this);
+}
+}
+var C=(%_ToString(this));
+var K=new e(B);
+return o(K,C,0);
+}
+function StringNormalizeJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.normalize");
+var L=(%_ToString(this));
+var M=%_Arguments(0);
+var N=(M===(void 0))?'NFC':(%_ToString(M));
+var O=['NFC','NFD','NFKC','NFKD'];
+var P=%_Call(c,O,N);
+if(P===-1){
+throw i(184,
+%_Call(d,O,', '));
+}
+return L;
+}
+var Q=[2,"","",-1,-1];
+function StringReplace(R,S){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.replace");
+var C=(%_ToString(this));
+if((%_IsRegExp(R))){
+if(!(typeof(S)==='function')){
+S=(%_ToString(S));
+if(!(%_RegExpFlags(R)&1)){
+var T=n(R,C,0);
+if(T==null){
+R.lastIndex=0
+return C;
+}
+if(S.length==0){
+return %_SubString(C,0,T[3])+
+%_SubString(C,T[4],C.length)
+}
+return ExpandReplacement(S,C,p,
+%_SubString(C,0,T[3]))+
+%_SubString(C,T[4],C.length);
+}
+R.lastIndex=0;
+return %StringReplaceGlobalRegExpWithString(
+C,R,S,p);
+}
+if((%_RegExpFlags(R)&1)){
+return StringReplaceGlobalRegExpWithFunction(C,R,S);
+}
+return StringReplaceNonGlobalRegExpWithFunction(C,R,S);
+}
+R=(%_ToString(R));
+if(R.length==1&&
+C.length>0xFF&&
+(typeof(S)==='string')&&
+%StringIndexOf(S,'$',0)<0){
+return %StringReplaceOneCharWithString(C,R,S);
+}
+var U=%StringIndexOf(C,R,0);
+if(U<0)return C;
+var V=U+R.length;
+var u=%_SubString(C,0,U);
+if((typeof(S)==='function')){
+u+=S(R,U,C);
+}else{
+Q[3]=U;
+Q[4]=V;
+u=ExpandReplacement((%_ToString(S)),
+C,
+Q,
+u);
+}
+return u+%_SubString(C,V,C.length);
+}
+function ExpandReplacement(W,C,X,u){
+var Y=W.length;
+var Z=%StringIndexOf(W,'$',0);
+if(Z<0){
+if(Y>0)u+=W;
+return u;
+}
+if(Z>0)u+=%_SubString(W,0,Z);
+while(true){
+var aa='$';
+var I=Z+1;
+if(I<Y){
+var ab=%_StringCharCodeAt(W,I);
+if(ab==36){
+++I;
+u+='$';
+}else if(ab==38){
+++I;
+u+=
+%_SubString(C,X[3],X[4]);
+}else if(ab==96){
+++I;
+u+=%_SubString(C,0,X[3]);
+}else if(ab==39){
+++I;
+u+=%_SubString(C,X[4],C.length);
+}else if(ab>=48&&ab<=57){
+var ac=(ab-48)<<1;
+var ad=1;
+var ae=((X)[0]);
+if(I+1<W.length){
+var Z=%_StringCharCodeAt(W,I+1);
+if(Z>=48&&Z<=57){
+var af=ac*10+((Z-48)<<1);
+if(af<ae){
+ac=af;
+ad=2;
+}
+}
+}
+if(ac!=0&&ac<ae){
+var U=X[(3+(ac))];
+if(U>=0){
+u+=
+%_SubString(C,U,X[(3+(ac+1))]);
+}
+I+=ad;
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+}else{
+u+='$';
+}
+Z=%StringIndexOf(W,'$',I);
+if(Z<0){
+if(I<Y){
+u+=%_SubString(W,I,Y);
+}
+return u;
+}
+if(Z>I){
+u+=%_SubString(W,I,Z);
+}
+}
+return u;
+}
+function CaptureString(W,ag,D){
+var ah=D<<1;
+var U=ag[(3+(ah))];
+if(U<0)return;
+var V=ag[(3+(ah+1))];
+return %_SubString(W,U,V);
+}
+var ai=new g(4);
+function StringReplaceGlobalRegExpWithFunction(C,K,S){
+var aj=ai;
+if(aj){
+ai=null;
+}else{
+aj=new g(16);
+}
+var ak=%RegExpExecMultiple(K,
+C,
+p,
+aj);
+K.lastIndex=0;
+if((ak===null)){
+ai=aj;
+return C;
+}
+var w=ak.length;
+if(((p)[0])==2){
+var al=0;
+for(var z=0;z<w;z++){
+var am=ak[z];
+if(%_IsSmi(am)){
+if(am>0){
+al=(am>>11)+(am&0x7ff);
+}else{
+al=ak[++z]-am;
+}
+}else{
+var an=S(am,al,C);
+ak[z]=(%_ToString(an));
+al+=am.length;
+}
+}
+}else{
+for(var z=0;z<w;z++){
+var am=ak[z];
+if(!%_IsSmi(am)){
+var an=%Apply(S,(void 0),am,0,am.length);
+ak[z]=(%_ToString(an));
+}
+}
+}
+var u=%StringBuilderConcat(ak,w,C);
+aj.length=0;
+ai=aj;
+return u;
+}
+function StringReplaceNonGlobalRegExpWithFunction(C,K,S){
+var X=n(K,C,0);
+if((X===null)){
+K.lastIndex=0;
+return C;
+}
+var D=X[3];
+var u=%_SubString(C,0,D);
+var ao=X[4];
+var ap=((X)[0])>>1;
+var aq;
+if(ap==1){
+var L=%_SubString(C,D,ao);
+aq=S(L,D,C);
+}else{
+var ar=new g(ap+2);
+for(var as=0;as<ap;as++){
+ar[as]=CaptureString(C,X,as);
+}
+ar[as]=D;
+ar[as+1]=C;
+aq=%Apply(S,(void 0),ar,0,as+2);
+}
+u+=aq;
+return u+%_SubString(C,ao,C.length);
+}
+function StringSearch(B){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.search");
+if(!(B==null)){
+var at=B[q];
+if(!(at===(void 0))){
+return %_Call(at,B,this);
+}
+}
+var C=(%_ToString(this));
+var K=new e(B);
+return %_Call(K[q],K,C);
+}
+function StringSlice(U,V){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.slice");
+var L=(%_ToString(this));
+var au=L.length;
+var av=(%_ToInteger(U));
+var aw=au;
+if(!(V===(void 0))){
+aw=(%_ToInteger(V));
+}
+if(av<0){
+av+=au;
+if(av<0){
+av=0;
+}
+}else{
+if(av>au){
+return'';
+}
+}
+if(aw<0){
+aw+=au;
+if(aw<0){
+return'';
+}
+}else{
+if(aw>au){
+aw=au;
+}
+}
+if(aw<=av){
+return'';
+}
+return %_SubString(L,av,aw);
+}
+function StringSplitJS(ax,ay){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.split");
+if(!(ax==null)){
+var az=ax[r];
+if(!(az===(void 0))){
+return %_Call(az,ax,this,ay);
+}
+}
+var C=(%_ToString(this));
+ay=((ay===(void 0)))?4294967295:((ay)>>>0);
+var Y=C.length;
+var aA=(%_ToString(ax));
+if(ay===0)return[];
+if((ax===(void 0)))return[C];
+var aB=aA.length;
+if(aB===0)return %StringToArray(C,ay);
+return %StringSplit(C,aA,ay);
+}
+function StringSubstring(U,V){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.subString");
+var L=(%_ToString(this));
+var au=L.length;
+var av=(%_ToInteger(U));
+if(av<0){
+av=0;
+}else if(av>au){
+av=au;
+}
+var aw=au;
+if(!(V===(void 0))){
+aw=(%_ToInteger(V));
+if(aw>au){
+aw=au;
+}else{
+if(aw<0)aw=0;
+if(av>aw){
+var aC=aw;
+aw=av;
+av=aC;
+}
+}
+}
+return %_SubString(L,av,aw);
+}
+function StringSubstr(U,aD){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.substr");
+var L=(%_ToString(this));
+var w;
+if((aD===(void 0))){
+w=L.length;
+}else{
+w=(%_ToInteger(aD));
+if(w<=0)return'';
+}
+if((U===(void 0))){
+U=0;
+}else{
+U=(%_ToInteger(U));
+if(U>=L.length)return'';
+if(U<0){
+U+=L.length;
+if(U<0)U=0;
+}
+}
+var V=U+w;
+if(V>L.length)V=L.length;
+return %_SubString(L,U,V);
+}
+function StringToLowerCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToLocaleLowerCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLocaleLowerCase");
+return %StringToLowerCase((%_ToString(this)));
+}
+function StringToUpperCaseJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringToLocaleUpperCase(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.toLocaleUpperCase");
+return %StringToUpperCase((%_ToString(this)));
+}
+function StringTrimJS(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trim");
+return %StringTrim((%_ToString(this)),true,true);
+}
+function StringTrimLeft(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trimLeft");
+return %StringTrim((%_ToString(this)),true,false);
+}
+function StringTrimRight(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.trimRight");
+return %StringTrim((%_ToString(this)),false,true);
+}
+function StringFromCharCode(aE){
+var aD=%_ArgumentsLength();
+if(aD==1)return %_StringCharFromCode(aE&0xffff);
+var aF=%NewString(aD,true);
+var z;
+for(z=0;z<aD;z++){
+aE=%_Arguments(z)&0xffff;
+if(aE>0xff)break;
+%_OneByteSeqStringSetChar(z,aE,aF);
+}
+if(z==aD)return aF;
+aF=%TruncateString(aF,z);
+var aG=%NewString(aD-z,false);
+%_TwoByteSeqStringSetChar(0,aE,aG);
+z++;
+for(var as=1;z<aD;z++,as++){
+aE=%_Arguments(z)&0xffff;
+%_TwoByteSeqStringSetChar(as,aE,aG);
+}
+return aF+aG;
+}
+function HtmlEscape(aH){
+return %_Call(StringReplace,(%_ToString(aH)),/"/g,"&quot;");
+}
+function StringAnchor(aI){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.anchor");
+return"<a name=\""+HtmlEscape(aI)+"\">"+(%_ToString(this))+
+"</a>";
+}
+function StringBig(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.big");
+return"<big>"+(%_ToString(this))+"</big>";
+}
+function StringBlink(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.blink");
+return"<blink>"+(%_ToString(this))+"</blink>";
+}
+function StringBold(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.bold");
+return"<b>"+(%_ToString(this))+"</b>";
+}
+function StringFixed(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fixed");
+return"<tt>"+(%_ToString(this))+"</tt>";
+}
+function StringFontcolor(aJ){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fontcolor");
+return"<font color=\""+HtmlEscape(aJ)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringFontsize(aK){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.fontsize");
+return"<font size=\""+HtmlEscape(aK)+"\">"+(%_ToString(this))+
+"</font>";
+}
+function StringItalics(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.italics");
+return"<i>"+(%_ToString(this))+"</i>";
+}
+function StringLink(L){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.link");
+return"<a href=\""+HtmlEscape(L)+"\">"+(%_ToString(this))+"</a>";
+}
+function StringSmall(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.small");
+return"<small>"+(%_ToString(this))+"</small>";
+}
+function StringStrike(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.strike");
+return"<strike>"+(%_ToString(this))+"</strike>";
+}
+function StringSub(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.sub");
+return"<sub>"+(%_ToString(this))+"</sub>";
+}
+function StringSup(){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.sup");
+return"<sup>"+(%_ToString(this))+"</sup>";
+}
+function StringRepeat(aL){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.repeat");
+var L=(%_ToString(this));
+var aD=(%_ToInteger(aL));
+if(aD<0||aD===(1/0))throw i(168);
+if(L.length===0)return"";
+if(aD>%_MaxSmi())throw i(168);
+var aM="";
+while(true){
+if(aD&1)aM+=L;
+aD>>=1;
+if(aD===0)return aM;
+L+=L;
+}
+}
+function StringStartsWith(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.startsWith");
+var L=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.startsWith");
+}
+var aO=(%_ToString(aN));
+var t=0;
+if(%_ArgumentsLength()>1){
+var aP=%_Arguments(1);
+if(!(aP===(void 0))){
+t=(%_ToInteger(aP));
+}
+}
+var au=L.length;
+var U=l(k(t,0),au);
+var aQ=aO.length;
+if(aQ+U>au){
+return false;
+}
+return %_SubString(L,U,U+aQ)===aO;
+}
+function StringEndsWith(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.endsWith");
+var L=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.endsWith");
+}
+var aO=(%_ToString(aN));
+var au=L.length;
+var t=au;
+if(%_ArgumentsLength()>1){
+var aP=%_Arguments(1);
+if(!(aP===(void 0))){
+t=(%_ToInteger(aP));
+}
+}
+var V=l(k(t,0),au);
+var aQ=aO.length;
+var U=V-aQ;
+if(U<0){
+return false;
+}
+return %_SubString(L,U,U+aQ)===aO;
+}
+function StringIncludes(aN){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.includes");
+var W=(%_ToString(this));
+if((%_IsRegExp(aN))){
+throw j(38,"String.prototype.includes");
+}
+aN=(%_ToString(aN));
+var t=0;
+if(%_ArgumentsLength()>1){
+t=%_Arguments(1);
+t=(%_ToInteger(t));
+}
+var aR=W.length;
+if(t<0)t=0;
+if(t>aR)t=aR;
+var aS=aN.length;
+if(aS+t>aR){
+return false;
+}
+return %StringIndexOf(W,aN,t)!==-1;
+}
+function StringCodePointAt(t){
+if((%IS_VAR(this)===null)||(this===(void 0)))throw j(17,"String.prototype.codePointAt");
+var W=(%_ToString(this));
+var aK=W.length;
+t=(%_ToInteger(t));
+if(t<0||t>=aK){
+return(void 0);
+}
+var aT=%_StringCharCodeAt(W,t);
+if(aT<0xD800||aT>0xDBFF||t+1==aK){
+return aT;
+}
+var aU=%_StringCharCodeAt(W,t+1);
+if(aU<0xDC00||aU>0xDFFF){
+return aT;
+}
+return(aT-0xD800)*0x400+aU+0x2400;
+}
+function StringFromCodePoint(aV){
+var aE;
+var Y=%_ArgumentsLength();
+var D;
+var u="";
+for(D=0;D<Y;D++){
+aE=%_Arguments(D);
+if(!%_IsSmi(aE)){
+aE=(%_ToNumber(aE));
+}
+if(aE<0||aE>0x10FFFF||aE!==(%_ToInteger(aE))){
+throw i(167,aE);
+}
+if(aE<=0xFFFF){
+u+=%_StringCharFromCode(aE);
+}else{
+aE-=0x10000;
+u+=%_StringCharFromCode((aE>>>10)&0x3FF|0xD800);
+u+=%_StringCharFromCode(aE&0x3FF|0xDC00);
+}
+}
+return u;
+}
+function StringRaw(aW){
+var aX=%_ArgumentsLength();
+var aY=(%_ToObject(aW));
+var aZ=(%_ToObject(aY.raw));
+var ba=(%_ToLength(aZ.length));
+if(ba<=0)return"";
+var u=(%_ToString(aZ[0]));
+for(var z=1;z<ba;++z){
+if(z<aX){
+u+=(%_ToString(%_Arguments(z)));
+}
+u+=(%_ToString(aZ[z]));
+}
+return u;
+}
+%FunctionSetPrototype(f,new f());
+%AddNamedProperty(
+f.prototype,"constructor",f,2);
+b.InstallFunctions(f,2,[
+"fromCharCode",StringFromCharCode,
+"fromCodePoint",StringFromCodePoint,
+"raw",StringRaw
+]);
+b.InstallFunctions(f.prototype,2,[
+"valueOf",StringValueOf,
+"toString",StringToString,
+"charAt",StringCharAtJS,
+"charCodeAt",StringCharCodeAtJS,
+"codePointAt",StringCodePointAt,
+"concat",StringConcat,
+"endsWith",StringEndsWith,
+"includes",StringIncludes,
+"indexOf",StringIndexOfJS,
+"lastIndexOf",StringLastIndexOfJS,
+"localeCompare",StringLocaleCompareJS,
+"match",StringMatchJS,
+"normalize",StringNormalizeJS,
+"repeat",StringRepeat,
+"replace",StringReplace,
+"search",StringSearch,
+"slice",StringSlice,
+"split",StringSplitJS,
+"substring",StringSubstring,
+"substr",StringSubstr,
+"startsWith",StringStartsWith,
+"toLowerCase",StringToLowerCaseJS,
+"toLocaleLowerCase",StringToLocaleLowerCase,
+"toUpperCase",StringToUpperCaseJS,
+"toLocaleUpperCase",StringToLocaleUpperCase,
+"trim",StringTrimJS,
+"trimLeft",StringTrimLeft,
+"trimRight",StringTrimRight,
+"link",StringLink,
+"anchor",StringAnchor,
+"fontcolor",StringFontcolor,
+"fontsize",StringFontsize,
+"big",StringBig,
+"blink",StringBlink,
+"bold",StringBold,
+"fixed",StringFixed,
+"italics",StringItalics,
+"small",StringSmall,
+"strike",StringStrike,
+"sub",StringSub,
+"sup",StringSup
+]);
+b.Export(function(bb){
+bb.StringCharAt=StringCharAtJS;
+bb.StringIndexOf=StringIndexOfJS;
+bb.StringLastIndexOf=StringLastIndexOfJS;
+bb.StringMatch=StringMatchJS;
+bb.StringReplace=StringReplace;
+bb.StringSlice=StringSlice;
+bb.StringSplit=StringSplitJS;
+bb.StringSubstr=StringSubstr;
+bb.StringSubstring=StringSubstring;
+});
+})
+
+uri1U
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=a.Array;
+var e=b.InternalArray;
+var f;
+b.Import(function(g){
+f=g.MakeURIError;
+});
+function HexValueOf(h){
+if(h>=48&&h<=57)return h-48;
+if(h>=65&&h<=70)return h-55;
+if(h>=97&&h<=102)return h-87;
+return-1;
+}
+function isAlphaNumeric(i){
+if(97<=i&&i<=122)return true;
+if(65<=i&&i<=90)return true;
+if(48<=i&&i<=57)return true;
+return false;
+}
+var j=0;
+function URIAddEncodedOctetToBuffer(k,l,m){
+l[m++]=37;
+l[m++]=j[k>>4];
+l[m++]=j[k&0x0F];
+return m;
+}
+function URIEncodeOctets(n,l,m){
+if(j===0){
+j=[48,49,50,51,52,53,54,55,56,57,
+65,66,67,68,69,70];
+}
+m=URIAddEncodedOctetToBuffer(n[0],l,m);
+if(n[1])m=URIAddEncodedOctetToBuffer(n[1],l,m);
+if(n[2])m=URIAddEncodedOctetToBuffer(n[2],l,m);
+if(n[3])m=URIAddEncodedOctetToBuffer(n[3],l,m);
+return m;
+}
+function URIEncodeSingle(i,l,m){
+var o=(i>>12)&0xF;
+var p=(i>>6)&63;
+var q=i&63;
+var n=new d(3);
+if(i<=0x007F){
+n[0]=i;
+}else if(i<=0x07FF){
+n[0]=p+192;
+n[1]=q+128;
+}else{
+n[0]=o+224;
+n[1]=p+128;
+n[2]=q+128;
+}
+return URIEncodeOctets(n,l,m);
+}
+function URIEncodePair(r,s,l,m){
+var t=((r>>6)&0xF)+1;
+var u=(r>>2)&0xF;
+var o=r&3;
+var p=(s>>6)&0xF;
+var q=s&63;
+var n=new d(4);
+n[0]=(t>>2)+240;
+n[1]=(((t&3)<<4)|u)+128;
+n[2]=((o<<4)|p)+128;
+n[3]=q+128;
+return URIEncodeOctets(n,l,m);
+}
+function URIHexCharsToCharCode(v,w){
+var x=HexValueOf(v);
+var y=HexValueOf(w);
+if(x==-1||y==-1)throw f();
+return(x<<4)|y;
+}
+function URIDecodeOctets(n,l,m){
+var z;
+var A=n[0];
+if(A<0x80){
+z=A;
+}else if(A<0xc2){
+throw f();
+}else{
+var B=n[1];
+if(A<0xe0){
+var C=A&0x1f;
+if((B<0x80)||(B>0xbf))throw f();
+var D=B&0x3f;
+z=(C<<6)+D;
+if(z<0x80||z>0x7ff)throw f();
+}else{
+var E=n[2];
+if(A<0xf0){
+var C=A&0x0f;
+if((B<0x80)||(B>0xbf))throw f();
+var D=B&0x3f;
+if((E<0x80)||(E>0xbf))throw f();
+var F=E&0x3f;
+z=(C<<12)+(D<<6)+F;
+if((z<0x800)||(z>0xffff))throw f();
+}else{
+var G=n[3];
+if(A<0xf8){
+var C=(A&0x07);
+if((B<0x80)||(B>0xbf))throw f();
+var D=(B&0x3f);
+if((E<0x80)||(E>0xbf)){
+throw f();
+}
+var F=(E&0x3f);
+if((G<0x80)||(G>0xbf))throw f();
+var H=(G&0x3f);
+z=(C<<18)+(D<<12)+(F<<6)+H;
+if((z<0x10000)||(z>0x10ffff))throw f();
+}else{
+throw f();
+}
+}
+}
+}
+if(0xD800<=z&&z<=0xDFFF)throw f();
+if(z<0x10000){
+%_TwoByteSeqStringSetChar(m++,z,l);
+}else{
+%_TwoByteSeqStringSetChar(m++,(z>>10)+0xd7c0,l);
+%_TwoByteSeqStringSetChar(m++,(z&0x3ff)+0xdc00,l);
+}
+return m;
+}
+function Encode(I,J){
+I=(%_ToString(I));
+var K=I.length;
+var L=new e(K);
+var m=0;
+for(var M=0;M<K;M++){
+var r=%_StringCharCodeAt(I,M);
+if(J(r)){
+L[m++]=r;
+}else{
+if(r>=0xDC00&&r<=0xDFFF)throw f();
+if(r<0xD800||r>0xDBFF){
+m=URIEncodeSingle(r,L,m);
+}else{
+M++;
+if(M==K)throw f();
+var s=%_StringCharCodeAt(I,M);
+if(s<0xDC00||s>0xDFFF)throw f();
+m=URIEncodePair(r,s,L,m);
+}
+}
+}
+var l=%NewString(L.length,true);
+for(var N=0;N<L.length;N++){
+%_OneByteSeqStringSetChar(N,L[N],l);
+}
+return l;
+}
+function Decode(I,O){
+I=(%_ToString(I));
+var K=I.length;
+var P=%NewString(K,true);
+var m=0;
+var M=0;
+for(;M<K;M++){
+var h=%_StringCharCodeAt(I,M);
+if(h==37){
+if(M+2>=K)throw f();
+var i=URIHexCharsToCharCode(%_StringCharCodeAt(I,M+1),
+%_StringCharCodeAt(I,M+2));
+if(i>>7)break;
+if(O(i)){
+%_OneByteSeqStringSetChar(m++,37,P);
+%_OneByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M+1),
+P);
+%_OneByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M+2),
+P);
+}else{
+%_OneByteSeqStringSetChar(m++,i,P);
+}
+M+=2;
+}else{
+if(h>0x7f)break;
+%_OneByteSeqStringSetChar(m++,h,P);
+}
+}
+P=%TruncateString(P,m);
+if(M==K)return P;
+var Q=%NewString(K-M,false);
+m=0;
+for(;M<K;M++){
+var h=%_StringCharCodeAt(I,M);
+if(h==37){
+if(M+2>=K)throw f();
+var i=URIHexCharsToCharCode(%_StringCharCodeAt(I,++M),
+%_StringCharCodeAt(I,++M));
+if(i>>7){
+var R=0;
+while(((i<<++R)&0x80)!=0){}
+if(R==1||R>4)throw f();
+var n=new d(R);
+n[0]=i;
+if(M+3*(R-1)>=K)throw f();
+for(var N=1;N<R;N++){
+if(I[++M]!='%')throw f();
+n[N]=URIHexCharsToCharCode(%_StringCharCodeAt(I,++M),
+%_StringCharCodeAt(I,++M));
+}
+m=URIDecodeOctets(n,Q,m);
+}else if(O(i)){
+%_TwoByteSeqStringSetChar(m++,37,Q);
+%_TwoByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M-1),
+Q);
+%_TwoByteSeqStringSetChar(m++,%_StringCharCodeAt(I,M),
+Q);
+}else{
+%_TwoByteSeqStringSetChar(m++,i,Q);
+}
+}else{
+%_TwoByteSeqStringSetChar(m++,h,Q);
+}
+}
+Q=%TruncateString(Q,m);
+return P+Q;
+}
+function URIEscapeJS(S){
+return %URIEscape(S);
+}
+function URIUnescapeJS(S){
+return %URIUnescape(S);
+}
+function URIDecode(I){
+var T=function(i){
+if(35<=i&&i<=36)return true;
+if(i==38)return true;
+if(43<=i&&i<=44)return true;
+if(i==47)return true;
+if(58<=i&&i<=59)return true;
+if(i==61)return true;
+if(63<=i&&i<=64)return true;
+return false;
+};
+return Decode(I,T);
+}
+function URIDecodeComponent(U){
+var T=function(i){return false;};
+return Decode(U,T);
+}
+function URIEncode(I){
+var V=function(i){
+if(isAlphaNumeric(i))return true;
+if(i==33)return true;
+if(35<=i&&i<=36)return true;
+if(38<=i&&i<=47)return true;
+if(58<=i&&i<=59)return true;
+if(i==61)return true;
+if(63<=i&&i<=64)return true;
+if(i==95)return true;
+if(i==126)return true;
+return false;
+};
+return Encode(I,V);
+}
+function URIEncodeComponent(U){
+var V=function(i){
+if(isAlphaNumeric(i))return true;
+if(i==33)return true;
+if(39<=i&&i<=42)return true;
+if(45<=i&&i<=46)return true;
+if(i==95)return true;
+if(i==126)return true;
+return false;
+};
+return Encode(U,V);
+}
+b.InstallFunctions(a,2,[
+"escape",URIEscapeJS,
+"unescape",URIUnescapeJS,
+"decodeURI",URIDecode,
+"decodeURIComponent",URIDecodeComponent,
+"encodeURI",URIEncode,
+"encodeURIComponent",URIEncodeComponent
+]);
+})
+
+mathµJ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e=a.Object;
+var f=b.InternalArray;
+var g=%GetRootNaN();
+var h=64;
+var i=(void 0);
+var j=b.ImportNow("to_string_tag_symbol");
+function MathAbs(k){
+k=+k;
+return(k>0)?k:0-k;
+}
+function MathAcosJS(k){
+return %_MathAcos(+k);
+}
+function MathAsinJS(k){
+return %_MathAsin(+k);
+}
+function MathAtanJS(k){
+return %_MathAtan(+k);
+}
+function MathAtan2JS(l,k){
+l=+l;
+k=+k;
+return %_MathAtan2(l,k);
+}
+function MathCeil(k){
+return-%_MathFloor(-k);
+}
+function MathExp(k){
+return %MathExpRT((%_ToNumber(k)));
+}
+function MathFloorJS(k){
+return %_MathFloor(+k);
+}
+function MathLog(k){
+return %_MathLogRT((%_ToNumber(k)));
+}
+function MathMax(m,n){
+var o=%_ArgumentsLength();
+if(o==2){
+m=(%_ToNumber(m));
+n=(%_ToNumber(n));
+if(n>m)return n;
+if(m>n)return m;
+if(m==n){
+return(m===0&&%_IsMinusZero(m))?n:m;
+}
+return g;
+}
+var p=-(1/0);
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if((!%_IsSmi(%IS_VAR(r))&&!(r==r))||r>p||(p===0&&r===0&&%_IsMinusZero(p))){
+p=r;
+}
+}
+return p;
+}
+function MathMin(m,n){
+var o=%_ArgumentsLength();
+if(o==2){
+m=(%_ToNumber(m));
+n=(%_ToNumber(n));
+if(n>m)return m;
+if(m>n)return n;
+if(m==n){
+return(m===0&&%_IsMinusZero(m))?m:n;
+}
+return g;
+}
+var p=(1/0);
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if((!%_IsSmi(%IS_VAR(r))&&!(r==r))||r<p||(p===0&&r===0&&%_IsMinusZero(r))){
+p=r;
+}
+}
+return p;
+}
+function MathPowJS(k,l){
+return %_MathPow((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathRandom(){
+if(h>=64){
+i=%GenerateRandomNumbers(i);
+h=2;
+}
+return i[h++];
+}
+function MathRandomRaw(){
+if(h>=64){
+i=%GenerateRandomNumbers(i);
+h=2;
+}
+return %_DoubleLo(i[h++])&0x3FFFFFFF;
+}
+function MathRound(k){
+return %RoundNumber((%_ToNumber(k)));
+}
+function MathSqrtJS(k){
+return %_MathSqrt(+k);
+}
+function MathImul(k,l){
+return %NumberImul((%_ToNumber(k)),(%_ToNumber(l)));
+}
+function MathSign(k){
+k=+k;
+if(k>0)return 1;
+if(k<0)return-1;
+return k;
+}
+function MathTrunc(k){
+k=+k;
+if(k>0)return %_MathFloor(k);
+if(k<0)return-%_MathFloor(-k);
+return k;
+}
+function MathAsinh(k){
+k=(%_ToNumber(k));
+if(k===0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+if(k>0)return MathLog(k+%_MathSqrt(k*k+1));
+return-MathLog(-k+%_MathSqrt(k*k+1));
+}
+function MathAcosh(k){
+k=(%_ToNumber(k));
+if(k<1)return g;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return MathLog(k+%_MathSqrt(k+1)*%_MathSqrt(k-1));
+}
+function MathAtanh(k){
+k=(%_ToNumber(k));
+if(k===0)return k;
+if(!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return g;
+return 0.5*MathLog((1+k)/(1-k));
+}
+function MathHypot(k,l){
+var o=%_ArgumentsLength();
+var s=new f(o);
+var t=0;
+for(var q=0;q<o;q++){
+var r=%_Arguments(q);
+r=(%_ToNumber(r));
+if(r===(1/0)||r===-(1/0))return(1/0);
+r=MathAbs(r);
+if(r>t)t=r;
+s[q]=r;
+}
+if(t===0)t=1;
+var u=0;
+var v=0;
+for(var q=0;q<o;q++){
+var r=s[q]/t;
+var w=r*r-v;
+var x=u+w;
+v=(x-u)-w;
+u=x;
+}
+return %_MathSqrt(u)*t;
+}
+function MathFroundJS(k){
+return %MathFround((%_ToNumber(k)));
+}
+function MathClz32JS(k){
+return %_MathClz32(k>>>0);
+}
+function MathCbrt(k){
+k=(%_ToNumber(k));
+if(k==0||!(%_IsSmi(%IS_VAR(k))||((k==k)&&(k!=1/0)&&(k!=-1/0))))return k;
+return k>=0?CubeRoot(k):-CubeRoot(-k);
+}
+function CubeRoot(k){
+var y=MathFloorJS(%_DoubleHi(k)/3)+0x2A9F7893;
+var z=%_ConstructDouble(y|0,0);
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+z=(1.0/3.0)*(k/(z*z)+2*z);
+;
+return(1.0/3.0)*(k/(z*z)+2*z);
+;
+}
+%AddNamedProperty(d,j,"Math",1|2);
+b.InstallConstants(d,[
+"E",2.7182818284590452354,
+"LN10",2.302585092994046,
+"LN2",0.6931471805599453,
+"LOG2E",1.4426950408889634,
+"LOG10E",0.4342944819032518,
+"PI",3.1415926535897932,
+"SQRT1_2",0.7071067811865476,
+"SQRT2",1.4142135623730951
+]);
+b.InstallFunctions(d,2,[
+"random",MathRandom,
+"abs",MathAbs,
+"acos",MathAcosJS,
+"asin",MathAsinJS,
+"atan",MathAtanJS,
+"ceil",MathCeil,
+"exp",MathExp,
+"floor",MathFloorJS,
+"log",MathLog,
+"round",MathRound,
+"sqrt",MathSqrtJS,
+"atan2",MathAtan2JS,
+"pow",MathPowJS,
+"max",MathMax,
+"min",MathMin,
+"imul",MathImul,
+"sign",MathSign,
+"trunc",MathTrunc,
+"asinh",MathAsinh,
+"acosh",MathAcosh,
+"atanh",MathAtanh,
+"hypot",MathHypot,
+"fround",MathFroundJS,
+"clz32",MathClz32JS,
+"cbrt",MathCbrt
+]);
+%SetForceInlineFlag(MathAbs);
+%SetForceInlineFlag(MathAcosJS);
+%SetForceInlineFlag(MathAsinJS);
+%SetForceInlineFlag(MathAtanJS);
+%SetForceInlineFlag(MathAtan2JS);
+%SetForceInlineFlag(MathCeil);
+%SetForceInlineFlag(MathClz32JS);
+%SetForceInlineFlag(MathFloorJS);
+%SetForceInlineFlag(MathRandom);
+%SetForceInlineFlag(MathSign);
+%SetForceInlineFlag(MathSqrtJS);
+%SetForceInlineFlag(MathTrunc);
+b.Export(function(A){
+A.MathAbs=MathAbs;
+A.MathExp=MathExp;
+A.MathFloor=MathFloorJS;
+A.IntRandom=MathRandomRaw;
+A.MathMax=MathMax;
+A.MathMin=MathMin;
+});
+})
+
+fdlibmùÈ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Float64Array;
+var d=a.Math;
+var e;
+var f;
+var g=%GetRootNaN();
+var h;
+b.Import(function(i){
+e=i.MathAbs;
+f=i.MathExp;
+});
+b.CreateDoubleResultArray=function(a){
+h=new c(2);
+};
+function KernelTan(j,k,l){
+var m;
+var n;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x3e300000){
+if(((p|%_DoubleLo(j))|(l+1))==0){
+return 1/e(j);
+}else{
+if(l==1){
+return j;
+}else{
+var n=j+k;
+var m=%_ConstructDouble(%_DoubleHi(n),0);
+var q=k-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+var t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+}
+if(p>=0x3fe59428){
+if(j<0){
+j=-j;
+k=-k;
+}
+m=7.85398163397448278999e-01-j;
+n=3.06161699786838301793e-17-k;
+j=m+n;
+k=0;
+}
+m=j*j;
+n=m*m;
+var u=1.33333333333201242699e-01+n*(2.18694882948595424599e-02+n*(3.59207910759131235356e-03+
+n*(5.88041240820264096874e-04+n*(7.81794442939557092300e-05+n*-1.85586374855275456654e-05))));
+var q=m*(5.39682539762260521377e-02+n*(8.86323982359930005737e-03+n*(1.45620945432529025516e-03+
+n*(2.46463134818469906812e-04+n*(7.14072491382608190305e-05+n*2.59073051863633712884e-05)))));
+var t=m*j;
+u=k+m*(t*(u+q)+k);
+u=u+3.33333333333334091986e-01*t;
+n=j+u;
+if(p>=0x3fe59428){
+return(1-((o>>30)&2))*
+(l-2.0*(j-(n*n/(n+l)-u)));
+}
+if(l==1){
+return n;
+}else{
+m=%_ConstructDouble(%_DoubleHi(n),0);
+q=u-(m-j);
+var r=-1/n;
+var s=%_ConstructDouble(%_DoubleHi(r),0);
+t=1+s*m;
+return s+r*(t+s*q);
+}
+}
+function MathSinSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+var y=1-(v&2);
+if(v&1){
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}else{
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}
+}
+function MathCosSlow(j){
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+if(v&1){
+var y=(v&2)-1;
+var m=w*w;
+var q=m*w;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(w-((m*(0.5*x-q*u)-x)-q*-1.66666666666666324348e-01))*y;
+;
+}else{
+var y=1-(v&2);
+var p=%_DoubleHi(w)&0x7fffffff;
+var m=w*w;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-w*x)))*y;
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*w),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-w*x)))*y;
+}
+;
+}
+}
+function MathSin(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var m=j*j;
+var q=m*j;
+var u=8.33333333332248946124e-03+m*(-1.98412698298579493134e-04+m*(2.75573137070700676789e-06+m*(-2.50507602534068634195e-08+m*1.58969099521155010221e-10)));
+return(j-((m*(0.5*0-q*u)-0)-q*-1.66666666666666324348e-01));
+;
+}
+return+MathSinSlow(j);
+}
+function MathCos(j){
+j=+j;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+var p=%_DoubleHi(j)&0x7fffffff;
+var m=j*j;
+var u=m*(4.16666666666666019037e-02+m*(-1.38888888888741095749e-03+m*(2.48015872894767294178e-05+m*(-2.75573143513906633035e-07+m*(2.08757232129817482790e-09+m*-1.13596475577881948265e-11)))));
+if(p<0x3fd33333){
+return(1-(0.5*m-(m*u-j*0)));
+}else{
+var z;
+if(p>0x3fe90000){
+z=0.28125;
+}else{
+z=%_ConstructDouble(%_DoubleHi(0.25*j),0);
+}
+var A=0.5*m-z;
+return(1-z-(A-(m*u-j*0)));
+}
+;
+}
+return+MathCosSlow(j);
+}
+function MathTan(j){
+j=j*1;
+if((%_DoubleHi(j)&0x7fffffff)<=0x3fe921fb){
+return KernelTan(j,0,1);
+}
+var v,w,x;
+var o=%_DoubleHi(j);
+var p=o&0x7fffffff;
+if(p<0x4002d97c){
+if(o>0){
+var m=j-1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m-6.07710050650619224932e-11;
+x=(m-w)-6.07710050650619224932e-11;
+}else{
+m-=6.07710050630396597660e-11;
+w=m-2.02226624879595063154e-21;
+x=(m-w)-2.02226624879595063154e-21;
+}
+v=1;
+}else{
+var m=j+1.57079632673412561417;
+if(p!=0x3ff921fb){
+w=m+6.07710050650619224932e-11;
+x=(m-w)+6.07710050650619224932e-11;
+}else{
+m+=6.07710050630396597660e-11;
+w=m+2.02226624879595063154e-21;
+x=(m-w)+2.02226624879595063154e-21;
+}
+v=-1;
+}
+}else if(p<=0x413921fb){
+var s=e(j);
+v=(s*6.36619772367581382433e-01+0.5)|0;
+var u=s-v*1.57079632673412561417;
+var n=v*6.07710050650619224932e-11;
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x1000000){
+s=u;
+n=v*6.07710050630396597660e-11;
+u=s-n;
+n=v*2.02226624879595063154e-21-((s-u)-n);
+w=u-n;
+if(p-(%_DoubleHi(w)&0x7ff00000)>0x3100000){
+s=u;
+n=v*2.02226624871116645580e-21;
+u=s-n;
+n=v*8.47842766036889956997e-32-((s-u)-n);
+w=u-n;
+}
+}
+x=(u-w)-n;
+if(o<0){
+v=-v;
+w=-w;
+x=-x;
+}
+}else{
+v=%RemPiO2(j,h);
+w=h[0];
+x=h[1];
+}
+;
+return KernelTan(w,x,(v&1)?-1:1);
+}
+function MathLog1p(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var B=o&0x7fffffff;
+var C=1;
+var D=j;
+var E=1;
+var F=0;
+var G=j;
+if(o<0x3fda827a){
+if(B>=0x3ff00000){
+if(j===-1){
+return-(1/0);
+}else{
+return g;
+}
+}else if(B<0x3c900000){
+return j;
+}else if(B<0x3e200000){
+return j-j*j*0.5;
+}
+if((o>0)||(o<=-0x402D413D)){
+C=0;
+}
+}
+if(o>=0x7ff00000)return j;
+if(C!==0){
+if(o<0x43400000){
+G=1+j;
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+F=(C>0)?1-(G-j):j-(G-1);
+F=F/G;
+}else{
+E=%_DoubleHi(G);
+C=(E>>20)-1023;
+}
+E=E&0xfffff;
+if(E<0x6a09e){
+G=%_ConstructDouble(E|0x3ff00000,%_DoubleLo(G));
+}else{
+++C;
+G=%_ConstructDouble(E|0x3fe00000,%_DoubleLo(G));
+E=(0x00100000-E)>>2;
+}
+D=G-1;
+}
+var H=0.5*D*D;
+if(E===0){
+if(D===0){
+if(C===0){
+return 0.0;
+}else{
+return C*6.93147180369123816490e-01+(F+C*1.90821492927058770002e-10);
+}
+}
+var I=H*(1-6.666666666666666666e-01*D);
+if(C===0){
+return D-I;
+}else{
+return C*6.93147180369123816490e-01-((I-(C*1.90821492927058770002e-10+F))-D);
+}
+}
+var t=D/(2+D);
+var m=t*t;
+var I=m*(6.666666666666735130e-01+m*(3.999999999940941908e-01+m*(2.857142874366239149e-01+m*(2.222219843214978396e-01+
+m*(1.818357216161805012e-01+m*(1.531383769920937332e-01+m*1.479819860511658591e-01))))));
+if(C===0){
+return D-(H-t*(H+I));
+}else{
+return C*6.93147180369123816490e-01-((H-(t*(H+I)+(C*1.90821492927058770002e-10+F)))-D);
+}
+}
+function MathExpm1(j){
+j=j*1;
+var k;
+var J;
+var K;
+var C;
+var s;
+var F;
+var o=%_DoubleHi(j);
+var L=o&0x80000000;
+var k=(L===0)?j:-j;
+o&=0x7fffffff;
+if(o>=0x4043687a){
+if(o>=0x40862e42){
+if(o>=0x7ff00000){
+return(j===-(1/0))?-1:j;
+}
+if(j>7.09782712893383973096e+02)return(1/0);
+}
+if(L!=0)return-1;
+}
+if(o>0x3fd62e42){
+if(o<0x3ff0a2b2){
+if(L===0){
+J=j-6.93147180369123816490e-01;
+K=1.90821492927058770002e-10;
+C=1;
+}else{
+J=j+6.93147180369123816490e-01;
+K=-1.90821492927058770002e-10;
+C=-1;
+}
+}else{
+C=(1.44269504088896338700*j+((L===0)?0.5:-0.5))|0;
+s=C;
+J=j-s*6.93147180369123816490e-01;
+K=s*1.90821492927058770002e-10;
+}
+j=J-K;
+F=(J-j)-K;
+}else if(o<0x3c900000){
+return j;
+}else{
+C=0;
+}
+var M=0.5*j;
+var N=j*M;
+var O=1+N*(-3.33333333333331316428e-02+N*(1.58730158725481460165e-03+N*
+(-7.93650757867487942473e-05+N*(4.00821782732936239552e-06+N*-2.01099218183624371326e-07))));
+s=3-O*M;
+var P=N*((O-s)/(6-j*s));
+if(C===0){
+return j-(j*P-N);
+}else{
+P=(j*(P-F)-F);
+P-=N;
+if(C===-1)return 0.5*(j-P)-0.5;
+if(C===1){
+if(j<-0.25)return-2*(P-(j+0.5));
+return 1+2*(j-P);
+}
+if(C<=-2||C>56){
+k=1-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+return k-1;
+}
+if(C<20){
+s=%_ConstructDouble(0x3ff00000-(0x200000>>C),0);
+k=s-(P-j);
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}else{
+s=%_ConstructDouble((0x3ff-C)<<20,0);
+k=j-(P+s);
+k+=1;
+k=%_ConstructDouble(%_DoubleHi(k)+(C<<20),%_DoubleLo(k));
+}
+}
+return k;
+}
+function MathSinh(j){
+j=j*1;
+var Q=(j<0)?-0.5:0.5;
+var B=e(j);
+if(B<22){
+if(B<3.725290298461914e-9)return j;
+var s=MathExpm1(B);
+if(B<1)return Q*(2*s-s*s/(s+1));
+return Q*(s+s/(s+1));
+}
+if(B<709.7822265625)return Q*f(B);
+if(B<=710.4758600739439){
+var n=f(0.5*B);
+var s=Q*n;
+return s*n;
+}
+return j*(1/0);
+}
+function MathCosh(j){
+j=j*1;
+var p=%_DoubleHi(j)&0x7fffffff;
+if(p<0x3fd62e43){
+var s=MathExpm1(e(j));
+var n=1+s;
+if(p<0x3c800000)return n;
+return 1+(s*s)/(n+n);
+}
+if(p<0x40360000){
+var s=f(e(j));
+return 0.5*s+0.5/s;
+}
+if(p<0x40862e42)return 0.5*f(e(j));
+if(e(j)<=710.4758600739439){
+var n=f(0.5*e(j));
+var s=0.5*n;
+return s*n;
+}
+if((!%_IsSmi(%IS_VAR(j))&&!(j==j)))return j;
+return(1/0);
+}
+function MathTanh(j){
+j=j*1;
+if(!(%_IsSmi(%IS_VAR(j))||((j==j)&&(j!=1/0)&&(j!=-1/0)))){
+if(j>0)return 1;
+if(j<0)return-1;
+return j;
+}
+var B=e(j);
+var m;
+if(B<22){
+if(B<2.77555756156289135105e-17){
+return j;
+}
+if(B>=1){
+var s=MathExpm1(2*B);
+m=1-2/(s+2);
+}else{
+var s=MathExpm1(-2*B);
+m=-s/(s+2);
+}
+}else{
+m=1;
+}
+return(j>=0)?m:-m;
+}
+function MathLog10(j){
+j=j*1;
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var C=0;
+if(o<0x00100000){
+if(((o&0x7fffffff)|R)===0)return-(1/0);
+if(o<0)return g;
+C-=54;
+j*=18014398509481984;
+o=%_DoubleHi(j);
+R=%_DoubleLo(j);
+}
+if(o>=0x7ff00000)return j;
+C+=(o>>20)-1023;
+var S=(C&0x80000000)>>>31;
+o=(o&0x000fffff)|((0x3ff-S)<<20);
+var k=C+S;
+j=%_ConstructDouble(o,R);
+var m=k*3.69423907715893078616e-13+4.34294481903251816668e-01*%_MathLogRT(j);
+return m+k*3.01029995663611771306e-01;
+}
+function MathLog2(j){
+j=j*1;
+var B=e(j);
+var o=%_DoubleHi(j);
+var R=%_DoubleLo(j);
+var p=o&0x7fffffff;
+if((p|R)==0)return-(1/0);
+if(o<0)return g;
+if(p>=0x7ff00000)return j;
+var v=0;
+if(p<0x00100000){
+B*=9007199254740992;
+v-=53;
+p=%_DoubleHi(B);
+}
+v+=(p>>20)-0x3ff;
+var T=p&0x000fffff;
+p=T|0x3ff00000;
+var U=1;
+var V=0;
+var W=0;
+if(T>0x3988e){
+if(T<0xbb67a){
+U=1.5;
+V=5.84962487220764160156e-01;
+W=1.35003920212974897128e-08;
+}else{
+v+=1;
+p-=0x00100000;
+}
+}
+B=%_ConstructDouble(p,%_DoubleLo(B));
+var G=B-U;
+var q=1/(B+U);
+var X=G*q;
+var Y=%_ConstructDouble(%_DoubleHi(X),0);
+var Z=%_ConstructDouble(%_DoubleHi(B+U),0)
+var aa=B-(Z-U);
+var ab=q*((G-Y*Z)-Y*aa);
+var ac=X*X;
+var u=ac*ac*(5.99999999999994648725e-01+ac*(4.28571428578550184252e-01+ac*(3.33333329818377432918e-01+ac*(
+2.72728123808534006489e-01+ac*(2.30660745775561754067e-01+ac*2.06975017800338417784e-01)))));
+u+=ab*(Y+X);
+ac=Y*Y;
+Z=%_ConstructDouble(%_DoubleHi(3.0+ac+u),0);
+aa=u-((Z-3.0)-ac);
+G=Y*Z;
+q=ab*Z+aa*X;
+var ad=%_ConstructDouble(%_DoubleHi(G+q),0);
+var ae=q-(ad-G);
+var af=9.61796700954437255859e-01*ad;
+var ag=-7.02846165095275826516e-09*ad+ae*9.61796693925975554329e-01+W;
+var s=v;
+var ah=%_ConstructDouble(%_DoubleHi(((af+ag)+V)+s),0);
+var ai=ag-(((ah-s)-V)-af);
+return ah+ai;
+}
+b.InstallFunctions(d,2,[
+"cos",MathCos,
+"sin",MathSin,
+"tan",MathTan,
+"sinh",MathSinh,
+"cosh",MathCosh,
+"tanh",MathTanh,
+"log10",MathLog10,
+"log2",MathLog2,
+"log1p",MathLog1p,
+"expm1",MathExpm1
+]);
+%SetForceInlineFlag(MathSin);
+%SetForceInlineFlag(MathCos);
+})
+
+regexp…
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d=a.Object;
+var e=a.RegExp;
+var f;
+var g=b.InternalArray;
+var h=b.InternalPackedArray;
+var i;
+var j=b.ImportNow("match_symbol");
+var k=b.ImportNow("search_symbol");
+var l=b.ImportNow("split_symbol");
+b.ImportFromExperimental(function(m){
+c=m.FLAG_harmony_tolength;
+});
+b.Import(function(m){
+i=m.MakeTypeError;
+});
+var n=new h(
+2,
+"",
+(void 0),
+0,
+0
+);
+function IsRegExp(o){
+if(!(%_IsJSReceiver(o)))return false;
+var p=o[j];
+if(!(p===(void 0)))return(!!(p));
+return(%_IsRegExp(o));
+}
+function RegExpInitialize(q,r,s){
+r=(r===(void 0))?'':(%_ToString(r));
+s=(s===(void 0))?'':(%_ToString(s));
+%RegExpInitializeAndCompile(q,r,s);
+return q;
+}
+function PatternFlags(r){
+return((%_RegExpFlags(r)&1)?'g':'')+
+((%_RegExpFlags(r)&2)?'i':'')+
+((%_RegExpFlags(r)&4)?'m':'')+
+((%_RegExpFlags(r)&16)?'u':'')+
+((%_RegExpFlags(r)&8)?'y':'');
+}
+function RegExpConstructor(r,s){
+var t=new.target;
+var u=IsRegExp(r);
+if((t===(void 0))){
+t=e;
+if(u&&(s===(void 0))&&
+r.constructor===t){
+return r;
+}
+}
+if((%_IsRegExp(r))){
+if((s===(void 0)))s=PatternFlags(r);
+r=(%_RegExpSource(r));
+}else if(u){
+var v=r;
+r=r.source;
+if((s===(void 0)))s=v.flags;
+}
+var q=%NewObject(e,t);
+return RegExpInitialize(q,r,s);
+}
+function RegExpCompileJS(r,s){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.compile",this);
+}
+if((%_IsRegExp(r))){
+if(!(s===(void 0)))throw i(129);
+s=PatternFlags(r);
+r=(%_RegExpSource(r));
+}
+RegExpInitialize(this,r,s);
+}
+function DoRegExpExec(w,x,y){
+return %_RegExpExec(w,x,y,n);
+}
+function RegExpExecNoTests(w,x,z){
+var A=%_RegExpExec(w,x,z,n);
+if(A!==null){
+if((%_RegExpFlags(w)&8))w.lastIndex=A[4];
+var B=((A)[0])>>1;
+var z=A[3];
+var C=A[4];
+var D=%_SubString(x,z,C);
+var E=%_RegExpConstructResult(B,z,x);
+E[0]=D;
+if(B==1)return E;
+var F=3+2;
+for(var G=1;G<B;G++){
+z=A[F++];
+if(z!=-1){
+C=A[F];
+E[G]=%_SubString(x,z,C);
+}
+F++;
+}
+return E;
+;
+}
+w.lastIndex=0;
+return null;
+}
+function RegExpExecJS(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+'RegExp.prototype.exec',this);
+}
+x=(%_ToString(x));
+var H=this.lastIndex;
+var G=(c?(%_ToLength(H)):(%_ToInteger(H)));
+var I=(%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8);
+if(I){
+if(G<0||G>x.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+G=0;
+}
+var J=%_RegExpExec(this,x,G,n);
+if((J===null)){
+this.lastIndex=0;
+return null;
+}
+if(I){
+this.lastIndex=n[4];
+}
+var B=((J)[0])>>1;
+var z=J[3];
+var C=J[4];
+var D=%_SubString(x,z,C);
+var E=%_RegExpConstructResult(B,z,x);
+E[0]=D;
+if(B==1)return E;
+var F=3+2;
+for(var G=1;G<B;G++){
+z=J[F++];
+if(z!=-1){
+C=J[F];
+E[G]=%_SubString(x,z,C);
+}
+F++;
+}
+return E;
+;
+}
+var K;
+var L;
+function RegExpTest(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+'RegExp.prototype.test',this);
+}
+x=(%_ToString(x));
+var H=this.lastIndex;
+var G=(c?(%_ToLength(H)):(%_ToInteger(H)));
+if((%_RegExpFlags(this)&1)||(%_RegExpFlags(this)&8)){
+if(G<0||G>x.length){
+this.lastIndex=0;
+return false;
+}
+var J=%_RegExpExec(this,x,G,n);
+if((J===null)){
+this.lastIndex=0;
+return false;
+}
+this.lastIndex=n[4];
+return true;
+}else{
+var w=this;
+var M=(%_RegExpSource(w));
+if(w.length>=3&&
+%_StringCharCodeAt(w,0)==46&&
+%_StringCharCodeAt(w,1)==42&&
+%_StringCharCodeAt(w,2)!=63){
+w=TrimRegExp(w);
+}
+var J=%_RegExpExec(w,x,0,n);
+if((J===null)){
+this.lastIndex=0;
+return false;
+}
+return true;
+}
+}
+function TrimRegExp(w){
+if(!%_ObjectEquals(K,w)){
+K=w;
+L=
+new e(
+%_SubString((%_RegExpSource(w)),2,(%_RegExpSource(w)).length),
+((%_RegExpFlags(w)&2)?(%_RegExpFlags(w)&4)?"im":"i"
+:(%_RegExpFlags(w)&4)?"m":""));
+}
+return L;
+}
+function RegExpToString(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+%IncrementUseCounter(12);
+return'/(?:)/';
+}
+throw i(42,
+'RegExp.prototype.toString',this);
+}
+var E='/'+(%_RegExpSource(this))+'/';
+if((%_RegExpFlags(this)&1))E+='g';
+if((%_RegExpFlags(this)&2))E+='i';
+if((%_RegExpFlags(this)&4))E+='m';
+if((%_RegExpFlags(this)&16))E+='u';
+if((%_RegExpFlags(this)&8))E+='y';
+return E;
+}
+function RegExpSplit(x,N){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@split",this);
+}
+var O=this;
+var P=(%_ToString(x));
+N=((N===(void 0)))?4294967295:((N)>>>0);
+var Q=P.length;
+if(N===0)return[];
+if(Q===0){
+if(DoRegExpExec(O,P,0,0)!==null)return[];
+return[P];
+}
+var R=0;
+var S=0;
+var T=0;
+var E=new g();
+outer_loop:
+while(true){
+if(S===Q){
+E[E.length]=%_SubString(P,R,Q);
+break;
+}
+var A=DoRegExpExec(O,P,S);
+if(A===null||Q===(T=A[3])){
+E[E.length]=%_SubString(P,R,Q);
+break;
+}
+var U=A[4];
+if(S===U&&U===R){
+S++;
+continue;
+}
+E[E.length]=%_SubString(P,R,T);
+if(E.length===N)break;
+var V=((A)[0])+3;
+for(var G=3+2;G<V;){
+var z=A[G++];
+var C=A[G++];
+if(C!=-1){
+E[E.length]=%_SubString(P,z,C);
+}else{
+E[E.length]=(void 0);
+}
+if(E.length===N)break outer_loop;
+}
+S=R=U;
+}
+var W=[];
+%MoveArrayContents(E,W);
+return W;
+}
+function RegExpMatch(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@match",this);
+}
+var P=(%_ToString(x));
+if(!(%_RegExpFlags(this)&1))return RegExpExecNoTests(this,P,0);
+this.lastIndex=0;
+var E=%StringMatch(P,this,n);
+return E;
+}
+function RegExpSearch(x){
+if(!(%_IsRegExp(this))){
+throw i(42,
+"RegExp.prototype.@@search",this);
+}
+var X=DoRegExpExec(this,(%_ToString(x)),0);
+if(X)return X[3];
+return-1;
+}
+function RegExpGetLastMatch(){
+var Y=((n)[1]);
+return %_SubString(Y,
+n[3],
+n[4]);
+}
+function RegExpGetLastParen(){
+var Q=((n)[0]);
+if(Q<=2)return'';
+var Y=((n)[1]);
+var z=n[(3+(Q-2))];
+var C=n[(3+(Q-1))];
+if(z!=-1&&C!=-1){
+return %_SubString(Y,z,C);
+}
+return"";
+}
+function RegExpGetLeftContext(){
+var Z;
+var P;
+Z=n[3];
+P=((n)[1]);
+return %_SubString(P,0,Z);
+}
+function RegExpGetRightContext(){
+var Z;
+var P;
+Z=n[4];
+P=((n)[1]);
+return %_SubString(P,Z,P.length);
+}
+function RegExpMakeCaptureGetter(aa){
+return function foo(){
+var y=aa*2;
+if(y>=((n)[0]))return'';
+var ab=n[(3+(y))];
+var ac=n[(3+(y+1))];
+if(ab==-1||ac==-1)return'';
+return %_SubString(((n)[1]),ab,ac);
+};
+}
+function RegExpGetGlobal(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.global");
+}
+return!!(%_RegExpFlags(this)&1);
+}
+%FunctionSetName(RegExpGetGlobal,"RegExp.prototype.global");
+%SetNativeFlag(RegExpGetGlobal);
+function RegExpGetIgnoreCase(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.ignoreCase");
+}
+return!!(%_RegExpFlags(this)&2);
+}
+%FunctionSetName(RegExpGetIgnoreCase,"RegExp.prototype.ignoreCase");
+%SetNativeFlag(RegExpGetIgnoreCase);
+function RegExpGetMultiline(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.multiline");
+}
+return!!(%_RegExpFlags(this)&4);
+}
+%FunctionSetName(RegExpGetMultiline,"RegExp.prototype.multiline");
+%SetNativeFlag(RegExpGetMultiline);
+function RegExpGetSource(){
+if(!(%_IsRegExp(this))){
+if(this===f){
+return(void 0);
+}
+throw i(131,"RegExp.prototype.source");
+}
+return(%_RegExpSource(this));
+}
+%FunctionSetName(RegExpGetSource,"RegExp.prototype.source");
+%SetNativeFlag(RegExpGetSource);
+%FunctionSetInstanceClassName(e,'RegExp');
+f=new d();
+%FunctionSetPrototype(e,f);
+%AddNamedProperty(
+e.prototype,'constructor',e,2);
+%SetCode(e,RegExpConstructor);
+b.InstallFunctions(e.prototype,2,[
+"exec",RegExpExecJS,
+"test",RegExpTest,
+"toString",RegExpToString,
+"compile",RegExpCompileJS,
+j,RegExpMatch,
+k,RegExpSearch,
+l,RegExpSplit,
+]);
+b.InstallGetter(e.prototype,'global',RegExpGetGlobal);
+b.InstallGetter(e.prototype,'ignoreCase',RegExpGetIgnoreCase);
+b.InstallGetter(e.prototype,'multiline',RegExpGetMultiline);
+b.InstallGetter(e.prototype,'source',RegExpGetSource);
+%FunctionSetLength(e.prototype.compile,1);
+var ad=function(){
+var ae=((n)[2]);
+return(ae===(void 0))?"":ae;
+};
+var af=function(x){
+((n)[2])=(%_ToString(x));
+};
+%OptimizeObjectForAddingMultipleProperties(e,22);
+b.InstallGetterSetter(e,'input',ad,af,
+4);
+b.InstallGetterSetter(e,'$_',ad,af,
+2|4);
+var ag=function(ah){};
+b.InstallGetterSetter(e,'lastMatch',RegExpGetLastMatch,
+ag,4);
+b.InstallGetterSetter(e,'$&',RegExpGetLastMatch,ag,
+2|4);
+b.InstallGetterSetter(e,'lastParen',RegExpGetLastParen,
+ag,4);
+b.InstallGetterSetter(e,'$+',RegExpGetLastParen,ag,
+2|4);
+b.InstallGetterSetter(e,'leftContext',RegExpGetLeftContext,
+ag,4);
+b.InstallGetterSetter(e,'$`',RegExpGetLeftContext,ag,
+2|4);
+b.InstallGetterSetter(e,'rightContext',RegExpGetRightContext,
+ag,4);
+b.InstallGetterSetter(e,"$'",RegExpGetRightContext,ag,
+2|4);
+for(var G=1;G<10;++G){
+b.InstallGetterSetter(e,'$'+G,RegExpMakeCaptureGetter(G),
+ag,4);
+}
+%ToFastProperties(e);
+b.Export(function(ai){
+ai.RegExpExec=DoRegExpExec;
+ai.RegExpExecNoTests=RegExpExecNoTests;
+ai.RegExpLastMatchInfo=n;
+ai.RegExpTest=RegExpTest;
+});
+})
+
+,arraybufferÍ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.ArrayBuffer;
+var d;
+var e;
+var f;
+var g;
+b.Import(function(h){
+d=h.MakeTypeError;
+e=h.MaxSimple;
+f=h.MinSimple;
+g=h.SpeciesConstructor;
+});
+function ArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+function ArrayBufferSlice(i,j){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.slice',this);
+}
+var k=(%_ToInteger(i));
+if(!(j===(void 0))){
+j=(%_ToInteger(j));
+}
+var l;
+var m=%_ArrayBufferGetByteLength(this);
+if(k<0){
+l=e(m+k,0);
+}else{
+l=f(k,m);
+}
+var n=(j===(void 0))?m:j;
+var o;
+if(n<0){
+o=e(m+n,0);
+}else{
+o=f(n,m);
+}
+if(o<l){
+o=l;
+}
+var p=o-l;
+var q=g(this,c,true);
+var r=new q(p);
+if(!(%_ClassOf(r)==='ArrayBuffer')){
+throw d(42,
+'ArrayBuffer.prototype.slice',r);
+}
+if(r===this){
+throw d(11);
+}
+if(%_ArrayBufferGetByteLength(r)<p){
+throw d(10);
+}
+%ArrayBufferSliceImpl(this,r,l,p);
+return r;
+}
+b.InstallGetter(c.prototype,"byteLength",
+ArrayBufferGetByteLen);
+b.InstallFunctions(c.prototype,2,[
+"slice",ArrayBufferSlice
+]);
+})
+
+(typedarrayzœ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f=a.Array;
+var g=a.ArrayBuffer;
+var h=a.DataView;
+var i=a.Object;
+var j=b.InternalArray;
+var k;
+var l;
+var m;
+var n;
+var o;
+var p;
+var q;
+var r;
+var s;
+var t;
+var u;
+var v;
+var w;
+var x;
+var y;
+var z;
+var j=b.InternalArray;
+var A;
+var B;
+var C;
+var D;
+var E;
+var F;
+var G;
+var H;
+var I=b.ImportNow("iterator_symbol");
+var J=b.ImportNow("to_string_tag_symbol");
+var K=a.Uint8Array;
+
+var L=a.Int8Array;
+
+var M=a.Uint16Array;
+
+var N=a.Int16Array;
+
+var O=a.Uint32Array;
+
+var P=a.Int32Array;
+
+var Q=a.Float32Array;
+
+var R=a.Float64Array;
+
+var S=a.Uint8ClampedArray;
+
+
+b.Import(function(T){
+c=T.ArrayFrom;
+d=T.ArrayToString;
+e=T.ArrayValues;
+k=T.InnerArrayCopyWithin;
+l=T.InnerArrayEvery;
+m=T.InnerArrayFill;
+n=T.InnerArrayFilter;
+o=T.InnerArrayFind;
+p=T.InnerArrayFindIndex;
+q=T.InnerArrayForEach;
+r=T.InnerArrayIncludes;
+s=T.InnerArrayIndexOf;
+t=T.InnerArrayJoin;
+u=T.InnerArrayLastIndexOf;
+v=T.InnerArrayReduce;
+w=T.InnerArrayReduceRight;
+x=T.InnerArraySome;
+y=T.InnerArraySort;
+z=T.InnerArrayToLocaleString;
+A=T.IsNaN;
+B=T.MakeRangeError;
+C=T.MakeTypeError;
+D=T.MaxSimple;
+E=T.MinSimple;
+F=T.PackedArrayReverse;
+G=T.SpeciesConstructor;
+H=T.ToPositiveInteger;
+});
+function TypedArrayDefaultConstructor(U){
+switch(%_ClassOf(U)){
+case"Uint8Array":
+return K;
+
+case"Int8Array":
+return L;
+
+case"Uint16Array":
+return M;
+
+case"Int16Array":
+return N;
+
+case"Uint32Array":
+return O;
+
+case"Int32Array":
+return P;
+
+case"Float32Array":
+return Q;
+
+case"Float64Array":
+return R;
+
+case"Uint8ClampedArray":
+return S;
+
+
+}
+throw C(42,
+"TypedArrayDefaultConstructor",this);
+}
+function TypedArrayCreate(V,W,X,Y){
+if((X===(void 0))){
+var Z=new V(W);
+}else{
+var Z=new V(W,X,Y);
+}
+if(!%_IsTypedArray(Z))throw C(68);
+if((typeof(W)==='number')&&%_TypedArrayGetLength(Z)<W){
+throw C(265);
+}
+return Z;
+}
+function TypedArraySpeciesCreate(aa,W,X,Y,ab){
+var ac=TypedArrayDefaultConstructor(aa);
+var V=G(aa,ac,
+ab);
+return TypedArrayCreate(V,W,X,Y);
+}
+function Uint8ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Uint8Array",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Uint8Array",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,1,ae,ai,aj,true);
+}
+function Uint8ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,1,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,1,null,0,am,true);
+}
+}
+function Uint8ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,1,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,1,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint8ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint8ArrayConstructByArrayLike(ad,as);
+}
+function Uint8ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint8ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint8ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint8ArrayConstructByArrayLike(this,X);
+}else{
+Uint8ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint8Array")
+}
+}
+function Uint8Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw C(42,"Uint8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint8ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int8ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Int8Array",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Int8Array",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,2,ae,ai,aj,true);
+}
+function Int8ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,2,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,2,null,0,am,true);
+}
+}
+function Int8ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,2,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,2,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int8ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int8ArrayConstructByArrayLike(ad,as);
+}
+function Int8ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int8ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int8ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int8ArrayConstructByArrayLike(this,X);
+}else{
+Int8ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int8Array")
+}
+}
+function Int8Array_GetLength(){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw C(42,"Int8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int8ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint16ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 2!==0){
+throw B(179,
+"start offset","Uint16Array",2);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 2!==0){
+throw B(179,
+"byte length","Uint16Array",2);
+}
+aj=ah-ai;
+ak=aj/2;
+}else{
+var ak=ag;
+aj=ak*2;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,3,ae,ai,aj,true);
+}
+function Uint16ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*2;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,3,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,3,null,0,am,true);
+}
+}
+function Uint16ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*2;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,3,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,3,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint16ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint16ArrayConstructByArrayLike(ad,as);
+}
+function Uint16ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint16ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint16ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint16ArrayConstructByArrayLike(this,X);
+}else{
+Uint16ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint16Array")
+}
+}
+function Uint16Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw C(42,"Uint16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint16ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*2;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int16ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 2!==0){
+throw B(179,
+"start offset","Int16Array",2);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 2!==0){
+throw B(179,
+"byte length","Int16Array",2);
+}
+aj=ah-ai;
+ak=aj/2;
+}else{
+var ak=ag;
+aj=ak*2;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,4,ae,ai,aj,true);
+}
+function Int16ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*2;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,4,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,4,null,0,am,true);
+}
+}
+function Int16ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*2;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,4,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,4,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int16ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int16ArrayConstructByArrayLike(ad,as);
+}
+function Int16ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int16ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int16ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int16ArrayConstructByArrayLike(this,X);
+}else{
+Int16ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int16Array")
+}
+}
+function Int16Array_GetLength(){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw C(42,"Int16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int16ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*2;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Uint32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Uint32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,5,ae,ai,aj,true);
+}
+function Uint32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,5,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,5,null,0,am,true);
+}
+}
+function Uint32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,5,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,5,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint32ArrayConstructByArrayLike(ad,as);
+}
+function Uint32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint32ArrayConstructByArrayLike(this,X);
+}else{
+Uint32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint32Array")
+}
+}
+function Uint32Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw C(42,"Uint32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Int32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Int32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Int32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,6,ae,ai,aj,true);
+}
+function Int32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,6,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,6,null,0,am,true);
+}
+}
+function Int32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,6,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,6,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Int32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Int32ArrayConstructByArrayLike(ad,as);
+}
+function Int32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Int32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Int32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Int32ArrayConstructByArrayLike(this,X);
+}else{
+Int32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Int32Array")
+}
+}
+function Int32Array_GetLength(){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw C(42,"Int32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Int32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Float32ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 4!==0){
+throw B(179,
+"start offset","Float32Array",4);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 4!==0){
+throw B(179,
+"byte length","Float32Array",4);
+}
+aj=ah-ai;
+ak=aj/4;
+}else{
+var ak=ag;
+aj=ak*4;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,7,ae,ai,aj,true);
+}
+function Float32ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*4;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,7,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,7,null,0,am,true);
+}
+}
+function Float32ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*4;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,7,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,7,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Float32ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Float32ArrayConstructByArrayLike(ad,as);
+}
+function Float32ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Float32ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Float32ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Float32ArrayConstructByArrayLike(this,X);
+}else{
+Float32ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Float32Array")
+}
+}
+function Float32Array_GetLength(){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw C(42,"Float32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Float32ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*4;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Float64ArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 8!==0){
+throw B(179,
+"start offset","Float64Array",8);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 8!==0){
+throw B(179,
+"byte length","Float64Array",8);
+}
+aj=ah-ai;
+ak=aj/8;
+}else{
+var ak=ag;
+aj=ak*8;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,8,ae,ai,aj,true);
+}
+function Float64ArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*8;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,8,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,8,null,0,am,true);
+}
+}
+function Float64ArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*8;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,8,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,8,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Float64ArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Float64ArrayConstructByArrayLike(ad,as);
+}
+function Float64ArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Float64ArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Float64ArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Float64ArrayConstructByArrayLike(this,X);
+}else{
+Float64ArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Float64Array")
+}
+}
+function Float64Array_GetLength(){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw C(42,"Float64Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Float64ArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*8;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+function Uint8ClampedArrayConstructByArrayBuffer(ad,ae,af,ag){
+if(!(af===(void 0))){
+af=H(af,180);
+}
+if(!(ag===(void 0))){
+ag=H(ag,180);
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai;
+if((af===(void 0))){
+ai=0;
+}else{
+ai=af;
+if(ai % 1!==0){
+throw B(179,
+"start offset","Uint8ClampedArray",1);
+}
+if(ai>ah){
+throw B(181);
+}
+}
+var aj;
+var ak;
+if((ag===(void 0))){
+if(ah % 1!==0){
+throw B(179,
+"byte length","Uint8ClampedArray",1);
+}
+aj=ah-ai;
+ak=aj/1;
+}else{
+var ak=ag;
+aj=ak*1;
+}
+if((ai+aj>ah)
+||(ak>%_MaxSmi())){
+throw B(180);
+}
+%_TypedArrayInitialize(ad,9,ae,ai,aj,true);
+}
+function Uint8ClampedArrayConstructByLength(ad,ag){
+var al=(ag===(void 0))?
+0:H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var am=al*1;
+if(am>%_TypedArrayMaxSizeInHeap()){
+var ae=new g(am);
+%_TypedArrayInitialize(ad,9,ae,0,am,true);
+}else{
+%_TypedArrayInitialize(ad,9,null,0,am,true);
+}
+}
+function Uint8ClampedArrayConstructByArrayLike(ad,an){
+var ag=an.length;
+var al=H(ag,180);
+if(al>%_MaxSmi()){
+throw B(180);
+}
+var ao=false;
+var am=al*1;
+if(am<=%_TypedArrayMaxSizeInHeap()){
+%_TypedArrayInitialize(ad,9,null,0,am,false);
+}else{
+ao=
+%TypedArrayInitializeFromArrayLike(ad,9,an,al);
+}
+if(!ao){
+for(var ap=0;ap<al;ap++){
+ad[ap]=an[ap];
+}
+}
+}
+function Uint8ClampedArrayConstructByIterable(ad,aq,ar){
+var as=new j();
+var at=%_Call(ar,aq);
+var au={
+__proto__:null
+};
+au[I]=function(){return at;}
+for(var av of au){
+as.push(av);
+}
+Uint8ClampedArrayConstructByArrayLike(ad,as);
+}
+function Uint8ClampedArrayConstructor(X,Y,aw){
+if(!(new.target===(void 0))){
+if((%_ClassOf(X)==='ArrayBuffer')||(%_ClassOf(X)==='SharedArrayBuffer')){
+Uint8ClampedArrayConstructByArrayBuffer(this,X,Y,aw);
+}else if((typeof(X)==='number')||(typeof(X)==='string')||
+(typeof(X)==='boolean')||(X===(void 0))){
+Uint8ClampedArrayConstructByLength(this,X);
+}else{
+var ar=X[I];
+if((ar===(void 0))||ar===e){
+Uint8ClampedArrayConstructByArrayLike(this,X);
+}else{
+Uint8ClampedArrayConstructByIterable(this,X,ar);
+}
+}
+}else{
+throw C(26,"Uint8ClampedArray")
+}
+}
+function Uint8ClampedArray_GetLength(){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw C(42,"Uint8ClampedArray.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+function Uint8ClampedArraySubArray(ax,ay){
+var az=(%_ToInteger(ax));
+if(!(ay===(void 0))){
+var aA=(%_ToInteger(ay));
+var aB=%_TypedArrayGetLength(this);
+}else{
+var aB=%_TypedArrayGetLength(this);
+var aA=aB;
+}
+if(az<0){
+az=D(0,aB+az);
+}else{
+az=E(az,aB);
+}
+if(aA<0){
+aA=D(0,aB+aA);
+}else{
+aA=E(aA,aB);
+}
+if(aA<az){
+aA=az;
+}
+var ak=aA-az;
+var aC=
+%_ArrayBufferViewGetByteOffset(this)+az*1;
+return TypedArraySpeciesCreate(this,%TypedArrayGetBuffer(this),
+aC,ak,true);
+}
+
+
+function TypedArraySubArray(ax,ay){
+switch(%_ClassOf(this)){
+case"Uint8Array":
+return %_Call(Uint8ArraySubArray,this,ax,ay);
+
+case"Int8Array":
+return %_Call(Int8ArraySubArray,this,ax,ay);
+
+case"Uint16Array":
+return %_Call(Uint16ArraySubArray,this,ax,ay);
+
+case"Int16Array":
+return %_Call(Int16ArraySubArray,this,ax,ay);
+
+case"Uint32Array":
+return %_Call(Uint32ArraySubArray,this,ax,ay);
+
+case"Int32Array":
+return %_Call(Int32ArraySubArray,this,ax,ay);
+
+case"Float32Array":
+return %_Call(Float32ArraySubArray,this,ax,ay);
+
+case"Float64Array":
+return %_Call(Float64ArraySubArray,this,ax,ay);
+
+case"Uint8ClampedArray":
+return %_Call(Uint8ClampedArraySubArray,this,ax,ay);
+
+
+}
+throw C(42,
+"get TypedArray.prototype.subarray",this);
+}
+%SetForceInlineFlag(TypedArraySubArray);
+function TypedArrayGetBuffer(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+%SetForceInlineFlag(TypedArrayGetBuffer);
+function TypedArrayGetByteLength(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteLength);
+function TypedArrayGetByteOffset(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+%SetForceInlineFlag(TypedArrayGetByteOffset);
+function TypedArrayGetLength(){
+if(!%_IsTypedArray(this)){
+throw C(42,
+"get TypedArray.prototype.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+%SetForceInlineFlag(TypedArrayGetLength);
+function TypedArraySetFromArrayLike(aD,aE,aF,ai){
+if(ai>0){
+for(var ap=0;ap<aF;ap++){
+aD[ai+ap]=aE[ap];
+}
+}
+else{
+for(var ap=0;ap<aF;ap++){
+aD[ap]=aE[ap];
+}
+}
+}
+function TypedArraySetFromOverlappingTypedArray(aD,aE,ai){
+var aG=aE.BYTES_PER_ELEMENT;
+var aH=aD.BYTES_PER_ELEMENT;
+var aF=aE.length;
+function CopyLeftPart(){
+var aI=aD.byteOffset+(ai+1)*aH;
+var aJ=aE.byteOffset;
+for(var aK=0;
+aK<aF&&aI<=aJ;
+aK++){
+aD[ai+aK]=aE[aK];
+aI+=aH;
+aJ+=aG;
+}
+return aK;
+}
+var aK=CopyLeftPart();
+function CopyRightPart(){
+var aI=
+aD.byteOffset+(ai+aF-1)*aH;
+var aJ=
+aE.byteOffset+aF*aG;
+for(var aL=aF-1;
+aL>=aK&&aI>=aJ;
+aL--){
+aD[ai+aL]=aE[aL];
+aI-=aH;
+aJ-=aG;
+}
+return aL;
+}
+var aL=CopyRightPart();
+var aM=new f(aL+1-aK);
+for(var ap=aK;ap<=aL;ap++){
+aM[ap-aK]=aE[ap];
+}
+for(ap=aK;ap<=aL;ap++){
+aD[ai+ap]=aM[ap-aK];
+}
+}
+function TypedArraySet(ad,ai){
+var aN=(ai===(void 0))?0:(%_ToInteger(ai));
+if(aN<0)throw C(190);
+if(aN>%_MaxSmi()){
+throw B(191);
+}
+switch(%TypedArraySetFastCases(this,ad,aN)){
+case 0:
+return;
+case 1:
+TypedArraySetFromOverlappingTypedArray(this,ad,aN);
+return;
+case 2:
+TypedArraySetFromArrayLike(this,ad,ad.length,aN);
+return;
+case 3:
+var al=ad.length;
+if((al===(void 0))){
+if((typeof(ad)==='number')){
+throw C(45);
+}
+return;
+}
+al=(%_ToLength(al));
+if(aN+al>this.length){
+throw B(191);
+}
+TypedArraySetFromArrayLike(this,ad,al,aN);
+return;
+}
+}
+function TypedArrayGetToStringTag(){
+if(!%_IsTypedArray(this))return;
+var aO=%_ClassOf(this);
+if((aO===(void 0)))return;
+return aO;
+}
+function TypedArrayCopyWithin(aD,aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return k(aD,aP,ay,this,ag);
+}
+%FunctionSetLength(TypedArrayCopyWithin,2);
+function TypedArrayEvery(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return l(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArrayEvery,1);
+function TypedArrayForEach(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+q(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArrayForEach,1);
+function TypedArrayFill(av,aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return m(av,aP,ay,this,ag);
+}
+%FunctionSetLength(TypedArrayFill,1);
+function TypedArrayFilter(aQ,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+if(!(typeof(aQ)==='function'))throw C(15,aQ);
+var aT=new j();
+n(aQ,aS,this,ag,aT);
+var aU=aT.length;
+var aV=TypedArraySpeciesCreate(this,aU);
+for(var ap=0;ap<aU;ap++){
+aV[ap]=aT[ap];
+}
+return aV;
+}
+%FunctionSetLength(TypedArrayFilter,1);
+function TypedArrayFind(aW,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return o(aW,aS,this,ag);
+}
+%FunctionSetLength(TypedArrayFind,1);
+function TypedArrayFindIndex(aW,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return p(aW,aS,this,ag);
+}
+%FunctionSetLength(TypedArrayFindIndex,1);
+function TypedArrayReverse(){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return F(this,ag);
+}
+function TypedArrayComparefn(aX,aY){
+if(A(aX)&&A(aY)){
+return A(aY)?0:1;
+}
+if(A(aX)){
+return 1;
+}
+if(aX===0&&aX===aY){
+if(%_IsMinusZero(aX)){
+if(!%_IsMinusZero(aY)){
+return-1;
+}
+}else if(%_IsMinusZero(aY)){
+return 1;
+}
+}
+return aX-aY;
+}
+function TypedArraySort(aZ){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+if((aZ===(void 0))){
+aZ=TypedArrayComparefn;
+}
+return y(this,ag,aZ);
+}
+function TypedArrayIndexOf(ba,bb){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return s(this,ba,bb,ag);
+}
+%FunctionSetLength(TypedArrayIndexOf,1);
+function TypedArrayLastIndexOf(ba,bb){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return u(this,ba,bb,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayLastIndexOf,1);
+function TypedArrayMap(aQ,aS){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+var aT=TypedArraySpeciesCreate(this,ag);
+if(!(typeof(aQ)==='function'))throw C(15,aQ);
+for(var ap=0;ap<ag;ap++){
+var ba=this[ap];
+aT[ap]=%_Call(aQ,aS,ba,ap,this);
+}
+return aT;
+}
+%FunctionSetLength(TypedArrayMap,1);
+function TypedArraySome(aQ,aR){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return x(aQ,aR,this,ag);
+}
+%FunctionSetLength(TypedArraySome,1);
+function TypedArrayToLocaleString(){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return z(this,ag);
+}
+function TypedArrayToString(){
+return %_Call(d,this);
+}
+function TypedArrayJoin(bc){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return t(bc,this,ag);
+}
+function TypedArrayReduce(bd,be){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return v(bd,be,this,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayReduce,1);
+function TypedArrayReduceRight(bd,be){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return w(bd,be,this,ag,
+%_ArgumentsLength());
+}
+%FunctionSetLength(TypedArrayReduceRight,1);
+function TypedArraySlice(aP,ay){
+if(!%_IsTypedArray(this))throw C(68);
+var bf=%_TypedArrayGetLength(this);
+var bg=(%_ToInteger(aP));
+var bh;
+if(bg<0){
+bh=D(bf+bg,0);
+}else{
+bh=E(bg,bf);
+}
+var bi;
+if((ay===(void 0))){
+bi=bf;
+}else{
+bi=(%_ToInteger(ay));
+}
+var bj;
+if(bi<0){
+bj=D(bf+bi,0);
+}else{
+bj=E(bi,bf);
+}
+var bk=D(bj-bh,0);
+var bl=TypedArraySpeciesCreate(this,bk);
+var bm=0;
+while(bh<bj){
+var bn=this[bh];
+bl[bm]=bn;
+bh++;
+bm++;
+}
+return bl;
+}
+function TypedArrayIncludes(bo,bp){
+if(!%_IsTypedArray(this))throw C(68);
+var ag=%_TypedArrayGetLength(this);
+return r(bo,bp,this,ag);
+}
+%FunctionSetLength(TypedArrayIncludes,1);
+function TypedArrayOf(){
+var ag=%_ArgumentsLength();
+var bl=TypedArrayCreate(this,ag);
+for(var ap=0;ap<ag;ap++){
+bl[ap]=%_Arguments(ap);
+}
+return bl;
+}
+function TypedArrayFrom(aE,bq,aS){
+var bl=%_Call(c,f,aE,bq,aS);
+return TypedArrayCreate(this,bl);
+}
+%FunctionSetLength(TypedArrayFrom,1);
+function TypedArray(){
+if((new.target===(void 0))){
+throw C(25,"TypedArray");
+}
+if(new.target===TypedArray){
+throw C(23,"TypedArray");
+}
+}
+%FunctionSetPrototype(TypedArray,new i());
+%AddNamedProperty(TypedArray.prototype,
+"constructor",TypedArray,2);
+b.InstallFunctions(TypedArray,2|4|1,[
+"from",TypedArrayFrom,
+"of",TypedArrayOf
+]);
+b.InstallGetter(TypedArray.prototype,"buffer",TypedArrayGetBuffer);
+b.InstallGetter(TypedArray.prototype,"byteOffset",TypedArrayGetByteOffset,
+2|4);
+b.InstallGetter(TypedArray.prototype,"byteLength",
+TypedArrayGetByteLength,2|4);
+b.InstallGetter(TypedArray.prototype,"length",TypedArrayGetLength,
+2|4);
+b.InstallGetter(TypedArray.prototype,J,
+TypedArrayGetToStringTag);
+b.InstallFunctions(TypedArray.prototype,2,[
+"subarray",TypedArraySubArray,
+"set",TypedArraySet,
+"copyWithin",TypedArrayCopyWithin,
+"every",TypedArrayEvery,
+"fill",TypedArrayFill,
+"filter",TypedArrayFilter,
+"find",TypedArrayFind,
+"findIndex",TypedArrayFindIndex,
+"includes",TypedArrayIncludes,
+"indexOf",TypedArrayIndexOf,
+"join",TypedArrayJoin,
+"lastIndexOf",TypedArrayLastIndexOf,
+"forEach",TypedArrayForEach,
+"map",TypedArrayMap,
+"reduce",TypedArrayReduce,
+"reduceRight",TypedArrayReduceRight,
+"reverse",TypedArrayReverse,
+"slice",TypedArraySlice,
+"some",TypedArraySome,
+"sort",TypedArraySort,
+"toString",TypedArrayToString,
+"toLocaleString",TypedArrayToLocaleString
+]);
+%SetCode(K,Uint8ArrayConstructor);
+%FunctionSetPrototype(K,new i());
+%InternalSetPrototype(K,TypedArray);
+%InternalSetPrototype(K.prototype,TypedArray.prototype);
+%AddNamedProperty(K,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(K.prototype,
+"constructor",a.Uint8Array,2);
+%AddNamedProperty(K.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(K.prototype,"length",Uint8Array_GetLength,
+2|4);
+
+%SetCode(L,Int8ArrayConstructor);
+%FunctionSetPrototype(L,new i());
+%InternalSetPrototype(L,TypedArray);
+%InternalSetPrototype(L.prototype,TypedArray.prototype);
+%AddNamedProperty(L,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(L.prototype,
+"constructor",a.Int8Array,2);
+%AddNamedProperty(L.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(L.prototype,"length",Int8Array_GetLength,
+2|4);
+
+%SetCode(M,Uint16ArrayConstructor);
+%FunctionSetPrototype(M,new i());
+%InternalSetPrototype(M,TypedArray);
+%InternalSetPrototype(M.prototype,TypedArray.prototype);
+%AddNamedProperty(M,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(M.prototype,
+"constructor",a.Uint16Array,2);
+%AddNamedProperty(M.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+b.InstallGetter(M.prototype,"length",Uint16Array_GetLength,
+2|4);
+
+%SetCode(N,Int16ArrayConstructor);
+%FunctionSetPrototype(N,new i());
+%InternalSetPrototype(N,TypedArray);
+%InternalSetPrototype(N.prototype,TypedArray.prototype);
+%AddNamedProperty(N,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(N.prototype,
+"constructor",a.Int16Array,2);
+%AddNamedProperty(N.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+b.InstallGetter(N.prototype,"length",Int16Array_GetLength,
+2|4);
+
+%SetCode(O,Uint32ArrayConstructor);
+%FunctionSetPrototype(O,new i());
+%InternalSetPrototype(O,TypedArray);
+%InternalSetPrototype(O.prototype,TypedArray.prototype);
+%AddNamedProperty(O,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(O.prototype,
+"constructor",a.Uint32Array,2);
+%AddNamedProperty(O.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(O.prototype,"length",Uint32Array_GetLength,
+2|4);
+
+%SetCode(P,Int32ArrayConstructor);
+%FunctionSetPrototype(P,new i());
+%InternalSetPrototype(P,TypedArray);
+%InternalSetPrototype(P.prototype,TypedArray.prototype);
+%AddNamedProperty(P,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(P.prototype,
+"constructor",a.Int32Array,2);
+%AddNamedProperty(P.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(P.prototype,"length",Int32Array_GetLength,
+2|4);
+
+%SetCode(Q,Float32ArrayConstructor);
+%FunctionSetPrototype(Q,new i());
+%InternalSetPrototype(Q,TypedArray);
+%InternalSetPrototype(Q.prototype,TypedArray.prototype);
+%AddNamedProperty(Q,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(Q.prototype,
+"constructor",a.Float32Array,2);
+%AddNamedProperty(Q.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+b.InstallGetter(Q.prototype,"length",Float32Array_GetLength,
+2|4);
+
+%SetCode(R,Float64ArrayConstructor);
+%FunctionSetPrototype(R,new i());
+%InternalSetPrototype(R,TypedArray);
+%InternalSetPrototype(R.prototype,TypedArray.prototype);
+%AddNamedProperty(R,"BYTES_PER_ELEMENT",8,
+1|2|4);
+%AddNamedProperty(R.prototype,
+"constructor",a.Float64Array,2);
+%AddNamedProperty(R.prototype,
+"BYTES_PER_ELEMENT",8,
+1|2|4);
+b.InstallGetter(R.prototype,"length",Float64Array_GetLength,
+2|4);
+
+%SetCode(S,Uint8ClampedArrayConstructor);
+%FunctionSetPrototype(S,new i());
+%InternalSetPrototype(S,TypedArray);
+%InternalSetPrototype(S.prototype,TypedArray.prototype);
+%AddNamedProperty(S,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(S.prototype,
+"constructor",a.Uint8ClampedArray,2);
+%AddNamedProperty(S.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+b.InstallGetter(S.prototype,"length",Uint8ClampedArray_GetLength,
+2|4);
+
+
+function DataViewConstructor(ae,af,am){
+if((new.target===(void 0))){
+throw C(26,"DataView");
+}
+if(!(%_ClassOf(ae)==='ArrayBuffer'))throw C(29);
+if(!(af===(void 0))){
+af=H(af,172);
+}
+if(!(am===(void 0))){
+am=(%_ToInteger(am));
+}
+var ah=%_ArrayBufferGetByteLength(ae);
+var ai=(af===(void 0))?0:af;
+if(ai>ah)throw B(172);
+var ag=(am===(void 0))
+?ah-ai
+:am;
+if(ag<0||ai+ag>ah){
+throw new B(171);
+}
+var aT=%NewObject(h,new.target);
+%_DataViewInitialize(aT,ae,ai,ag);
+return aT;
+}
+function DataViewGetBufferJS(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,'DataView.buffer',this);
+}
+return %DataViewGetBuffer(this);
+}
+function DataViewGetByteOffset(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteOffset',this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function DataViewGetByteLength(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteLength',this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function DataViewGetInt8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt8(this,ai,!!br);
+}
+function DataViewSetInt8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint8(this,ai,!!br);
+}
+function DataViewSetUint8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt16(this,ai,!!br);
+}
+function DataViewSetInt16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint16(this,ai,!!br);
+}
+function DataViewSetUint16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt32(this,ai,!!br);
+}
+function DataViewSetInt32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint32(this,ai,!!br);
+}
+function DataViewSetUint32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat32(this,ai,!!br);
+}
+function DataViewSetFloat32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat64JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat64',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat64(this,ai,!!br);
+}
+function DataViewSetFloat64JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat64',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat64(this,ai,(%_ToNumber(av)),!!br);
+}
+
+
+%SetCode(h,DataViewConstructor);
+%FunctionSetPrototype(h,new i);
+%AddNamedProperty(h.prototype,"constructor",h,
+2);
+%AddNamedProperty(h.prototype,J,"DataView",
+1|2);
+b.InstallGetter(h.prototype,"buffer",DataViewGetBufferJS);
+b.InstallGetter(h.prototype,"byteOffset",
+DataViewGetByteOffset);
+b.InstallGetter(h.prototype,"byteLength",
+DataViewGetByteLength);
+b.InstallFunctions(h.prototype,2,[
+"getInt8",DataViewGetInt8JS,
+"setInt8",DataViewSetInt8JS,
+"getUint8",DataViewGetUint8JS,
+"setUint8",DataViewSetUint8JS,
+"getInt16",DataViewGetInt16JS,
+"setInt16",DataViewSetInt16JS,
+"getUint16",DataViewGetUint16JS,
+"setUint16",DataViewSetUint16JS,
+"getInt32",DataViewGetInt32JS,
+"setInt32",DataViewSetInt32JS,
+"getUint32",DataViewGetUint32JS,
+"setUint32",DataViewSetUint32JS,
+"getFloat32",DataViewGetFloat32JS,
+"setFloat32",DataViewSetFloat32JS,
+"getFloat64",DataViewGetFloat64JS,
+"setFloat64",DataViewSetFloat64JS
+]);
+})
+
+Hiterator-prototypeÑ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+function IteratorPrototypeIterator(){
+return this;
+}
+b.SetFunctionName(IteratorPrototypeIterator,e);
+%AddNamedProperty(d,e,
+IteratorPrototypeIterator,2);
+})
+
+$generator­
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,i);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+return{value:void 0,done:true};
+}else{
+throw f(40);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+try{
+return %_GeneratorThrow(this,k);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+throw k;
+}else{
+throw f(40);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+8object-observeÑ­
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Object;
+var f=b.InternalArray;
+var g;
+b.Import(function(h){
+c=h.GetHash;
+g=h.MakeTypeError;
+});
+var i;
+var j={};
+function GetObservationStateJS(){
+if((i===(void 0))){
+i=%GetObservationState();
+}
+if((i.callbackInfoMap===(void 0))){
+i.callbackInfoMap=%ObservationWeakMapCreate();
+i.objectInfoMap=%ObservationWeakMapCreate();
+i.notifierObjectInfoMap=%ObservationWeakMapCreate();
+i.pendingObservers=null;
+i.nextCallbackPriority=0;
+i.lastMicrotaskId=0;
+}
+return i;
+}
+function GetPendingObservers(){
+return GetObservationStateJS().pendingObservers;
+}
+function SetPendingObservers(k){
+GetObservationStateJS().pendingObservers=k;
+}
+function GetNextCallbackPriority(){
+return GetObservationStateJS().nextCallbackPriority++;
+}
+function nullProtoObject(){
+return{__proto__:null};
+}
+function TypeMapCreate(){
+return nullProtoObject();
+}
+function TypeMapAddType(l,m,n){
+l[m]=n?1:(l[m]||0)+1;
+}
+function TypeMapRemoveType(l,m){
+l[m]--;
+}
+function TypeMapCreateFromList(o,p){
+var l=TypeMapCreate();
+for(var q=0;q<p;q++){
+TypeMapAddType(l,o[q],true);
+}
+return l;
+}
+function TypeMapHasType(l,m){
+return!!l[m];
+}
+function TypeMapIsDisjointFrom(r,s){
+if(!r||!s)
+return true;
+for(var m in r){
+if(TypeMapHasType(r,m)&&TypeMapHasType(s,m))
+return false;
+}
+return true;
+}
+var t=(function(){
+var u=[
+'add',
+'update',
+'delete',
+'setPrototype',
+'reconfigure',
+'preventExtensions'
+];
+return TypeMapCreateFromList(u,u.length);
+})();
+function ObserverCreate(v,w){
+if((w===(void 0)))
+return v;
+var x=nullProtoObject();
+x.callback=v;
+x.accept=w;
+return x;
+}
+function ObserverGetCallback(x){
+return(typeof(x)==='function')?x:x.callback;
+}
+function ObserverGetAcceptTypes(x){
+return(typeof(x)==='function')?t:x.accept;
+}
+function ObserverIsActive(x,y){
+return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(y),
+ObserverGetAcceptTypes(x));
+}
+function ObjectInfoGetOrCreate(z){
+var y=ObjectInfoGet(z);
+if((y===(void 0))){
+if(!(%_IsJSProxy(z))){
+%SetIsObserved(z);
+}
+y={
+object:z,
+changeObservers:null,
+notifier:null,
+performing:null,
+performingCount:0,
+};
+%WeakCollectionSet(GetObservationStateJS().objectInfoMap,
+z,y,c(z));
+}
+return y;
+}
+function ObjectInfoGet(z){
+return %WeakCollectionGet(GetObservationStateJS().objectInfoMap,z,
+c(z));
+}
+function ObjectInfoGetFromNotifier(A){
+return %WeakCollectionGet(GetObservationStateJS().notifierObjectInfoMap,
+A,c(A));
+}
+function ObjectInfoGetNotifier(y){
+if((y.notifier===null)){
+var A={__proto__:j};
+y.notifier=A;
+%WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
+A,y,c(A));
+}
+return y.notifier;
+}
+function ChangeObserversIsOptimized(B){
+return(typeof(B)==='function')||
+(typeof(B.callback)==='function');
+}
+function ObjectInfoNormalizeChangeObservers(y){
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+var v=ObserverGetCallback(x);
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers=nullProtoObject();
+y.changeObservers[D]=x;
+}
+}
+function ObjectInfoAddObserver(y,v,w){
+var C=CallbackInfoGetOrCreate(v);
+var x=ObserverCreate(v,w);
+if(!y.changeObservers){
+y.changeObservers=x;
+return;
+}
+ObjectInfoNormalizeChangeObservers(y);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=x;
+}
+function ObjectInfoRemoveObserver(y,v){
+if(!y.changeObservers)
+return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+if(v===ObserverGetCallback(y.changeObservers))
+y.changeObservers=null;
+return;
+}
+var C=CallbackInfoGet(v);
+var D=CallbackInfoGetPriority(C);
+y.changeObservers[D]=null;
+}
+function ObjectInfoHasActiveObservers(y){
+if((y===(void 0))||!y.changeObservers)
+return false;
+if(ChangeObserversIsOptimized(y.changeObservers))
+return ObserverIsActive(y.changeObservers,y);
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if(!(x===null)&&ObserverIsActive(x,y))
+return true;
+}
+return false;
+}
+function ObjectInfoAddPerformingType(y,m){
+y.performing=y.performing||TypeMapCreate();
+TypeMapAddType(y.performing,m);
+y.performingCount++;
+}
+function ObjectInfoRemovePerformingType(y,m){
+y.performingCount--;
+TypeMapRemoveType(y.performing,m);
+}
+function ObjectInfoGetPerformingTypes(y){
+return y.performingCount>0?y.performing:null;
+}
+function ConvertAcceptListToTypeMap(E){
+if((E===(void 0)))
+return E;
+if(!(%_IsJSReceiver(E)))throw g(80);
+var F=(%_ToInteger(E.length));
+if(F<0)F=0;
+return TypeMapCreateFromList(E,F);
+}
+function CallbackInfoGet(v){
+return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap,v,
+c(v));
+}
+function CallbackInfoSet(v,C){
+%WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+v,C,c(v));
+}
+function CallbackInfoGetOrCreate(v){
+var C=CallbackInfoGet(v);
+if(!(C===(void 0)))
+return C;
+var D=GetNextCallbackPriority();
+CallbackInfoSet(v,D);
+return D;
+}
+function CallbackInfoGetPriority(C){
+if((typeof(C)==='number'))
+return C;
+else
+return C.priority;
+}
+function CallbackInfoNormalize(v){
+var C=CallbackInfoGet(v);
+if((typeof(C)==='number')){
+var D=C;
+C=new f;
+C.priority=D;
+CallbackInfoSet(v,C);
+}
+return C;
+}
+function ObjectObserve(z,v,w){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"observe","observe");
+if(%IsJSGlobalProxy(z))
+throw g(78,"observe");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"observe");
+if(!(typeof(v)==='function'))
+throw g(81,"observe");
+if(%object_is_frozen(v))
+throw g(77);
+var G=%GetObjectContextObjectObserve(z);
+return G(z,v,w);
+}
+function NativeObjectObserve(z,v,w){
+var y=ObjectInfoGetOrCreate(z);
+var o=ConvertAcceptListToTypeMap(w);
+ObjectInfoAddObserver(y,v,o);
+return z;
+}
+function ObjectUnobserve(z,v){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"unobserve","unobserve");
+if(%IsJSGlobalProxy(z))
+throw g(78,"unobserve");
+if(!(typeof(v)==='function'))
+throw g(81,"unobserve");
+var y=ObjectInfoGet(z);
+if((y===(void 0)))
+return z;
+ObjectInfoRemoveObserver(y,v);
+return z;
+}
+function ArrayObserve(z,v){
+return ObjectObserve(z,v,['add',
+'update',
+'delete',
+'splice']);
+}
+function ArrayUnobserve(z,v){
+return ObjectUnobserve(z,v);
+}
+function ObserverEnqueueIfActive(x,y,H){
+if(!ObserverIsActive(x,y)||
+!TypeMapHasType(ObserverGetAcceptTypes(x),H.type)){
+return;
+}
+var v=ObserverGetCallback(x);
+if(!%ObserverObjectAndRecordHaveSameOrigin(v,H.object,
+H)){
+return;
+}
+var C=CallbackInfoNormalize(v);
+if((GetPendingObservers()===null)){
+SetPendingObservers(nullProtoObject());
+if((%_DebugIsActive()!=0)){
+var I=++GetObservationStateJS().lastMicrotaskId;
+var J="Object.observe";
+%EnqueueMicrotask(function(){
+%DebugAsyncTaskEvent({type:"willHandle",id:I,name:J});
+ObserveMicrotaskRunner();
+%DebugAsyncTaskEvent({type:"didHandle",id:I,name:J});
+});
+%DebugAsyncTaskEvent({type:"enqueue",id:I,name:J});
+}else{
+%EnqueueMicrotask(ObserveMicrotaskRunner);
+}
+}
+GetPendingObservers()[C.priority]=v;
+C.push(H);
+}
+function ObjectInfoEnqueueExternalChangeRecord(y,H,m){
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var K=!(m===(void 0));
+var L=K?
+{object:y.object,type:m}:
+{object:y.object};
+for(var M in H){
+if(M==='object'||(K&&M==='type'))continue;
+%DefineDataPropertyUnchecked(
+L,M,H[M],1+4);
+}
+%object_freeze(L);
+ObjectInfoEnqueueInternalChangeRecord(y,L);
+}
+function ObjectInfoEnqueueInternalChangeRecord(y,H){
+if((typeof(H.name)==='symbol'))return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+ObserverEnqueueIfActive(x,y,H);
+return;
+}
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if((x===null))
+continue;
+ObserverEnqueueIfActive(x,y,H);
+}
+}
+function BeginPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoAddPerformingType(y,'splice');
+}
+function EndPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoRemovePerformingType(y,'splice');
+}
+function EnqueueSpliceRecord(N,O,P,Q){
+var y=ObjectInfoGet(N);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H={
+type:'splice',
+object:N,
+index:O,
+removed:P,
+addedCount:Q
+};
+%object_freeze(H);
+%object_freeze(H.removed);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function NotifyChange(m,z,J,R){
+var y=ObjectInfoGet(z);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H;
+if(arguments.length==2){
+H={type:m,object:z};
+}else if(arguments.length==3){
+H={type:m,object:z,name:J};
+}else{
+H={
+type:m,
+object:z,
+name:J,
+oldValue:R
+};
+}
+%object_freeze(H);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function ObjectNotifierNotify(H){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"notify");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(H.type)==='string'))
+throw g(86);
+ObjectInfoEnqueueExternalChangeRecord(y,H);
+}
+function ObjectNotifierPerformChange(S,T){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"performChange");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(S)==='string'))
+throw g(85);
+if(!(typeof(T)==='function'))
+throw g(84);
+var U=%GetObjectContextNotifierPerformChange(y);
+U(y,S,T);
+}
+function NativeObjectNotifierPerformChange(y,S,T){
+ObjectInfoAddPerformingType(y,S);
+var H;
+try{
+H=T();
+}finally{
+ObjectInfoRemovePerformingType(y,S);
+}
+if((%_IsJSReceiver(H)))
+ObjectInfoEnqueueExternalChangeRecord(y,H,S);
+}
+function ObjectGetNotifier(z){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"getNotifier","getNotifier");
+if(%IsJSGlobalProxy(z))
+throw g(78,"getNotifier");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"getNotifier");
+if(%object_is_frozen(z))return null;
+if(!%ObjectWasCreatedInCurrentOrigin(z))return null;
+var V=%GetObjectContextObjectGetNotifier(z);
+return V(z);
+}
+function NativeObjectGetNotifier(z){
+var y=ObjectInfoGetOrCreate(z);
+return ObjectInfoGetNotifier(y);
+}
+function CallbackDeliverPending(v){
+var C=CallbackInfoGet(v);
+if((C===(void 0))||(typeof(C)==='number'))
+return false;
+var D=C.priority;
+CallbackInfoSet(v,D);
+var k=GetPendingObservers();
+if(!(k===null))
+delete k[D];
+var W=[];
+%MoveArrayContents(C,W);
+%DeliverObservationChangeRecords(v,W);
+return true;
+}
+function ObjectDeliverChangeRecords(v){
+if(!(typeof(v)==='function'))
+throw g(81,"deliverChangeRecords");
+while(CallbackDeliverPending(v)){}
+}
+function ObserveMicrotaskRunner(){
+var k=GetPendingObservers();
+if(!(k===null)){
+SetPendingObservers(null);
+for(var q in k){
+CallbackDeliverPending(k[q]);
+}
+}
+}
+b.InstallFunctions(j,2,[
+"notify",ObjectNotifierNotify,
+"performChange",ObjectNotifierPerformChange
+]);
+var X=[
+"deliverChangeRecords",ObjectDeliverChangeRecords,
+"getNotifier",ObjectGetNotifier,
+"observe",ObjectObserve,
+"unobserve",ObjectUnobserve
+];
+var Y=[
+"observe",ArrayObserve,
+"unobserve",ArrayUnobserve
+];
+var Z=function(aa,q){
+if(q % 2===1)%FunctionRemovePrototype(aa);
+};
+X.forEach(Z);
+Y.forEach(Z);
+%InstallToContext([
+"native_object_get_notifier",NativeObjectGetNotifier,
+"native_object_notifier_perform_change",NativeObjectNotifierPerformChange,
+"native_object_observe",NativeObjectObserve,
+"observers_begin_perform_splice",BeginPerformSplice,
+"observers_end_perform_splice",EndPerformSplice,
+"observers_enqueue_splice",EnqueueSpliceRecord,
+"observers_notify_change",NotifyChange,
+]);
+b.Export(function(ab){
+ab.ObserveArrayMethods=Y;
+ab.ObserveBeginPerformSplice=BeginPerformSplice;
+ab.ObserveEndPerformSplice=EndPerformSplice;
+ab.ObserveEnqueueSpliceRecord=EnqueueSpliceRecord;
+ab.ObserveObjectMethods=X;
+});
+})
+
+(collectionE}
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Object;
+var e=a.Set;
+var f=b.ImportNow("hash_code_symbol");
+var g;
+var h;
+var i;
+var j;
+var k;
+var l=b.ImportNow("to_string_tag_symbol");
+b.Import(function(m){
+g=m.IntRandom;
+h=m.MakeTypeError;
+i=m.MapIterator;
+j=m.NumberIsNaN;
+k=m.SetIterator;
+});
+function HashToEntry(n,o,p){
+var q=(o&((p)-1));
+return((%_FixedArrayGet(n,(3+(q))|0)));
+}
+%SetForceInlineFlag(HashToEntry);
+function SetFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)<<1))+1)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(SetFindEntry);
+function MapFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)*3))+2)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(MapFindEntry);
+function ComputeIntegerHash(r,v){
+var o=r;
+o=o^v;
+o=~o+(o<<15);
+o=o^(o>>>12);
+o=o+(o<<2);
+o=o^(o>>>4);
+o=(o*2057)|0;
+o=o^(o>>>16);
+return o&0x3fffffff;
+}
+%SetForceInlineFlag(ComputeIntegerHash);
+function GetExistingHash(r){
+if(%_IsSmi(r)){
+return ComputeIntegerHash(r,0);
+}
+if((typeof(r)==='string')){
+var w=%_StringGetRawHashField(r);
+if((w&1)===0){
+return w>>>2;
+}
+}else if((%_IsJSReceiver(r))&&!(%_IsJSProxy(r))&&!(%_ClassOf(r)==='global')){
+var o=(r[f]);
+return o;
+}
+return %GenericHash(r);
+}
+%SetForceInlineFlag(GetExistingHash);
+function GetHash(r){
+var o=GetExistingHash(r);
+if((o===(void 0))){
+o=g()|0;
+if(o===0)o=1;
+(r[f]=o);
+}
+return o;
+}
+%SetForceInlineFlag(GetHash);
+function SetConstructor(x){
+if((new.target===(void 0))){
+throw h(26,"Set");
+}
+%_SetInitialize(this);
+if(!(x==null)){
+var y=this.add;
+if(!(typeof(y)==='function')){
+throw h(91,y,'add',this);
+}
+for(var z of x){
+%_Call(y,this,z);
+}
+}
+}
+function SetAdd(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.add',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+if(SetFindEntry(n,p,r,o)!==-1)return this;
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%SetGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+var s=A+B;
+var D=(3+(p)+((s)<<1));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+((%_FixedArraySet(n,(D+1)|0,(E)|0)));
+return this;
+}
+function SetHas(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+return SetFindEntry(n,p,r,o)!==-1;
+}
+function SetDelete(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+var s=SetFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)<<1));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%SetShrink(this);
+return true;
+}
+function SetGetSize(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function SetClearJS(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.clear',this);
+}
+%_SetClear(this);
+}
+function SetForEach(F,G){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new k(this,2);
+var r;
+var I=[(void 0)];
+while(%SetIteratorNext(H,I)){
+r=I[0];
+%_Call(F,G,r,r,this);
+}
+}
+%SetCode(e,SetConstructor);
+%FunctionSetLength(e,0);
+%FunctionSetPrototype(e,new d());
+%AddNamedProperty(e.prototype,"constructor",e,2);
+%AddNamedProperty(e.prototype,l,"Set",
+2|1);
+%FunctionSetLength(SetForEach,1);
+b.InstallGetter(e.prototype,"size",SetGetSize);
+b.InstallFunctions(e.prototype,2,[
+"add",SetAdd,
+"has",SetHas,
+"delete",SetDelete,
+"clear",SetClearJS,
+"forEach",SetForEach
+]);
+function MapConstructor(x){
+if((new.target===(void 0))){
+throw h(26,"Map");
+}
+%_MapInitialize(this);
+if(!(x==null)){
+var y=this.set;
+if(!(typeof(y)==='function')){
+throw h(91,y,'set',this);
+}
+for(var J of x){
+if(!(%_IsJSReceiver(J))){
+throw h(49,J);
+}
+%_Call(y,this,J[0],J[1]);
+}
+}
+}
+function MapGet(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.get',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return(void 0);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return(void 0);
+return((%_FixedArrayGet(n,((3+(p)+((s)*3))+1)|0)));
+}
+function MapSet(r,z){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.set',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s!==-1){
+var K=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(K+1)|0,z));
+return this;
+}
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%MapGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+s=A+B;
+var D=(3+(p)+((s)*3));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+(%_FixedArraySet(n,(D+1)|0,z));
+(%_FixedArraySet(n,(D+2)|0,E));
+return this;
+}
+function MapHas(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+return MapFindEntry(n,p,r,o)!==-1;
+}
+function MapDelete(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(%_FixedArraySet(n,(D+1)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%MapShrink(this);
+return true;
+}
+function MapGetSize(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function MapClearJS(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.clear',this);
+}
+%_MapClear(this);
+}
+function MapForEach(F,G){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new i(this,3);
+var I=[(void 0),(void 0)];
+while(%MapIteratorNext(H,I)){
+%_Call(F,G,I[1],I[0],this);
+}
+}
+%SetCode(c,MapConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new d());
+%AddNamedProperty(c.prototype,"constructor",c,2);
+%AddNamedProperty(
+c.prototype,l,"Map",2|1);
+%FunctionSetLength(MapForEach,1);
+b.InstallGetter(c.prototype,"size",MapGetSize);
+b.InstallFunctions(c.prototype,2,[
+"get",MapGet,
+"set",MapSet,
+"has",MapHas,
+"delete",MapDelete,
+"clear",MapClearJS,
+"forEach",MapForEach
+]);
+%InstallToContext([
+"map_get",MapGet,
+"map_set",MapSet,
+"map_has",MapHas,
+"map_delete",MapDelete,
+"set_add",SetAdd,
+"set_has",SetHas,
+"set_delete",SetDelete,
+]);
+b.Export(function(L){
+L.GetExistingHash=GetExistingHash;
+L.GetHash=GetHash;
+});
+})
+
+<weak-collectionÕ-
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e=a.Object;
+var f=a.WeakMap;
+var g=a.WeakSet;
+var h;
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+c=j.GetExistingHash;
+d=j.GetHash;
+h=j.MakeTypeError;
+});
+function WeakMapConstructor(k){
+if((new.target===(void 0))){
+throw h(26,"WeakMap");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.set;
+if(!(typeof(l)==='function')){
+throw h(91,l,'set',this);
+}
+for(var m of k){
+if(!(%_IsJSReceiver(m))){
+throw h(49,m);
+}
+%_Call(l,this,m[0],m[1]);
+}
+}
+}
+function WeakMapGet(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.get',this);
+}
+if(!(%_IsJSReceiver(n)))return(void 0);
+var o=c(n);
+if((o===(void 0)))return(void 0);
+return %WeakCollectionGet(this,n,o);
+}
+function WeakMapSet(n,p){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.set',this);
+}
+if(!(%_IsJSReceiver(n)))throw h(175);
+return %WeakCollectionSet(this,n,p,d(n));
+}
+function WeakMapHas(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.has',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,n,o);
+}
+function WeakMapDelete(n){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw h(42,
+'WeakMap.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(n)))return false;
+var o=c(n);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,n,o);
+}
+%SetCode(f,WeakMapConstructor);
+%FunctionSetLength(f,0);
+%FunctionSetPrototype(f,new e());
+%AddNamedProperty(f.prototype,"constructor",f,
+2);
+%AddNamedProperty(f.prototype,i,"WeakMap",
+2|1);
+b.InstallFunctions(f.prototype,2,[
+"get",WeakMapGet,
+"set",WeakMapSet,
+"has",WeakMapHas,
+"delete",WeakMapDelete
+]);
+function WeakSetConstructor(k){
+if((new.target===(void 0))){
+throw h(26,"WeakSet");
+}
+%WeakCollectionInitialize(this);
+if(!(k==null)){
+var l=this.add;
+if(!(typeof(l)==='function')){
+throw h(91,l,'add',this);
+}
+for(var p of k){
+%_Call(l,this,p);
+}
+}
+}
+function WeakSetAdd(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.add',this);
+}
+if(!(%_IsJSReceiver(p)))throw h(176);
+return %WeakCollectionSet(this,p,true,d(p));
+}
+function WeakSetHas(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.has',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionHas(this,p,o);
+}
+function WeakSetDelete(p){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw h(42,
+'WeakSet.prototype.delete',this);
+}
+if(!(%_IsJSReceiver(p)))return false;
+var o=c(p);
+if((o===(void 0)))return false;
+return %WeakCollectionDelete(this,p,o);
+}
+%SetCode(g,WeakSetConstructor);
+%FunctionSetLength(g,0);
+%FunctionSetPrototype(g,new e());
+%AddNamedProperty(g.prototype,"constructor",g,
+2);
+%AddNamedProperty(g.prototype,i,"WeakSet",
+2|1);
+b.InstallFunctions(g.prototype,2,[
+"add",WeakSetAdd,
+"has",WeakSetHas,
+"delete",WeakSetDelete
+]);
+})
+
+Lcollection-iterator(
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Set;
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=b.ImportNow("MapIterator");
+var h=b.ImportNow("to_string_tag_symbol");
+var i=b.ImportNow("SetIterator");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function SetIteratorConstructor(k,l){
+%SetIteratorInitialize(this,k,l);
+}
+function SetIteratorNextJS(){
+if(!(%_ClassOf(this)==='Set Iterator')){
+throw f(42,
+'Set Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%SetIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 2:
+n.value=m[0];
+break;
+case 3:
+m[1]=m[0];
+break;
+}
+return n;
+}
+function SetEntries(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(42,
+'Set.prototype.entries',this);
+}
+return new i(this,3);
+}
+function SetValues(){
+if(!(%_ClassOf(this)==='Set')){
+throw f(42,
+'Set.prototype.values',this);
+}
+return new i(this,2);
+}
+%SetCode(i,SetIteratorConstructor);
+%FunctionSetInstanceClassName(i,'Set Iterator');
+b.InstallFunctions(i.prototype,2,[
+'next',SetIteratorNextJS
+]);
+%AddNamedProperty(i.prototype,h,
+"Set Iterator",1|2);
+b.InstallFunctions(d.prototype,2,[
+'entries',SetEntries,
+'keys',SetValues,
+'values',SetValues
+]);
+%AddNamedProperty(d.prototype,e,SetValues,2);
+function MapIteratorConstructor(o,l){
+%MapIteratorInitialize(this,o,l);
+}
+function MapIteratorNextJS(){
+if(!(%_ClassOf(this)==='Map Iterator')){
+throw f(42,
+'Map Iterator.prototype.next',this);
+}
+var m=[(void 0),(void 0)];
+var n=%_CreateIterResultObject(m,false);
+switch(%MapIteratorNext(this,m)){
+case 0:
+n.value=(void 0);
+n.done=true;
+break;
+case 1:
+n.value=m[0];
+break;
+case 2:
+n.value=m[1];
+break;
+}
+return n;
+}
+function MapEntries(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.entries',this);
+}
+return new g(this,3);
+}
+function MapKeys(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.keys',this);
+}
+return new g(this,1);
+}
+function MapValues(){
+if(!(%_ClassOf(this)==='Map')){
+throw f(42,
+'Map.prototype.values',this);
+}
+return new g(this,2);
+}
+%SetCode(g,MapIteratorConstructor);
+%FunctionSetInstanceClassName(g,'Map Iterator');
+b.InstallFunctions(g.prototype,2,[
+'next',MapIteratorNextJS
+]);
+%AddNamedProperty(g.prototype,h,
+"Map Iterator",1|2);
+b.InstallFunctions(c.prototype,2,[
+'entries',MapEntries,
+'keys',MapKeys,
+'values',MapValues
+]);
+%AddNamedProperty(c.prototype,e,MapEntries,2);
+b.Export(function(p){
+p.MapEntries=MapEntries;
+p.MapIteratorNext=MapIteratorNextJS;
+p.SetIteratorNext=SetIteratorNextJS;
+p.SetValues=SetValues;
+});
+})
+
+promiseQs
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=b.InternalArray;
+var e;
+var f=
+b.ImportNow("promise_combined_deferred_symbol");
+var g=
+b.ImportNow("promise_has_handler_symbol");
+var h=b.ImportNow("promise_on_reject_symbol");
+var i=
+b.ImportNow("promise_on_resolve_symbol");
+var j=b.ImportNow("promise_raw_symbol");
+var k=b.ImportNow("promise_status_symbol");
+var l=b.ImportNow("promise_value_symbol");
+var m;
+var n=b.ImportNow("to_string_tag_symbol");
+b.Import(function(o){
+e=o.MakeTypeError;
+m=o.SpeciesConstructor;
+});
+var p=0;
+function CreateResolvingFunctions(q){
+var r=false;
+var s=value=>{
+if(r===true)return;
+r=true;
+PromiseResolve(q,value);
+};
+var t=reason=>{
+if(r===true)return;
+r=true;
+PromiseReject(q,reason);
+};
+return{
+__proto__:null,
+resolve:s,
+reject:t
+};
+}
+var u=function Promise(v){
+if(v===j){
+return %NewObject(u,new.target);
+}
+if((new.target===(void 0)))throw e(61,this);
+if(!(typeof(v)==='function'))
+throw e(134,v);
+var q=PromiseInit(%NewObject(u,new.target));
+var w=CreateResolvingFunctions(q);
+try{
+%DebugPushPromise(q,Promise);
+v(w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}finally{
+%DebugPopPromise();
+}
+return q;
+}
+function PromiseSet(q,x,y,z,A){
+(q[k]=x);
+(q[l]=y);
+(q[i]=z);
+(q[h]=A);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:q,status:x,value:y});
+}
+return q;
+}
+function PromiseCreateAndSet(x,y){
+var q=new u(j);
+if((%_DebugIsActive()!=0))PromiseSet(q,0,(void 0));
+return PromiseSet(q,x,y);
+}
+function PromiseInit(q){
+return PromiseSet(
+q,0,(void 0),new d,new d)
+}
+function PromiseDone(q,x,y,B){
+if((q[k])===0){
+var C=(q[B]);
+if(C.length)PromiseEnqueue(y,C,x);
+PromiseSet(q,x,y);
+}
+}
+function PromiseHandle(y,D,E){
+try{
+%DebugPushPromise(E.promise,PromiseHandle);
+var F=D(y);
+E.resolve(F);
+}catch(exception){
+try{E.reject(exception);}catch(e){}
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseEnqueue(y,C,x){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+for(var J=0;J<C.length;J+=2){
+PromiseHandle(y,C[J],C[J+1])
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H=x>0?"Promise.resolve":"Promise.reject";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+}
+function PromiseIdResolveHandler(K){return K}
+function PromiseIdRejectHandler(L){throw L}
+function PromiseNopResolver(){}
+function IsPromise(K){
+return(%_IsJSReceiver(K))&&(!(K[k]===(void 0)));
+}
+function PromiseCreate(){
+return new u(PromiseNopResolver)
+}
+function PromiseResolve(q,K){
+if(K===q){
+return PromiseReject(q,e(88,K));
+}
+if((%_IsJSReceiver(K))){
+try{
+var M=K.then;
+}catch(e){
+return PromiseReject(q,e);
+}
+if((typeof(M)==='function')){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+var w=CreateResolvingFunctions(q);
+try{
+%_Call(M,K,w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H="PromseResolveThenableJob";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+return;
+}
+}
+PromiseDone(q,+1,K,i);
+}
+function PromiseReject(q,L){
+if((q[k])==0){
+var N=(%_DebugIsActive()!=0);
+if(N||
+!(!(q[g]===(void 0)))){
+%PromiseRejectEvent(q,L,N);
+}
+}
+PromiseDone(q,-1,L,h)
+}
+function NewPromiseCapability(O){
+if(O===u){
+var q=PromiseInit(new u(j));
+var w=CreateResolvingFunctions(q);
+return{
+promise:q,
+resolve:w.resolve,
+reject:w.reject
+};
+}
+var F={promise:(void 0),resolve:(void 0),reject:(void 0)};
+F.promise=new O((s,t)=>{
+if(!(F.resolve===(void 0))||!(F.reject===(void 0)))
+throw e(89);
+F.resolve=s;
+F.reject=t;
+});
+return F;
+}
+function PromiseDeferred(){
+%IncrementUseCounter(19);
+return NewPromiseCapability(this);
+}
+function PromiseResolved(K){
+%IncrementUseCounter(18);
+return %_Call(PromiseCast,this,K);
+}
+function PromiseRejected(L){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRejected);
+}
+if(this===u){
+var q=PromiseCreateAndSet(-1,L);
+%PromiseRejectEvent(q,L,false);
+return q;
+}else{
+var P=NewPromiseCapability(this);
+%_Call(P.reject,(void 0),L);
+return P.promise;
+}
+}
+function PromiseThen(z,A){
+var x=(this[k]);
+if((x===(void 0))){
+throw e(61,this);
+}
+var Q=m(this,u);
+z=(typeof(z)==='function')?z:PromiseIdResolveHandler;
+A=(typeof(A)==='function')?A:PromiseIdRejectHandler;
+var E=NewPromiseCapability(Q);
+switch(x){
+case 0:
+(this[i]).push(z,E);
+(this[h]).push(A,E);
+break;
+case+1:
+PromiseEnqueue((this[l]),
+[z,E],
++1);
+break;
+case-1:
+if(!(!(this[g]===(void 0)))){
+%PromiseRevokeReject(this);
+}
+PromiseEnqueue((this[l]),
+[A,E],
+-1);
+break;
+}
+(this[g]=true);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:E.promise,parentPromise:this});
+}
+return E.promise;
+}
+function PromiseChain(z,A){
+%IncrementUseCounter(17);
+return %_Call(PromiseThen,this,z,A);
+}
+function PromiseCatch(A){
+return this.then((void 0),A);
+}
+function PromiseCast(K){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseCast);
+}
+if(IsPromise(K)&&K.constructor===this)return K;
+var P=NewPromiseCapability(this);
+var R=%_Call(P.resolve,(void 0),K);
+return P.promise;
+}
+function PromiseAll(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,"Promise.all");
+}
+var E=NewPromiseCapability(this);
+var T=new d();
+var U;
+function CreateResolveElementFunction(V,W,P){
+var X=false;
+return(K)=>{
+if(X===true)return;
+X=true;
+W[V]=K;
+if(--U===0){
+var Y=[];
+%MoveArrayContents(W,Y);
+%_Call(P.resolve,(void 0),Y);
+}
+};
+}
+try{
+var J=0;
+U=1;
+for(var y of S){
+var Z=this.resolve(y);
+++U;
+Z.then(
+CreateResolveElementFunction(J,T,E),
+E.reject);
+(E.reject[f]=E);
+++J;
+}
+if(--U===0){
+var Y=[];
+%MoveArrayContents(T,Y);
+%_Call(E.resolve,(void 0),Y);
+}
+}catch(e){
+%_Call(E.reject,(void 0),e);
+}
+return E.promise;
+}
+function PromiseRace(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRace);
+}
+var E=NewPromiseCapability(this);
+try{
+for(var y of S){
+this.resolve(y).then(E.resolve,E.reject);
+(E.reject[f]=E);
+}
+}catch(e){
+E.reject(e)
+}
+return E.promise;
+}
+function PromiseHasUserDefinedRejectHandlerRecursive(q){
+var aa=(q[h]);
+if((aa===(void 0)))return false;
+for(var J=0;J<aa.length;J+=2){
+var D=aa[J];
+if(D!==PromiseIdRejectHandler){
+var E=(D[f]);
+if((E===(void 0)))return true;
+if(PromiseHasUserDefinedRejectHandlerRecursive(E.promise)){
+return true;
+}
+}else if(PromiseHasUserDefinedRejectHandlerRecursive(
+aa[J+1].promise)){
+return true;
+}
+}
+return false;
+}
+function PromiseHasUserDefinedRejectHandler(){
+return PromiseHasUserDefinedRejectHandlerRecursive(this);
+};
+%AddNamedProperty(a,'Promise',u,2);
+%AddNamedProperty(u.prototype,n,"Promise",
+2|1);
+b.InstallFunctions(u,2,[
+"reject",PromiseRejected,
+"all",PromiseAll,
+"race",PromiseRace,
+"resolve",PromiseCast
+]);
+b.InstallFunctions(u.prototype,2,[
+"then",PromiseThen,
+"catch",PromiseCatch
+]);
+%InstallToContext([
+"promise_catch",PromiseCatch,
+"promise_chain",PromiseChain,
+"promise_create",PromiseCreate,
+"promise_has_user_defined_reject_handler",PromiseHasUserDefinedRejectHandler,
+"promise_reject",PromiseReject,
+"promise_resolve",PromiseResolve,
+"promise_then",PromiseThen,
+]);
+b.InstallFunctions(c,0,[
+"createPromise",PromiseCreate,
+"resolvePromise",PromiseResolve,
+"rejectPromise",PromiseReject
+]);
+[PromiseChain,PromiseDeferred,PromiseResolved].forEach(
+fn=>%FunctionRemovePrototype(fn));
+b.Export(function(ab){
+ab.PromiseChain=PromiseChain;
+ab.PromiseDeferred=PromiseDeferred;
+ab.PromiseResolved=PromiseResolved;
+});
+})
+
+ messages�á
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g=
+b.ImportNow("call_site_receiver_symbol");
+var h=
+b.ImportNow("call_site_function_symbol");
+var i=
+b.ImportNow("call_site_position_symbol");
+var j=
+b.ImportNow("call_site_strict_symbol");
+var k;
+var l;
+var m=
+b.ImportNow("formatted_stack_trace_symbol");
+var n=a.Object;
+var o;
+var p;
+var q;
+var r=b.InternalArray;
+var s=b.ImportNow("internal_error_symbol");
+var t;
+var u=b.ImportNow("object_to_string");
+var v=b.ImportNow("Script");
+var w=b.ImportNow("stack_trace_symbol");
+var x;
+var y;
+var z;
+var A;
+var B=b.ImportNow("to_string_tag_symbol");
+var C;
+var D;
+var E;
+b.Import(function(F){
+c=F.ArrayJoin;
+d=F.Bool16x8ToString;
+e=F.Bool32x4ToString;
+f=F.Bool8x16ToString;
+l=F.Float32x4ToString;
+o=F.Int16x8ToString;
+p=F.Int32x4ToString;
+q=F.Int8x16ToString;
+t=F.ObjectDefineProperty;
+x=F.StringCharAt;
+y=F.StringIndexOf;
+z=F.StringSubstring;
+A=F.SymbolToString;
+C=F.Uint16x8ToString;
+D=F.Uint32x4ToString;
+E=F.Uint8x16ToString;
+});
+b.ImportFromExperimental(function(F){
+k=F.FLAG_harmony_tostring;
+});
+var G;
+var H;
+var I;
+var J;
+var K;
+var L;
+var M;
+function NoSideEffectsObjectToString(){
+if((this===(void 0)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+var N=(%_ToObject(this));
+var O=%_ClassOf(N);
+var P;
+if(k){
+P=%GetDataProperty(N,B);
+if(!(typeof(P)==='string')){
+P=O;
+}
+}else{
+P=O;
+}
+return`[object ${P}]`;
+}
+function IsErrorObject(Q){
+return(%HasOwnProperty(Q,w));
+}
+function NoSideEffectsErrorToString(){
+var R=%GetDataProperty(this,"name");
+var S=%GetDataProperty(this,"message");
+R=(R===(void 0))?"Error":NoSideEffectsToString(R);
+S=(S===(void 0))?"":NoSideEffectsToString(S);
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`;
+}
+function NoSideEffectsToString(Q){
+if((typeof(Q)==='string'))return Q;
+if((typeof(Q)==='number'))return %_NumberToString(Q);
+if((typeof(Q)==='boolean'))return Q?'true':'false';
+if((Q===(void 0)))return'undefined';
+if((Q===null))return'null';
+if((%_IsFunction(Q))){
+var T=%FunctionToString(Q);
+if(T.length>128){
+T=%_SubString(T,0,111)+"...<omitted>..."+
+%_SubString(T,T.length-2,T.length);
+}
+return T;
+}
+if((typeof(Q)==='symbol'))return %_Call(A,Q);
+if((%_IsSimdValue(Q))){
+switch(typeof(Q)){
+case'float32x4':return %_Call(l,Q);
+case'int32x4':return %_Call(p,Q);
+case'int16x8':return %_Call(o,Q);
+case'int8x16':return %_Call(q,Q);
+case'uint32x4':return %_Call(D,Q);
+case'uint16x8':return %_Call(C,Q);
+case'uint8x16':return %_Call(E,Q);
+case'bool32x4':return %_Call(e,Q);
+case'bool16x8':return %_Call(d,Q);
+case'bool8x16':return %_Call(f,Q);
+}
+}
+if((%_IsJSReceiver(Q))){
+if(IsErrorObject(Q)||
+%GetDataProperty(Q,"toString")===ErrorToString){
+return %_Call(NoSideEffectsErrorToString,Q);
+}
+if(%GetDataProperty(Q,"toString")===u){
+var U=%GetDataProperty(Q,"constructor");
+if((%_IsFunction(U))){
+var V=%FunctionGetName(U);
+if(V!="")return`#<${V}>`;
+}
+}
+}
+return %_Call(NoSideEffectsObjectToString,Q);
+}
+function MakeGenericError(U,W,X,Y,Z){
+var aa=new U(FormatMessage(W,X,Y,Z));
+aa[s]=true;
+return aa;
+}
+%FunctionSetInstanceClassName(v,'Script');
+%AddNamedProperty(v.prototype,'constructor',v,
+2|4|1);
+%SetCode(v,function(ab){
+throw MakeError(6);
+});
+function FormatMessage(W,X,Y,Z){
+var X=NoSideEffectsToString(X);
+var Y=NoSideEffectsToString(Y);
+var Z=NoSideEffectsToString(Z);
+try{
+return %FormatMessageString(W,X,Y,Z);
+}catch(e){
+return"<error>";
+}
+}
+function GetLineNumber(S){
+var ac=%MessageGetStartPosition(S);
+if(ac==-1)return 0;
+var ad=%MessageGetScript(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return 0;
+return ae.line+1;
+}
+function GetColumnNumber(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return-1;
+return ae.column;
+}
+function GetSourceLine(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return"";
+return ae.sourceText();
+}
+function ScriptLineFromPosition(af){
+var ag=0;
+var ah=this.lineCount()-1;
+var ai=this.line_ends;
+if(af>ai[ah]){
+return-1;
+}
+if(af<=ai[0]){
+return 0;
+}
+while(ah>=1){
+var aj=(ag+ah)>>1;
+if(af>ai[aj]){
+ag=aj+1;
+}else if(af<=ai[aj-1]){
+ah=aj-1;
+}else{
+return aj;
+}
+}
+return-1;
+}
+function ScriptLocationFromPosition(af,
+include_resource_offset){
+var ak=this.lineFromPosition(af);
+if(ak==-1)return null;
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+if(am>0&&%_Call(x,this.source,am-1)=='\r'){
+am--;
+}
+var an=af-al;
+if(include_resource_offset){
+ak+=this.line_offset;
+if(ak==this.line_offset){
+an+=this.column_offset;
+}
+}
+return new SourceLocation(this,af,ak,an,al,am);
+}
+function ScriptLocationFromLine(ao,ap,aq){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+var an=ap||0;
+if(ak==0){
+an-=this.column_offset;
+}
+var ar=aq||0;
+if(ak<0||an<0||ar<0)return null;
+if(ak==0){
+return this.locationFromPosition(ar+an,false);
+}else{
+var as=this.lineFromPosition(ar);
+if(as==-1||as+ak>=this.lineCount()){
+return null;
+}
+return this.locationFromPosition(
+this.line_ends[as+ak-1]+1+an);
+}
+}
+function ScriptSourceSlice(at,au){
+var av=(at===(void 0))?this.line_offset
+:at;
+var aw=(au===(void 0))?this.line_offset+this.lineCount()
+:au;
+av-=this.line_offset;
+aw-=this.line_offset;
+if(av<0)av=0;
+if(aw>this.lineCount())aw=this.lineCount();
+if(av>=this.lineCount()||
+aw<0||
+av>aw){
+return null;
+}
+var ai=this.line_ends;
+var ax=av==0?0:ai[av-1]+1;
+var ay=aw==0?0:ai[aw-1]+1;
+return new SourceSlice(this,
+av+this.line_offset,
+aw+this.line_offset,
+ax,ay);
+}
+function ScriptSourceLine(ao){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+if(ak<0||this.lineCount()<=ak){
+return null;
+}
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+return %_Call(z,this.source,al,am);
+}
+function ScriptLineCount(){
+return this.line_ends.length;
+}
+function ScriptLineEnd(az){
+return this.line_ends[az];
+}
+function ScriptNameOrSourceURL(){
+if(this.source_url)return this.source_url;
+return this.name;
+}
+b.SetUpLockedPrototype(v,[
+"source",
+"name",
+"source_url",
+"source_mapping_url",
+"line_ends",
+"line_offset",
+"column_offset"
+],[
+"lineFromPosition",ScriptLineFromPosition,
+"locationFromPosition",ScriptLocationFromPosition,
+"locationFromLine",ScriptLocationFromLine,
+"sourceSlice",ScriptSourceSlice,
+"sourceLine",ScriptSourceLine,
+"lineCount",ScriptLineCount,
+"nameOrSourceURL",ScriptNameOrSourceURL,
+"lineEnd",ScriptLineEnd
+]
+);
+function SourceLocation(ad,af,ak,an,al,am){
+this.script=ad;
+this.position=af;
+this.line=ak;
+this.column=an;
+this.start=al;
+this.end=am;
+}
+function SourceLocationSourceText(){
+return %_Call(z,this.script.source,this.start,this.end);
+}
+b.SetUpLockedPrototype(SourceLocation,
+["script","position","line","column","start","end"],
+["sourceText",SourceLocationSourceText]
+);
+function SourceSlice(ad,av,aw,ax,ay){
+this.script=ad;
+this.from_line=av;
+this.to_line=aw;
+this.from_position=ax;
+this.to_position=ay;
+}
+function SourceSliceSourceText(){
+return %_Call(z,
+this.script.source,
+this.from_position,
+this.to_position);
+}
+b.SetUpLockedPrototype(SourceSlice,
+["script","from_line","to_line","from_position","to_position"],
+["sourceText",SourceSliceSourceText]
+);
+function GetStackTraceLine(aA,aB,aC,aD){
+return new CallSite(aA,aB,aC,false).toString();
+}
+function CallSite(aE,aB,aC,aF){
+if(!(%_IsFunction(aB))){
+throw MakeTypeError(18,typeof aB);
+}
+if((new.target===(void 0))){
+return new CallSite(aE,aB,aC,aF);
+}
+(this[g]=aE);
+(this[h]=aB);
+(this[i]=((aC)|0));
+(this[j]=(!!(aF)));
+}
+function CallSiteGetThis(){
+return(this[j])
+?(void 0):(this[g]);
+}
+function CallSiteGetFunction(){
+return(this[j])
+?(void 0):(this[h]);
+}
+function CallSiteGetPosition(){
+return(this[i]);
+}
+function CallSiteGetTypeName(){
+return GetTypeName((this[g]),false);
+}
+function CallSiteIsToplevel(){
+return %CallSiteIsToplevelRT(this);
+}
+function CallSiteIsEval(){
+return %CallSiteIsEvalRT(this);
+}
+function CallSiteGetEvalOrigin(){
+var ad=%FunctionGetScript((this[h]));
+return FormatEvalOrigin(ad);
+}
+function CallSiteGetScriptNameOrSourceURL(){
+return %CallSiteGetScriptNameOrSourceUrlRT(this);
+}
+function CallSiteGetFunctionName(){
+return %CallSiteGetFunctionNameRT(this);
+}
+function CallSiteGetMethodName(){
+return %CallSiteGetMethodNameRT(this);
+}
+function CallSiteGetFileName(){
+return %CallSiteGetFileNameRT(this);
+}
+function CallSiteGetLineNumber(){
+return %CallSiteGetLineNumberRT(this);
+}
+function CallSiteGetColumnNumber(){
+return %CallSiteGetColumnNumberRT(this);
+}
+function CallSiteIsNative(){
+return %CallSiteIsNativeRT(this);
+}
+function CallSiteIsConstructor(){
+return %CallSiteIsConstructorRT(this);
+}
+function CallSiteToString(){
+var aG;
+var aH="";
+if(this.isNative()){
+aH="native";
+}else{
+aG=this.getScriptNameOrSourceURL();
+if(!aG&&this.isEval()){
+aH=this.getEvalOrigin();
+aH+=", ";
+}
+if(aG){
+aH+=aG;
+}else{
+aH+="<anonymous>";
+}
+var aI=this.getLineNumber();
+if(aI!=null){
+aH+=":"+aI;
+var aJ=this.getColumnNumber();
+if(aJ){
+aH+=":"+aJ;
+}
+}
+}
+var ak="";
+var aK=this.getFunctionName();
+var aL=true;
+var aM=this.isConstructor();
+var aN=!(this.isToplevel()||aM);
+if(aN){
+var aO=GetTypeName((this[g]),true);
+var aP=this.getMethodName();
+if(aK){
+if(aO&&%_Call(y,aK,aO)!=0){
+ak+=aO+".";
+}
+ak+=aK;
+if(aP&&
+(%_Call(y,aK,"."+aP)!=
+aK.length-aP.length-1)){
+ak+=" [as "+aP+"]";
+}
+}else{
+ak+=aO+"."+(aP||"<anonymous>");
+}
+}else if(aM){
+ak+="new "+(aK||"<anonymous>");
+}else if(aK){
+ak+=aK;
+}else{
+ak+=aH;
+aL=false;
+}
+if(aL){
+ak+=" ("+aH+")";
+}
+return ak;
+}
+b.SetUpLockedPrototype(CallSite,["receiver","fun","pos"],[
+"getThis",CallSiteGetThis,
+"getTypeName",CallSiteGetTypeName,
+"isToplevel",CallSiteIsToplevel,
+"isEval",CallSiteIsEval,
+"getEvalOrigin",CallSiteGetEvalOrigin,
+"getScriptNameOrSourceURL",CallSiteGetScriptNameOrSourceURL,
+"getFunction",CallSiteGetFunction,
+"getFunctionName",CallSiteGetFunctionName,
+"getMethodName",CallSiteGetMethodName,
+"getFileName",CallSiteGetFileName,
+"getLineNumber",CallSiteGetLineNumber,
+"getColumnNumber",CallSiteGetColumnNumber,
+"isNative",CallSiteIsNative,
+"getPosition",CallSiteGetPosition,
+"isConstructor",CallSiteIsConstructor,
+"toString",CallSiteToString
+]);
+function FormatEvalOrigin(ad){
+var aQ=ad.nameOrSourceURL();
+if(aQ){
+return aQ;
+}
+var aR="eval at ";
+if(ad.eval_from_function_name){
+aR+=ad.eval_from_function_name;
+}else{
+aR+="<anonymous>";
+}
+var aS=ad.eval_from_script;
+if(aS){
+if(aS.compilation_type==1){
+aR+=" ("+FormatEvalOrigin(aS)+")";
+}else{
+if(aS.name){
+aR+=" ("+aS.name;
+var ae=aS.locationFromPosition(
+ad.eval_from_script_position,true);
+if(ae){
+aR+=":"+(ae.line+1);
+aR+=":"+(ae.column+1);
+}
+aR+=")";
+}else{
+aR+=" (unknown source)";
+}
+}
+}
+return aR;
+}
+function FormatErrorString(aa){
+try{
+return %_Call(ErrorToString,aa);
+}catch(e){
+try{
+return"<error: "+e+">";
+}catch(ee){
+return"<error>";
+}
+}
+}
+function GetStackFrames(aT){
+var aU=new r();
+var aV=aT[0];
+for(var aj=1;aj<aT.length;aj+=4){
+var aA=aT[aj];
+var aB=aT[aj+1];
+var aW=aT[aj+2];
+var aX=aT[aj+3];
+var aC=%_IsSmi(aW)?aW:%FunctionGetPositionForOffset(aW,aX);
+aV--;
+aU.push(new CallSite(aA,aB,aC,(aV<0)));
+}
+return aU;
+}
+var aY=false;
+function FormatStackTrace(Q,aT){
+var aU=GetStackFrames(aT);
+if((%_IsFunction(G.prepareStackTrace))&&
+!aY){
+var aZ=[];
+%MoveArrayContents(aU,aZ);
+aY=true;
+var ba=(void 0);
+try{
+ba=G.prepareStackTrace(Q,aZ);
+}catch(e){
+throw e;
+}finally{
+aY=false;
+}
+return ba;
+}
+var bb=new r();
+bb.push(FormatErrorString(Q));
+for(var aj=0;aj<aU.length;aj++){
+var bc=aU[aj];
+var ak;
+try{
+ak=bc.toString();
+}catch(e){
+try{
+ak="<error: "+e+">";
+}catch(ee){
+ak="<error>";
+}
+}
+bb.push("    at "+ak);
+}
+return %_Call(c,bb,"\n");
+}
+function GetTypeName(aE,bd){
+if((aE==null))return null;
+if((%_IsJSProxy(aE)))return"Proxy";
+var U=%GetDataProperty((%_ToObject(aE)),"constructor");
+if(!(%_IsFunction(U))){
+return bd?null:%_Call(NoSideEffectsToString,aE);
+}
+return %FunctionGetName(U);
+}
+var be=function(){
+var bf=(void 0);
+var bg=this;
+while(bg){
+var bf=
+(bg[m]);
+if((bf===(void 0))){
+var ba=(bg[w]);
+if((ba===(void 0))){
+bg=%_GetPrototype(bg);
+continue;
+}
+bf=FormatStackTrace(bg,ba);
+(bg[w]=(void 0));
+(bg[m]=bf);
+}
+return bf;
+}
+return(void 0);
+};
+var bh=function(bi){
+if(IsErrorObject(this)){
+(this[w]=(void 0));
+(this[m]=bi);
+}
+};
+var bj=function(){};
+function SetUpError(bk){
+%FunctionSetInstanceClassName(bk,'Error');
+var R=bk.name;
+var bl=new n();
+if(R!=='Error'){
+%InternalSetPrototype(bk,G);
+%InternalSetPrototype(bl,G.prototype);
+}
+%FunctionSetPrototype(bk,bl);
+%AddNamedProperty(bk.prototype,'name',R,2);
+%AddNamedProperty(bk.prototype,'message','',2);
+%AddNamedProperty(
+bk.prototype,'constructor',bk,2);
+%SetCode(bk,function(bm){
+if((new.target===(void 0)))return new bk(bm);
+try{bj(this,bk);}catch(e){}
+if(!(bm===(void 0))){
+%AddNamedProperty(this,'message',(%_ToString(bm)),2);
+}
+});
+%SetNativeFlag(bk);
+return bk;
+};
+G=SetUpError(a.Error);
+M=SetUpError(a.EvalError);
+I=SetUpError(a.RangeError);
+L=SetUpError(a.ReferenceError);
+K=SetUpError(a.SyntaxError);
+H=SetUpError(a.TypeError);
+J=SetUpError(a.URIError);
+b.InstallFunctions(G.prototype,2,
+['toString',ErrorToString]);
+function ErrorToString(){
+if(!(%_IsJSReceiver(this))){
+throw MakeTypeError(16,"Error.prototype.toString");
+}
+var R=this.name;
+R=(R===(void 0))?"Error":(%_ToString(R));
+var S=this.message;
+S=(S===(void 0))?"":(%_ToString(S));
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`
+}
+function MakeError(W,X,Y,Z){
+return MakeGenericError(G,W,X,Y,Z);
+}
+function MakeRangeError(W,X,Y,Z){
+return MakeGenericError(I,W,X,Y,Z);
+}
+function MakeSyntaxError(W,X,Y,Z){
+return MakeGenericError(K,W,X,Y,Z);
+}
+function MakeTypeError(W,X,Y,Z){
+return MakeGenericError(H,W,X,Y,Z);
+}
+function MakeURIError(){
+return MakeGenericError(J,283);
+}
+var bn=MakeRangeError(187);
+b.InstallGetterSetter(bn,'stack',
+be,bh)
+bj=function captureStackTrace(Q,bo){
+t(Q,'stack',{get:be,
+set:bh,
+configurable:true});
+%CollectStackTrace(Q,bo?bo:bj);
+};
+G.captureStackTrace=bj;
+%InstallToContext([
+"get_stack_trace_line_fun",GetStackTraceLine,
+"make_error_function",MakeGenericError,
+"make_range_error",MakeRangeError,
+"make_type_error",MakeTypeError,
+"message_get_column_number",GetColumnNumber,
+"message_get_line_number",GetLineNumber,
+"message_get_source_line",GetSourceLine,
+"no_side_effects_to_string_fun",NoSideEffectsToString,
+"stack_overflow_boilerplate",bn,
+]);
+b.Export(function(bp){
+bp.ErrorToString=ErrorToString;
+bp.MakeError=MakeError;
+bp.MakeRangeError=MakeRangeError;
+bp.MakeSyntaxError=MakeSyntaxError;
+bp.MakeTypeError=MakeTypeError;
+bp.MakeURIError=MakeURIError;
+});
+});
+
+jsonE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Date;
+var d=a.JSON;
+var e=a.Set;
+var f=b.InternalArray;
+var g;
+var h;
+var i;
+var j;
+var k=b.ImportNow("to_string_tag_symbol");
+b.Import(function(l){
+g=l.MakeTypeError;
+h=l.MaxSimple;
+i=l.MinSimple;
+j=l.ObjectHasOwnProperty;
+});
+function CreateDataProperty(m,n,o){
+var p={value:o,enumerable:true,writable:true,configurable:true};
+return %reflect_define_property(m,n,p);
+}
+function InternalizeJSONProperty(q,r,s){
+var t=q[r];
+if((%_IsJSReceiver(t))){
+if(%is_arraylike(t)){
+var u=(%_ToLength(t.length));
+for(var v=0;v<u;v++){
+var w=
+InternalizeJSONProperty(t,%_NumberToString(v),s);
+if((w===(void 0))){
+%reflect_delete_property(t,v);
+}else{
+CreateDataProperty(t,v,w);
+}
+}
+}else{
+for(var n of %object_keys(t)){
+var w=InternalizeJSONProperty(t,n,s);
+if((w===(void 0))){
+%reflect_delete_property(t,n);
+}else{
+CreateDataProperty(t,n,w);
+}
+}
+}
+}
+return %_Call(s,q,r,t);
+}
+function JSONParse(x,s){
+var y=%ParseJson(x);
+if((typeof(s)==='function')){
+return InternalizeJSONProperty({'':y},'',s);
+}else{
+return y;
+}
+}
+function SerializeArray(z,A,B,C,D){
+if(!%PushIfAbsent(B,z))throw g(22);
+var E=C;
+C+=D;
+var F=new f();
+var G=(%_ToLength(z.length));
+for(var v=0;v<G;v++){
+var H=JSONSerialize(%_NumberToString(v),z,A,B,
+C,D);
+if((H===(void 0))){
+H="null";
+}
+F.push(H);
+}
+var I;
+if(D==""){
+I="["+F.join(",")+"]";
+}else if(F.length>0){
+var J=",\n"+C;
+I="[\n"+C+F.join(J)+"\n"+
+E+"]";
+}else{
+I="[]";
+}
+B.pop();
+return I;
+}
+function SerializeObject(z,A,B,C,D){
+if(!%PushIfAbsent(B,z))throw g(22);
+var E=C;
+C+=D;
+var F=new f();
+if((%_IsArray(A))){
+var u=A.length;
+for(var v=0;v<u;v++){
+var n=A[v];
+var H=JSONSerialize(n,z,A,B,C,D);
+if(!(H===(void 0))){
+var K=%QuoteJSONString(n)+":";
+if(D!="")K+=" ";
+K+=H;
+F.push(K);
+}
+}
+}else{
+for(var n of %object_keys(z)){
+var H=JSONSerialize(n,z,A,B,C,D);
+if(!(H===(void 0))){
+var K=%QuoteJSONString(n)+":";
+if(D!="")K+=" ";
+K+=H;
+F.push(K);
+}
+}
+}
+var I;
+if(D==""){
+I="{"+F.join(",")+"}";
+}else if(F.length>0){
+var J=",\n"+C;
+I="{\n"+C+F.join(J)+"\n"+
+E+"}";
+}else{
+I="{}";
+}
+B.pop();
+return I;
+}
+function JSONSerialize(L,q,A,B,C,D){
+var z=q[L];
+if((%_IsJSReceiver(z))){
+var M=z.toJSON;
+if((typeof(M)==='function')){
+z=%_Call(M,z,L);
+}
+}
+if((typeof(A)==='function')){
+z=%_Call(A,q,L,z);
+}
+if((typeof(z)==='string')){
+return %QuoteJSONString(z);
+}else if((typeof(z)==='number')){
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((typeof(z)==='boolean')){
+return z?"true":"false";
+}else if((z===null)){
+return"null";
+}else if((%_IsJSReceiver(z))&&!(typeof(z)==='function')){
+if(%is_arraylike(z)){
+return SerializeArray(z,A,B,C,D);
+}else if((%_ClassOf(z)==='Number')){
+z=(%_ToNumber(z));
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((%_ClassOf(z)==='String')){
+return %QuoteJSONString((%_ToString(z)));
+}else if((%_ClassOf(z)==='Boolean')){
+return %_ValueOf(z)?"true":"false";
+}else{
+return SerializeObject(z,A,B,C,D);
+}
+}
+return(void 0);
+}
+function JSONStringify(z,A,N){
+if(%_ArgumentsLength()==1&&!(%_IsJSProxy(z))){
+return %BasicJSONStringify(z);
+}
+if(!(typeof(A)==='function')&&%is_arraylike(A)){
+var O=new f();
+var P=new e();
+var u=(%_ToLength(A.length));
+for(var v=0;v<u;v++){
+var o=A[v];
+var Q;
+if((typeof(o)==='string')){
+Q=o;
+}else if((typeof(o)==='number')){
+Q=%_NumberToString(o);
+}else if((%_ClassOf(o)==='String')||(%_ClassOf(o)==='Number')){
+Q=(%_ToString(o));
+}else{
+continue;
+}
+if(!P.has(Q)){
+O.push(Q);
+P.add(Q);
+}
+}
+A=O;
+}
+if((typeof(N)==='object')){
+if((%_ClassOf(N)==='Number')){
+N=(%_ToNumber(N));
+}else if((%_ClassOf(N)==='String')){
+N=(%_ToString(N));
+}
+}
+var D;
+if((typeof(N)==='number')){
+N=h(0,i((%_ToInteger(N)),10));
+D=%_SubString("          ",0,N);
+}else if((typeof(N)==='string')){
+if(N.length>10){
+D=%_SubString(N,0,10);
+}else{
+D=N;
+}
+}else{
+D="";
+}
+return JSONSerialize('',{'':z},A,new f(),"",D);
+}
+%AddNamedProperty(d,k,"JSON",1|2);
+b.InstallFunctions(d,2,[
+"parse",JSONParse,
+"stringify",JSONStringify
+]);
+function DateToJSON(L){
+var m=(%_ToObject(this));
+var R=(%_ToPrimitive_Number(m));
+if((typeof(R)==='number')&&!(%_IsSmi(%IS_VAR(R))||((R==R)&&(R!=1/0)&&(R!=-1/0)))){
+return null;
+}
+return m.toISOString();
+}
+b.InstallFunctions(c.prototype,2,[
+"toJSON",DateToJSON
+]);
+function JsonSerializeAdapter(L,S){
+var q={};
+q[L]=S;
+return JSONSerialize(L,q,(void 0),new f(),"","");
+}
+%InstallToContext(["json_serialize_adapter",JsonSerializeAdapter]);
+})
+
+8array-iteratorÝ 
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=
+b.ImportNow("array_iteration_kind_symbol");
+var d=
+b.ImportNow("array_iterator_next_symbol");
+var e=
+b.ImportNow("array_iterator_object_symbol");
+var f=a.Array;
+var g=b.ImportNow("IteratorPrototype");
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j=b.ImportNow("to_string_tag_symbol");
+var k=a.Uint8Array.__proto__;
+b.Import(function(l){
+i=l.MakeTypeError;
+})
+function ArrayIterator(){}
+function CreateArrayIterator(m,n){
+var o=(%_ToObject(m));
+var p=new ArrayIterator;
+(p[e]=o);
+(p[d]=0);
+(p[c]=n);
+return p;
+}
+function ArrayIteratorIterator(){
+return this;
+}
+function ArrayIteratorNext(){
+var p=this;
+var q=(void 0);
+var r=true;
+if(!(%_IsJSReceiver(p))||
+!(!(p[d]===(void 0)))){
+throw i(42,
+'Array Iterator.prototype.next',this);
+}
+var m=(p[e]);
+if(!(m===(void 0))){
+var s=(p[d]);
+var t=(p[c]);
+var u=((m.length)>>>0);
+if(s>=u){
+(p[e]=(void 0));
+}else{
+(p[d]=s+1);
+if(t==2){
+q=m[s];
+}else if(t==3){
+q=[s,m[s]];
+}else{
+q=s;
+}
+r=false;
+}
+}
+return %_CreateIterResultObject(q,r);
+}
+function ArrayEntries(){
+return CreateArrayIterator(this,3);
+}
+function ArrayValues(){
+return CreateArrayIterator(this,2);
+}
+function ArrayKeys(){
+return CreateArrayIterator(this,1);
+}
+%FunctionSetPrototype(ArrayIterator,{__proto__:g});
+%FunctionSetInstanceClassName(ArrayIterator,'Array Iterator');
+b.InstallFunctions(ArrayIterator.prototype,2,[
+'next',ArrayIteratorNext
+]);
+b.SetFunctionName(ArrayIteratorIterator,h);
+%AddNamedProperty(ArrayIterator.prototype,h,
+ArrayIteratorIterator,2);
+%AddNamedProperty(ArrayIterator.prototype,j,
+"Array Iterator",1|2);
+b.InstallFunctions(f.prototype,2,[
+'entries',ArrayEntries,
+'keys',ArrayKeys
+]);
+b.SetFunctionName(ArrayValues,'values');
+%AddNamedProperty(f.prototype,h,ArrayValues,
+2);
+%AddNamedProperty(k.prototype,
+'entries',ArrayEntries,2);
+%AddNamedProperty(k.prototype,'values',ArrayValues,2);
+%AddNamedProperty(k.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(k.prototype,
+h,ArrayValues,2);
+b.Export(function(v){
+v.ArrayValues=ArrayValues;
+});
+%InstallToContext(["array_values_iterator",ArrayValues]);
+})
+
+<string-iterator5
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.String;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+var f;
+var g=
+b.ImportNow("string_iterator_iterated_string_symbol");
+var h=
+b.ImportNow("string_iterator_next_index_symbol");
+var i=b.ImportNow("to_string_tag_symbol");
+b.Import(function(j){
+f=j.MakeTypeError;
+});
+function StringIterator(){}
+function CreateStringIterator(k){
+var l=(%_ToString(k));
+var m=new StringIterator;
+(m[g]=l);
+(m[h]=0);
+return m;
+}
+function StringIteratorNext(){
+var m=this;
+var n=(void 0);
+var o=true;
+if(!(%_IsJSReceiver(m))||
+!(!(m[h]===(void 0)))){
+throw f(42,
+'String Iterator.prototype.next');
+}
+var l=(m[g]);
+if(!(l===(void 0))){
+var p=(m[h]);
+var q=((l.length)>>>0);
+if(p>=q){
+(m[g]=(void 0));
+}else{
+var r=%_StringCharCodeAt(l,p);
+n=%_StringCharFromCode(r);
+o=false;
+p++;
+if(r>=0xD800&&r<=0xDBFF&&p<q){
+var s=%_StringCharCodeAt(l,p);
+if(s>=0xDC00&&s<=0xDFFF){
+n+=%_StringCharFromCode(s);
+p++;
+}
+}
+(m[h]=p);
+}
+}
+return %_CreateIterResultObject(n,o);
+}
+function StringPrototypeIterator(){
+return CreateStringIterator(this);
+}
+%FunctionSetPrototype(StringIterator,{__proto__:d});
+%FunctionSetInstanceClassName(StringIterator,'String Iterator');
+b.InstallFunctions(StringIterator.prototype,2,[
+'next',StringIteratorNext
+]);
+%AddNamedProperty(StringIterator.prototype,i,
+"String Iterator",1|2);
+b.SetFunctionName(StringPrototypeIterator,e);
+%AddNamedProperty(c.prototype,e,
+StringPrototypeIterator,2);
+})
+
+$templates
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=b.InternalArray;
+var e=new c;
+var f=c.prototype.get;
+var g=c.prototype.set;
+function SameCallSiteElements(h,i){
+var j=h.length;
+var i=i.raw;
+if(j!==i.length)return false;
+for(var k=0;k<j;++k){
+if(h[k]!==i[k])return false;
+}
+return true;
+}
+function GetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+if((n===(void 0)))return;
+var j=n.length;
+for(var k=0;k<j;++k){
+if(SameCallSiteElements(l,n[k]))return n[k];
+}
+}
+function SetCachedCallSite(l,m){
+var n=%_Call(f,e,m);
+var o;
+if((n===(void 0))){
+o=new d(1);
+o[0]=l;
+%_Call(g,e,m,o);
+}else{
+n.push(l);
+}
+return l;
+}
+function GetTemplateCallSite(l,h,m){
+var p=GetCachedCallSite(h,m);
+if(!(p===(void 0)))return p;
+%AddNamedProperty(l,"raw",%object_freeze(h),
+1|2|4);
+return SetCachedCallSite(%object_freeze(l),m);
+}
+%InstallToContext(["get_template_call_site",GetTemplateCallSite]);
+})
+
+spreadÝ
+(function(a,b){
+'use strict';
+var c=b.InternalArray;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function SpreadArguments(){
+var f=%_ArgumentsLength();
+var g=new c();
+for(var h=0;h<f;++h){
+var i=%_Arguments(h);
+var j=i.length;
+for(var k=0;k<j;++k){
+g.push(i[k]);
+}
+}
+return g;
+}
+function SpreadIterable(l){
+if((l==null)){
+throw d(66,l);
+}
+var g=new c();
+for(var m of l){
+g.push(m);
+}
+return g;
+}
+%InstallToContext([
+"spread_arguments",SpreadArguments,
+"spread_iterable",SpreadIterable,
+]);
+})
+
+i18nFç

+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g;
+var h=a.Boolean;
+var i=a.Date;
+var j=a.Number;
+var k=a.RegExp;
+var l=a.String;
+var m;
+var n;
+var o;
+var p;
+var q=b.ImportNow("ObjectDefineProperties");
+var r=b.ImportNow("ObjectDefineProperty");
+var s=b.ImportNow("intl_pattern_symbol");
+var t;
+var u=b.ImportNow("intl_resolved_symbol");
+var v;
+var w;
+var x;
+var y;
+var z;
+var A;
+var B;
+b.Import(function(C){
+c=C.ArrayIndexOf;
+d=C.ArrayJoin;
+e=C.ArrayPush;
+f=C.IsFinite;
+g=C.IsNaN;
+m=C.MakeError;
+n=C.MakeRangeError;
+o=C.MakeTypeError;
+p=C.MathFloor;
+t=C.RegExpTest;
+v=C.StringIndexOf;
+w=C.StringLastIndexOf;
+x=C.StringMatch;
+y=C.StringReplace;
+z=C.StringSplit;
+A=C.StringSubstr;
+B=C.StringSubstring;
+});
+var D={};
+%AddNamedProperty(a,"Intl",D,2);
+var E={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformat':(void 0),
+'breakiterator':(void 0)
+};
+var F=(void 0);
+var G=(void 0);
+function GetUnicodeExtensionRE(){
+if(((void 0)===(void 0))){
+G=new k('-u(-[a-z0-9]{2,8})+','g');
+}
+return G;
+}
+var H=(void 0);
+function GetAnyExtensionRE(){
+if((H===(void 0))){
+H=new k('-[a-z0-9]{1}-.*','g');
+}
+return H;
+}
+var I=(void 0);
+function GetQuotedStringRE(){
+if((I===(void 0))){
+I=new k("'[^']+'",'g');
+}
+return I;
+}
+var J=(void 0);
+function GetServiceRE(){
+if((J===(void 0))){
+J=
+new k('^(collator|numberformat|dateformat|breakiterator)$');
+}
+return J;
+}
+var K=(void 0);
+function GetLanguageTagRE(){
+if((K===(void 0))){
+BuildLanguageTagREs();
+}
+return K;
+}
+var L=(void 0);
+function GetLanguageVariantRE(){
+if((L===(void 0))){
+BuildLanguageTagREs();
+}
+return L;
+}
+var M=(void 0);
+function GetLanguageSingletonRE(){
+if((M===(void 0))){
+BuildLanguageTagREs();
+}
+return M;
+}
+var N=(void 0);
+function GetTimezoneNameCheckRE(){
+if((N===(void 0))){
+N=new k(
+'^([A-Za-z]+)/([A-Za-z_-]+)((?:\/[A-Za-z_-]+)+)*$');
+}
+return N;
+}
+var O=(void 0);
+function GetTimezoneNameLocationPartRE(){
+if((O===(void 0))){
+O=
+new k('^([A-Za-z]+)((?:[_-][A-Za-z]+)+)*$');
+}
+return O;
+}
+function addBoundMethod(P,Q,R,S){
+%CheckIsBootstrapping();
+function getter(){
+if(!%IsInitializedIntlObject(this)){
+throw o(51,Q);
+}
+var T='__bound'+Q+'__';
+if((this[T]===(void 0))){
+var U=this;
+var V;
+if((S===(void 0))||S===2){
+V=function(W,X){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return R(U,W,X);
+}
+}else if(S===1){
+V=function(W){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return R(U,W);
+}
+}else{
+V=function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(%_ArgumentsLength()>0){
+return R(U,%_Arguments(0));
+}else{
+return R(U);
+}
+}
+}
+%FunctionSetName(V,T);
+%FunctionRemovePrototype(V);
+%SetNativeFlag(V);
+this[T]=V;
+}
+return this[T];
+}
+%FunctionSetName(getter,Q);
+%FunctionRemovePrototype(getter);
+%SetNativeFlag(getter);
+r(P.prototype,Q,{
+get:getter,
+enumerable:false,
+configurable:true
+});
+}
+function supportedLocalesOf(Y,Z,aa){
+if((%_Call(x,Y,GetServiceRE())===null)){
+throw m(7,Y);
+}
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var ab=aa.localeMatcher;
+if(!(ab===(void 0))){
+ab=l(ab);
+if(ab!=='lookup'&&ab!=='best fit'){
+throw n(183,ab);
+}
+}else{
+ab='best fit';
+}
+var ac=initializeLocaleList(Z);
+if((E[Y]===(void 0))){
+E[Y]=getAvailableLocalesOf(Y);
+}
+if(ab==='best fit'){
+return initializeLocaleList(bestFitSupportedLocalesOf(
+ac,E[Y]));
+}
+return initializeLocaleList(lookupSupportedLocalesOf(
+ac,E[Y]));
+}
+function lookupSupportedLocalesOf(ac,ad){
+var ae=[];
+for(var af=0;af<ac.length;++af){
+var ag=%_Call(y,
+ac[af],
+GetUnicodeExtensionRE(),
+'');
+do{
+if(!(ad[ag]===(void 0))){
+%_Call(e,ae,ac[af]);
+break;
+}
+var ah=%_Call(w,ag,'-');
+if(ah===-1){
+break;
+}
+ag=%_Call(B,ag,0,ah);
+}while(true);
+}
+return ae;
+}
+function bestFitSupportedLocalesOf(ac,ad){
+return lookupSupportedLocalesOf(ac,ad);
+}
+function getGetOption(aa,ai){
+if((aa===(void 0)))throw m(4,ai);
+var aj=function getOption(ak,al,am,an){
+if(!(aa[ak]===(void 0))){
+var ao=aa[ak];
+switch(al){
+case'boolean':
+ao=h(ao);
+break;
+case'string':
+ao=l(ao);
+break;
+case'number':
+ao=j(ao);
+break;
+default:
+throw m(8);
+}
+if(!(am===(void 0))&&%_Call(c,am,ao)===-1){
+throw n(193,ao,ai,ak);
+}
+return ao;
+}
+return an;
+}
+return aj;
+}
+function resolveLocale(Y,ac,aa){
+ac=initializeLocaleList(ac);
+var aj=getGetOption(aa,Y);
+var ab=aj('localeMatcher','string',
+['lookup','best fit'],'best fit');
+var ap;
+if(ab==='lookup'){
+ap=lookupMatcher(Y,ac);
+}else{
+ap=bestFitMatcher(Y,ac);
+}
+return ap;
+}
+function lookupMatcher(Y,ac){
+if((%_Call(x,Y,GetServiceRE())===null)){
+throw m(7,Y);
+}
+if((E[Y]===(void 0))){
+E[Y]=getAvailableLocalesOf(Y);
+}
+for(var af=0;af<ac.length;++af){
+var ag=%_Call(y,ac[af],
+GetAnyExtensionRE(),'');
+do{
+if(!(E[Y][ag]===(void 0))){
+var aq=
+%_Call(x,ac[af],GetUnicodeExtensionRE());
+var ar=(aq===null)?'':aq[0];
+return{'locale':ag,'extension':ar,'position':af};
+}
+var ah=%_Call(w,ag,'-');
+if(ah===-1){
+break;
+}
+ag=%_Call(B,ag,0,ah);
+}while(true);
+}
+if((F===(void 0))){
+F=%GetDefaultICULocale();
+}
+return{'locale':F,'extension':'','position':-1};
+}
+function bestFitMatcher(Y,ac){
+return lookupMatcher(Y,ac);
+}
+function parseExtension(ar){
+var as=%_Call(z,ar,'-');
+if(as.length<=2||
+(as[0]!==''&&as[1]!=='u')){
+return{};
+}
+var at={};
+var au=(void 0);
+for(var af=2;af<as.length;++af){
+var S=as[af].length;
+var av=as[af];
+if(S===2){
+at[av]=(void 0);
+au=av;
+}else if(S>=3&&S<=8&&!(au===(void 0))){
+at[au]=av;
+au=(void 0);
+}else{
+return{};
+}
+}
+return at;
+}
+function setOptions(aw,at,ax,aj,ay){
+var ar='';
+var az=function updateExtension(aA,ao){
+return'-'+aA+'-'+l(ao);
+}
+var aB=function updateProperty(ak,al,ao){
+if(al==='boolean'&&(typeof ao==='string')){
+ao=(ao==='true')?true:false;
+}
+if(!(ak===(void 0))){
+defineWEProperty(ay,ak,ao);
+}
+}
+for(var aA in ax){
+if(%HasOwnProperty(ax,aA)){
+var ao=(void 0);
+var aC=ax[aA];
+if(!(aC.property===(void 0))){
+ao=aj(aC.property,aC.type,aC.values);
+}
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+continue;
+}
+if(%HasOwnProperty(at,aA)){
+ao=at[aA];
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+}else if(aC.type==='boolean'){
+aB(aC.property,aC.type,true);
+ar+=az(aA,true);
+}
+}
+}
+}
+return ar===''?'':'-u'+ar;
+}
+function freezeArray(aD){
+var aE=aD.length;
+for(var af=0;af<aE;af++){
+if(af in aD){
+r(aD,af,{value:aD[af],
+configurable:false,
+writable:false,
+enumerable:true});
+}
+}
+r(aD,'length',{value:aE,writable:false});
+return aD;
+}
+function getOptimalLanguageTag(aF,ap){
+if(aF===ap){
+return aF;
+}
+var Z=%GetLanguageTagVariants([aF,ap]);
+if(Z[0].maximized!==Z[1].maximized){
+return ap;
+}
+var aG=new k('^'+Z[1].base);
+return %_Call(y,ap,aG,Z[0].base);
+}
+function getAvailableLocalesOf(Y){
+var aH=%AvailableLocalesOf(Y);
+for(var af in aH){
+if(%HasOwnProperty(aH,af)){
+var aI=
+%_Call(x,af,/^([a-z]{2,3})-([A-Z][a-z]{3})-([A-Z]{2})$/);
+if(aI!==null){
+aH[aI[1]+'-'+aI[3]]=null;
+}
+}
+}
+return aH;
+}
+function defineWEProperty(aJ,ak,ao){
+r(aJ,ak,
+{value:ao,writable:true,enumerable:true});
+}
+function addWEPropertyIfDefined(aJ,ak,ao){
+if(!(ao===(void 0))){
+defineWEProperty(aJ,ak,ao);
+}
+}
+function defineWECProperty(aJ,ak,ao){
+r(aJ,ak,{value:ao,
+writable:true,
+enumerable:true,
+configurable:true});
+}
+function addWECPropertyIfDefined(aJ,ak,ao){
+if(!(ao===(void 0))){
+defineWECProperty(aJ,ak,ao);
+}
+}
+function toTitleCaseWord(aK){
+return %StringToUpperCase(%_Call(A,aK,0,1))+
+%StringToLowerCase(%_Call(A,aK,1));
+}
+function toTitleCaseTimezoneLocation(aL){
+var aM=%_Call(x,aL,GetTimezoneNameLocationPartRE());
+if((aM===null))throw n(163,aL);
+var aN=toTitleCaseWord(aM[1]);
+if(!(aM[2]===(void 0))&&2<aM.length){
+var aO=%_Call(B,aM[2],0,1);
+var aI=%_Call(z,aM[2],aO);
+for(var af=1;af<aI.length;af++){
+var aP=aI[af]
+var aQ=%StringToLowerCase(aP);
+aN=aN+aO+
+((aQ!=='es'&&
+aQ!=='of'&&aQ!=='au')?
+toTitleCaseWord(aP):aQ);
+}
+}
+return aN;
+}
+function canonicalizeLanguageTag(aR){
+if(typeof aR!=='string'&&typeof aR!=='object'||
+(aR===null)){
+throw o(50);
+}
+var aS=l(aR);
+if(isValidLanguageTag(aS)===false){
+throw n(174,aS);
+}
+var aT=%CanonicalizeLanguageTag(aS);
+if(aT==='invalid-tag'){
+throw n(174,aS);
+}
+return aT;
+}
+function initializeLocaleList(Z){
+var aU=[];
+if((Z===(void 0))){
+aU=[];
+}else{
+if(typeof Z==='string'){
+%_Call(e,aU,canonicalizeLanguageTag(Z));
+return freezeArray(aU);
+}
+var aV=(%_ToObject(Z));
+var aW=((aV.length)>>>0);
+for(var aX=0;aX<aW;aX++){
+if(aX in aV){
+var ao=aV[aX];
+var aT=canonicalizeLanguageTag(ao);
+if(%_Call(c,aU,aT)===-1){
+%_Call(e,aU,aT);
+}
+}
+}
+}
+return freezeArray(aU);
+}
+function isValidLanguageTag(ag){
+if(!%_Call(t,GetLanguageTagRE(),ag)){
+return false;
+}
+if(%_Call(v,ag,'x-')===0){
+return true;
+}
+ag=%_Call(z,ag,/-x-/)[0];
+var aY=[];
+var aZ=[];
+var aI=%_Call(z,ag,/-/);
+for(var af=1;af<aI.length;af++){
+var ao=aI[af];
+if(%_Call(t,GetLanguageVariantRE(),ao)&&
+aZ.length===0){
+if(%_Call(c,aY,ao)===-1){
+%_Call(e,aY,ao);
+}else{
+return false;
+}
+}
+if(%_Call(t,GetLanguageSingletonRE(),ao)){
+if(%_Call(c,aZ,ao)===-1){
+%_Call(e,aZ,ao);
+}else{
+return false;
+}
+}
+}
+return true;
+}
+function BuildLanguageTagREs(){
+var ba='[a-zA-Z]';
+var bb='[0-9]';
+var bc='('+ba+'|'+bb+')';
+var bd='(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|'+
+'zh-min|zh-min-nan|zh-xiang)';
+var be='(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|'+
+'i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|'+
+'i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)';
+var bf='('+be+'|'+bd+')';
+var bg='(x(-'+bc+'{1,8})+)';
+var bh='('+bb+'|[A-WY-Za-wy-z])';
+M=new k('^'+bh+'$','i');
+var ar='('+bh+'(-'+bc+'{2,8})+)';
+var bi='('+bc+'{5,8}|('+bb+bc+'{3}))';
+L=new k('^'+bi+'$','i');
+var bj='('+ba+'{2}|'+bb+'{3})';
+var bk='('+ba+'{4})';
+var bl='('+ba+'{3}(-'+ba+'{3}){0,2})';
+var bm='('+ba+'{2,3}(-'+bl+')?|'+ba+'{4}|'+
+ba+'{5,8})';
+var bn=bm+'(-'+bk+')?(-'+bj+')?(-'+
+bi+')*(-'+ar+')*(-'+bg+')?';
+var bo=
+'^('+bn+'|'+bg+'|'+bf+')$';
+K=new k(bo,'i');
+}
+var bp={
+get(){
+%IncrementUseCounter(16);
+return this[u];
+},
+set(ao){
+this[u]=ao;
+}
+};
+function initializeCollator(bq,Z,aa){
+if(%IsInitializedIntlObject(bq)){
+throw o(132,"Collator");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'collator');
+var br={};
+defineWEProperty(br,'usage',aj(
+'usage','string',['sort','search'],'sort'));
+var bs=aj('sensitivity','string',
+['base','accent','case','variant']);
+if((bs===(void 0))&&br.usage==='sort'){
+bs='variant';
+}
+defineWEProperty(br,'sensitivity',bs);
+defineWEProperty(br,'ignorePunctuation',aj(
+'ignorePunctuation','boolean',(void 0),false));
+var ag=resolveLocale('collator',Z,aa);
+var at=parseExtension(ag.extension);
+var bt={
+'kn':{'property':'numeric','type':'boolean'},
+'kf':{'property':'caseFirst','type':'string',
+'values':['false','lower','upper']}
+};
+setOptions(
+aa,at,bt,aj,br);
+var bu='default';
+var ar='';
+if(%HasOwnProperty(at,'co')&&br.usage==='sort'){
+var bv=[
+'big5han','dict','direct','ducet','gb2312','phonebk','phonetic',
+'pinyin','reformed','searchjl','stroke','trad','unihan','zhuyin'
+];
+if(%_Call(c,bv,at.co)!==-1){
+ar='-u-co-'+at.co;
+bu=at.co;
+}
+}else if(br.usage==='search'){
+ar='-u-co-search';
+}
+defineWEProperty(br,'collation',bu);
+var bw=ag.locale+ar;
+var ap=q({},{
+caseFirst:{writable:true},
+collation:{value:br.collation,writable:true},
+ignorePunctuation:{writable:true},
+locale:{writable:true},
+numeric:{writable:true},
+requestedLocale:{value:bw,writable:true},
+sensitivity:{writable:true},
+strength:{writable:true},
+usage:{value:br.usage,writable:true}
+});
+var bx=%CreateCollator(bw,
+br,
+ap);
+%MarkAsInitializedIntlObjectOfType(bq,'collator',bx);
+bq[u]=ap;
+r(bq,'resolved',bp);
+return bq;
+}
+%AddNamedProperty(D,'Collator',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.Collator(Z,aa);
+}
+return initializeCollator((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.Collator.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'collator')){
+throw o(133,"Collator");
+}
+var by=this;
+var ag=getOptimalLanguageTag(by[u].requestedLocale,
+by[u].locale);
+return{
+locale:ag,
+usage:by[u].usage,
+sensitivity:by[u].sensitivity,
+ignorePunctuation:by[u].ignorePunctuation,
+numeric:by[u].numeric,
+caseFirst:by[u].caseFirst,
+collation:by[u].collation
+};
+},
+2
+);
+%FunctionSetName(D.Collator.prototype.resolvedOptions,'resolvedOptions');
+%FunctionRemovePrototype(D.Collator.prototype.resolvedOptions);
+%SetNativeFlag(D.Collator.prototype.resolvedOptions);
+%AddNamedProperty(D.Collator,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('collator',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.Collator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.Collator.supportedLocalesOf);
+%SetNativeFlag(D.Collator.supportedLocalesOf);
+function compare(bq,W,X){
+return %InternalCompare(%GetImplFromInitializedIntlObject(bq),
+l(W),l(X));
+};
+addBoundMethod(D.Collator,'compare',compare,2);
+function isWellFormedCurrencyCode(bz){
+return typeof bz=="string"&&
+bz.length==3&&
+%_Call(x,bz,/[^A-Za-z]/)==null;
+}
+function getNumberOption(aa,ak,bA,bB,bC){
+var ao=aa[ak];
+if(!(ao===(void 0))){
+ao=j(ao);
+if(g(ao)||ao<bA||ao>bB){
+throw n(186,ak);
+}
+return p(ao);
+}
+return bC;
+}
+var bD={
+get(){
+%IncrementUseCounter(15);
+return this[s];
+},
+set(ao){
+this[s]=ao;
+}
+};
+function initializeNumberFormat(bE,Z,aa){
+if(%IsInitializedIntlObject(bE)){
+throw o(132,"NumberFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'numberformat');
+var ag=resolveLocale('numberformat',Z,aa);
+var br={};
+defineWEProperty(br,'style',aj(
+'style','string',['decimal','percent','currency'],'decimal'));
+var bz=aj('currency','string');
+if(!(bz===(void 0))&&!isWellFormedCurrencyCode(bz)){
+throw n(169,bz);
+}
+if(br.style==='currency'&&(bz===(void 0))){
+throw o(28);
+}
+var bF=aj(
+'currencyDisplay','string',['code','symbol','name'],'symbol');
+if(br.style==='currency'){
+defineWEProperty(br,'currency',%StringToUpperCase(bz));
+defineWEProperty(br,'currencyDisplay',bF);
+}
+var bG=getNumberOption(aa,'minimumIntegerDigits',1,21,1);
+defineWEProperty(br,'minimumIntegerDigits',bG);
+var bH=aa['minimumFractionDigits'];
+var bI=aa['maximumFractionDigits'];
+if(!(bH===(void 0))||br.style!=='currency'){
+bH=getNumberOption(aa,'minimumFractionDigits',0,20,0);
+defineWEProperty(br,'minimumFractionDigits',bH);
+}
+if(!(bI===(void 0))||br.style!=='currency'){
+var bJ=br.style==='percent'?0:3;
+bH=(bH===(void 0))?0:bH;
+var bK=(bH>bJ)?bH:bJ;
+bI=getNumberOption(aa,'maximumFractionDigits',bH,20,bK);
+defineWEProperty(br,'maximumFractionDigits',bI);
+}
+var bL=aa['minimumSignificantDigits'];
+var bM=aa['maximumSignificantDigits'];
+if(!(bL===(void 0))||!(bM===(void 0))){
+bL=getNumberOption(aa,'minimumSignificantDigits',1,21,0);
+defineWEProperty(br,'minimumSignificantDigits',bL);
+bM=getNumberOption(aa,'maximumSignificantDigits',bL,21,21);
+defineWEProperty(br,'maximumSignificantDigits',bM);
+}
+defineWEProperty(br,'useGrouping',aj(
+'useGrouping','boolean',(void 0),true));
+var at=parseExtension(ag.extension);
+var bN={
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,bN,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+currency:{writable:true},
+currencyDisplay:{writable:true},
+locale:{writable:true},
+maximumFractionDigits:{writable:true},
+minimumFractionDigits:{writable:true},
+minimumIntegerDigits:{writable:true},
+numberingSystem:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+style:{value:br.style,writable:true},
+useGrouping:{writable:true}
+});
+if(%HasOwnProperty(br,'minimumSignificantDigits')){
+defineWEProperty(ap,'minimumSignificantDigits',(void 0));
+}
+if(%HasOwnProperty(br,'maximumSignificantDigits')){
+defineWEProperty(ap,'maximumSignificantDigits',(void 0));
+}
+var bO=%CreateNumberFormat(bw,
+br,
+ap);
+if(br.style==='currency'){
+r(ap,'currencyDisplay',{value:bF,
+writable:true});
+}
+%MarkAsInitializedIntlObjectOfType(bE,'numberformat',bO);
+bE[u]=ap;
+r(bE,'resolved',bp);
+return bE;
+}
+%AddNamedProperty(D,'NumberFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.NumberFormat(Z,aa);
+}
+return initializeNumberFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.NumberFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'numberformat')){
+throw o(133,"NumberFormat");
+}
+var bP=this;
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+style:bP[u].style,
+useGrouping:bP[u].useGrouping,
+minimumIntegerDigits:bP[u].minimumIntegerDigits,
+minimumFractionDigits:bP[u].minimumFractionDigits,
+maximumFractionDigits:bP[u].maximumFractionDigits,
+};
+if(aN.style==='currency'){
+defineWECProperty(aN,'currency',bP[u].currency);
+defineWECProperty(aN,'currencyDisplay',
+bP[u].currencyDisplay);
+}
+if(%HasOwnProperty(bP[u],'minimumSignificantDigits')){
+defineWECProperty(aN,'minimumSignificantDigits',
+bP[u].minimumSignificantDigits);
+}
+if(%HasOwnProperty(bP[u],'maximumSignificantDigits')){
+defineWECProperty(aN,'maximumSignificantDigits',
+bP[u].maximumSignificantDigits);
+}
+return aN;
+},
+2
+);
+%FunctionSetName(D.NumberFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.NumberFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.NumberFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.NumberFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('numberformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.NumberFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.NumberFormat.supportedLocalesOf);
+%SetNativeFlag(D.NumberFormat.supportedLocalesOf);
+function formatNumber(bO,ao){
+var bQ=(%_ToNumber(ao))+0;
+return %InternalNumberFormat(%GetImplFromInitializedIntlObject(bO),
+bQ);
+}
+function parseNumber(bO,ao){
+return %InternalNumberParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.NumberFormat,'format',formatNumber,1);
+addBoundMethod(D.NumberFormat,'v8Parse',parseNumber,1);
+function toLDMLString(aa){
+var aj=getGetOption(aa,'dateformat');
+var bR='';
+var bS=aj('weekday','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
+bS=aj('era','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
+bS=aj('year','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'yy','numeric':'y'});
+bS=aj('month','string',
+['2-digit','numeric','narrow','short','long']);
+bR+=appendToLDMLString(bS,{'2-digit':'MM','numeric':'M',
+'narrow':'MMMMM','short':'MMM','long':'MMMM'});
+bS=aj('day','string',['2-digit','numeric']);
+bR+=appendToLDMLString(
+bS,{'2-digit':'dd','numeric':'d'});
+var bT=aj('hour12','boolean');
+bS=aj('hour','string',['2-digit','numeric']);
+if((bT===(void 0))){
+bR+=appendToLDMLString(bS,{'2-digit':'jj','numeric':'j'});
+}else if(bT===true){
+bR+=appendToLDMLString(bS,{'2-digit':'hh','numeric':'h'});
+}else{
+bR+=appendToLDMLString(bS,{'2-digit':'HH','numeric':'H'});
+}
+bS=aj('minute','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'mm','numeric':'m'});
+bS=aj('second','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'ss','numeric':'s'});
+bS=aj('timeZoneName','string',['short','long']);
+bR+=appendToLDMLString(bS,{short:'z',long:'zzzz'});
+return bR;
+}
+function appendToLDMLString(bS,bU){
+if(!(bS===(void 0))){
+return bU[bS];
+}else{
+return'';
+}
+}
+function fromLDMLString(bR){
+bR=%_Call(y,bR,GetQuotedStringRE(),'');
+var aa={};
+var aM=%_Call(x,bR,/E{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'weekday',aM,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
+aM=%_Call(x,bR,/G{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'era',aM,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
+aM=%_Call(x,bR,/y{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'year',aM,{y:'numeric',yy:'2-digit'});
+aM=%_Call(x,bR,/M{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{MM:'2-digit',
+M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
+aM=%_Call(x,bR,/L{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{LL:'2-digit',
+L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
+aM=%_Call(x,bR,/d{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'day',aM,{d:'numeric',dd:'2-digit'});
+aM=%_Call(x,bR,/h{1,2}/g);
+if(aM!==null){
+aa['hour12']=true;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{h:'numeric',hh:'2-digit'});
+aM=%_Call(x,bR,/H{1,2}/g);
+if(aM!==null){
+aa['hour12']=false;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{H:'numeric',HH:'2-digit'});
+aM=%_Call(x,bR,/m{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'minute',aM,{m:'numeric',mm:'2-digit'});
+aM=%_Call(x,bR,/s{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'second',aM,{s:'numeric',ss:'2-digit'});
+aM=%_Call(x,bR,/z|zzzz/g);
+aa=appendToDateTimeObject(
+aa,'timeZoneName',aM,{z:'short',zzzz:'long'});
+return aa;
+}
+function appendToDateTimeObject(aa,bS,aM,bU){
+if((aM===null)){
+if(!%HasOwnProperty(aa,bS)){
+defineWEProperty(aa,bS,(void 0));
+}
+return aa;
+}
+var ak=aM[0];
+defineWEProperty(aa,bS,bU[ak]);
+return aa;
+}
+function toDateTimeOptions(aa,bV,bW){
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var bX=true;
+if((bV==='date'||bV==='any')&&
+(!(aa.weekday===(void 0))||!(aa.year===(void 0))||
+!(aa.month===(void 0))||!(aa.day===(void 0)))){
+bX=false;
+}
+if((bV==='time'||bV==='any')&&
+(!(aa.hour===(void 0))||!(aa.minute===(void 0))||
+!(aa.second===(void 0)))){
+bX=false;
+}
+if(bX&&(bW==='date'||bW==='all')){
+r(aa,'year',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'month',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'day',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+if(bX&&(bW==='time'||bW==='all')){
+r(aa,'hour',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'minute',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'second',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+return aa;
+}
+function initializeDateTimeFormat(bY,Z,aa){
+if(%IsInitializedIntlObject(bY)){
+throw o(132,"DateTimeFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var ag=resolveLocale('dateformat',Z,aa);
+aa=toDateTimeOptions(aa,'any','date');
+var aj=getGetOption(aa,'dateformat');
+var ab=aj('formatMatcher','string',
+['basic','best fit'],'best fit');
+var bR=toLDMLString(aa);
+var bZ=canonicalizeTimeZoneID(aa.timeZone);
+var br={};
+var at=parseExtension(ag.extension);
+var ca={
+'ca':{'property':(void 0),'type':'string'},
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,ca,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+calendar:{writable:true},
+day:{writable:true},
+era:{writable:true},
+hour12:{writable:true},
+hour:{writable:true},
+locale:{writable:true},
+minute:{writable:true},
+month:{writable:true},
+numberingSystem:{writable:true},
+[s]:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+second:{writable:true},
+timeZone:{writable:true},
+timeZoneName:{writable:true},
+tz:{value:bZ,writable:true},
+weekday:{writable:true},
+year:{writable:true}
+});
+var bO=%CreateDateTimeFormat(
+bw,{skeleton:bR,timeZone:bZ},ap);
+if(ap.timeZone==="Etc/Unknown"){
+throw n(192,bZ);
+}
+%MarkAsInitializedIntlObjectOfType(bY,'dateformat',bO);
+bY[u]=ap;
+r(bY,'resolved',bp);
+return bY;
+}
+%AddNamedProperty(D,'DateTimeFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.DateTimeFormat(Z,aa);
+}
+return initializeDateTimeFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.DateTimeFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'dateformat')){
+throw o(133,"DateTimeFormat");
+}
+var cb={
+'gregorian':'gregory',
+'japanese':'japanese',
+'buddhist':'buddhist',
+'roc':'roc',
+'persian':'persian',
+'islamic-civil':'islamicc',
+'islamic':'islamic',
+'hebrew':'hebrew',
+'chinese':'chinese',
+'indian':'indian',
+'coptic':'coptic',
+'ethiopic':'ethiopic',
+'ethiopic-amete-alem':'ethioaa'
+};
+var bP=this;
+var cc=fromLDMLString(bP[u][s]);
+var cd=cb[bP[u].calendar];
+if((cd===(void 0))){
+cd=bP[u].calendar;
+}
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+calendar:cd,
+timeZone:bP[u].timeZone
+};
+addWECPropertyIfDefined(aN,'timeZoneName',cc.timeZoneName);
+addWECPropertyIfDefined(aN,'era',cc.era);
+addWECPropertyIfDefined(aN,'year',cc.year);
+addWECPropertyIfDefined(aN,'month',cc.month);
+addWECPropertyIfDefined(aN,'day',cc.day);
+addWECPropertyIfDefined(aN,'weekday',cc.weekday);
+addWECPropertyIfDefined(aN,'hour12',cc.hour12);
+addWECPropertyIfDefined(aN,'hour',cc.hour);
+addWECPropertyIfDefined(aN,'minute',cc.minute);
+addWECPropertyIfDefined(aN,'second',cc.second);
+return aN;
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.DateTimeFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.DateTimeFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.DateTimeFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('dateformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.DateTimeFormat.supportedLocalesOf);
+%SetNativeFlag(D.DateTimeFormat.supportedLocalesOf);
+function formatDate(bO,ce){
+var cf;
+if((ce===(void 0))){
+cf=%DateCurrentTime();
+}else{
+cf=(%_ToNumber(ce));
+}
+if(!f(cf))throw n(161);
+return %InternalDateFormat(%GetImplFromInitializedIntlObject(bO),
+new i(cf));
+}
+function parseDate(bO,ao){
+return %InternalDateParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.DateTimeFormat,'format',formatDate,0);
+addBoundMethod(D.DateTimeFormat,'v8Parse',parseDate,1);
+function canonicalizeTimeZoneID(cg){
+if((cg===(void 0))){
+return cg;
+}
+var ch=%StringToUpperCase(cg);
+if(ch==='UTC'||ch==='GMT'||
+ch==='ETC/UTC'||ch==='ETC/GMT'){
+return'UTC';
+}
+var aM=%_Call(x,cg,GetTimezoneNameCheckRE());
+if((aM===null))throw n(162,cg);
+var aN=toTitleCaseTimezoneLocation(aM[1])+'/'+
+toTitleCaseTimezoneLocation(aM[2]);
+if(!(aM[3]===(void 0))&&3<aM.length){
+var ci=%_Call(z,aM[3],'/');
+for(var af=1;af<ci.length;af++){
+aN=aN+'/'+toTitleCaseTimezoneLocation(ci[af]);
+}
+}
+return aN;
+}
+function initializeBreakIterator(cj,Z,aa){
+if(%IsInitializedIntlObject(cj)){
+throw o(132,"v8BreakIterator");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'breakiterator');
+var br={};
+defineWEProperty(br,'type',aj(
+'type','string',['character','word','sentence','line'],'word'));
+var ag=resolveLocale('breakiterator',Z,aa);
+var ap=q({},{
+requestedLocale:{value:ag.locale,writable:true},
+type:{value:br.type,writable:true},
+locale:{writable:true}
+});
+var ck=%CreateBreakIterator(ag.locale,
+br,
+ap);
+%MarkAsInitializedIntlObjectOfType(cj,'breakiterator',
+ck);
+cj[u]=ap;
+r(cj,'resolved',bp);
+return cj;
+}
+%AddNamedProperty(D,'v8BreakIterator',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.v8BreakIterator(Z,aa);
+}
+return initializeBreakIterator((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.v8BreakIterator.prototype,'resolvedOptions',
+function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'breakiterator')){
+throw o(133,"v8BreakIterator");
+}
+var cl=this;
+var ag=
+getOptimalLanguageTag(cl[u].requestedLocale,
+cl[u].locale);
+return{
+locale:ag,
+type:cl[u].type
+};
+},
+2
+);
+%FunctionSetName(D.v8BreakIterator.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.v8BreakIterator.prototype.resolvedOptions);
+%SetNativeFlag(D.v8BreakIterator.prototype.resolvedOptions);
+%AddNamedProperty(D.v8BreakIterator,'supportedLocalesOf',
+function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('breakiterator',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.v8BreakIterator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.v8BreakIterator.supportedLocalesOf);
+%SetNativeFlag(D.v8BreakIterator.supportedLocalesOf);
+function adoptText(cj,cm){
+%BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(cj),
+l(cm));
+}
+function first(cj){
+return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(cj));
+}
+function next(cj){
+return %BreakIteratorNext(%GetImplFromInitializedIntlObject(cj));
+}
+function current(cj){
+return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(cj));
+}
+function breakType(cj){
+return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(cj));
+}
+addBoundMethod(D.v8BreakIterator,'adoptText',adoptText,1);
+addBoundMethod(D.v8BreakIterator,'first',first,0);
+addBoundMethod(D.v8BreakIterator,'next',next,0);
+addBoundMethod(D.v8BreakIterator,'current',current,0);
+addBoundMethod(D.v8BreakIterator,'breakType',breakType,0);
+var cn={
+'collator':D.Collator,
+'numberformat':D.NumberFormat,
+'dateformatall':D.DateTimeFormat,
+'dateformatdate':D.DateTimeFormat,
+'dateformattime':D.DateTimeFormat
+};
+var co={
+'collator':(void 0),
+'numberformat':(void 0),
+'dateformatall':(void 0),
+'dateformatdate':(void 0),
+'dateformattime':(void 0),
+};
+function cachedOrNewService(Y,Z,aa,bW){
+var cp=((bW===(void 0)))?aa:bW;
+if((Z===(void 0))&&(aa===(void 0))){
+if((co[Y]===(void 0))){
+co[Y]=new cn[Y](Z,cp);
+}
+return co[Y];
+}
+return new cn[Y](Z,cp);
+}
+function OverrideFunction(aJ,cq,cr){
+%CheckIsBootstrapping();
+r(aJ,cq,{value:cr,
+writeable:true,
+configurable:true,
+enumerable:false});
+%FunctionSetName(cr,cq);
+%FunctionRemovePrototype(cr);
+%SetNativeFlag(cr);
+}
+OverrideFunction(l.prototype,'localeCompare',function(U){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if((this==null)){
+throw o(52);
+}
+var Z=%_Arguments(1);
+var aa=%_Arguments(2);
+var bq=cachedOrNewService('collator',Z,aa);
+return compare(bq,this,U);
+}
+);
+OverrideFunction(l.prototype,'normalize',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if((%IS_VAR(this)===null)||(this===(void 0)))throw o(17,"String.prototype.normalize");
+var cs=(%_ToString(this));
+var ct=%_Arguments(0);
+var cu=(ct===(void 0))?'NFC':(%_ToString(ct));
+var cv=['NFC','NFD','NFKC','NFKD'];
+var cw=%_Call(c,cv,cu);
+if(cw===-1){
+throw n(184,
+%_Call(d,cv,', '));
+}
+return %StringNormalize(cs,cw);
+}
+);
+OverrideFunction(j.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!(this instanceof j)&&typeof(this)!=='number'){
+throw o(53,"Number");
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+var bE=cachedOrNewService('numberformat',Z,aa);
+return formatNumber(bE,this);
+}
+);
+function toLocaleDateTime(cx,Z,aa,bV,bW,Y){
+if(!(cx instanceof i)){
+throw o(53,"Date");
+}
+if(g(cx))return'Invalid Date';
+var br=toDateTimeOptions(aa,bV,bW);
+var bY=
+cachedOrNewService(Y,Z,aa,br);
+return formatDate(bY,cx);
+}
+OverrideFunction(i.prototype,'toLocaleString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'any','all','dateformatall');
+}
+);
+OverrideFunction(i.prototype,'toLocaleDateString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'date','date','dateformatdate');
+}
+);
+OverrideFunction(i.prototype,'toLocaleTimeString',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+return toLocaleDateTime(
+this,Z,aa,'time','time','dateformattime');
+}
+);
+})
+
+,proxy		
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Proxy;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+});
+function ProxyCreateRevocable(f,g){
+var h=new c(f,g);
+return{proxy:h,revoke:()=>%JSProxyRevoke(h)};
+}
+function ProxyEnumerate(i,g,f){
+var j=%_Call(i,g,f);
+if(!(%_IsJSReceiver(j))){
+throw d(99);
+}
+var k=[];
+for(var l=j.next();!l.done;l=j.next()){
+var m=l.value;
+if(!(typeof(m)==='string')){
+throw d(100);
+}
+k.push(m);
+}
+return k;
+}
+b.InstallFunctions(c,2,[
+"revocable",ProxyCreateRevocable
+]);
+%InstallToContext([
+"proxy_enumerate",ProxyEnumerate,
+]);
+})
+
+$generator­
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,i);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+return{value:void 0,done:true};
+}else{
+throw f(40);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+try{
+return %_GeneratorThrow(this,k);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+throw k;
+}else{
+throw f(40);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+<harmony-atomicsM:
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d;
+var e;
+var f=b.ImportNow("to_string_tag_symbol");
+b.Import(function(g){
+d=g.MakeTypeError;
+e=g.MaxSimple;
+});
+function CheckSharedIntegerTypedArray(h){
+if(!%IsSharedIntegerTypedArray(h)){
+throw d(70,h);
+}
+}
+function CheckSharedInteger32TypedArray(h){
+CheckSharedIntegerTypedArray(h);
+if(!%IsSharedInteger32TypedArray(h)){
+throw d(71,h);
+}
+}
+function AtomicsCompareExchangeJS(i,j,k,l){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+k=(%_ToNumber(k));
+l=(%_ToNumber(l));
+return %_AtomicsCompareExchange(i,j,k,l);
+}
+function AtomicsLoadJS(i,j){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+return %_AtomicsLoad(i,j);
+}
+function AtomicsStoreJS(i,j,m){
+CheckSharedIntegerTypedArray(i);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(i)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsStore(i,j,m);
+}
+function AtomicsAddJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsAdd(h,j,m);
+}
+function AtomicsSubJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsSub(h,j,m);
+}
+function AtomicsAndJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsAnd(h,j,m);
+}
+function AtomicsOrJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsOr(h,j,m);
+}
+function AtomicsXorJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsXor(h,j,m);
+}
+function AtomicsExchangeJS(h,j,m){
+CheckSharedIntegerTypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+m=(%_ToNumber(m));
+return %_AtomicsExchange(h,j,m);
+}
+function AtomicsIsLockFreeJS(n){
+return %_AtomicsIsLockFree(n);
+}
+function AtomicsFutexWaitJS(h,j,m,o){
+CheckSharedInteger32TypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+if((o===(void 0))){
+o=(1/0);
+}else{
+o=(%_ToNumber(o));
+if((!%_IsSmi(%IS_VAR(o))&&!(o==o))){
+o=(1/0);
+}else{
+o=e(0,o);
+}
+}
+return %AtomicsFutexWait(h,j,m,o);
+}
+function AtomicsFutexWakeJS(h,j,p){
+CheckSharedInteger32TypedArray(h);
+j=(%_ToInteger(j));
+if(j<0||j>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+p=e(0,(%_ToInteger(p)));
+return %AtomicsFutexWake(h,j,p);
+}
+function AtomicsFutexWakeOrRequeueJS(h,q,p,m,r){
+CheckSharedInteger32TypedArray(h);
+q=(%_ToInteger(q));
+p=e(0,(%_ToInteger(p)));
+m=((m)|0);
+r=(%_ToInteger(r));
+if(q<0||q>=%_TypedArrayGetLength(h)||
+r<0||r>=%_TypedArrayGetLength(h)){
+return(void 0);
+}
+return %AtomicsFutexWakeOrRequeue(h,q,p,m,r);
+}
+function AtomicsConstructor(){}
+var s=new AtomicsConstructor();
+%InternalSetPrototype(s,c.prototype);
+%AddNamedProperty(a,"Atomics",s,2);
+%FunctionSetInstanceClassName(AtomicsConstructor,'Atomics');
+%AddNamedProperty(s,f,"Atomics",1|2);
+b.InstallConstants(s,[
+"OK",0,
+"NOTEQUAL",-1,
+"TIMEDOUT",-2,
+]);
+b.InstallFunctions(s,2,[
+"compareExchange",AtomicsCompareExchangeJS,
+"load",AtomicsLoadJS,
+"store",AtomicsStoreJS,
+"add",AtomicsAddJS,
+"sub",AtomicsSubJS,
+"and",AtomicsAndJS,
+"or",AtomicsOrJS,
+"xor",AtomicsXorJS,
+"exchange",AtomicsExchangeJS,
+"isLockFree",AtomicsIsLockFreeJS,
+"futexWait",AtomicsFutexWaitJS,
+"futexWake",AtomicsFutexWakeJS,
+"futexWakeOrRequeue",AtomicsFutexWakeOrRequeueJS,
+]);
+})
+
+8harmony-regexp%
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+var f=b.ImportNow("regexp_flags_symbol");
+b.Import(function(g){
+e=g.MakeTypeError;
+});
+function RegExpGetFlags(){
+if(!(%_IsJSReceiver(this))){
+throw e(
+130,"RegExp.prototype.flags",(%_ToString(this)));
+}
+var h='';
+if(this.global)h+='g';
+if(this.ignoreCase)h+='i';
+if(this.multiline)h+='m';
+if(this.unicode)h+='u';
+if(this.sticky)h+='y';
+return h;
+}
+function RegExpGetSticky(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(11);
+return(void 0);
+}
+throw e(131,"RegExp.prototype.sticky");
+}
+return!!(%_RegExpFlags(this)&8);
+}
+%FunctionSetName(RegExpGetSticky,"RegExp.prototype.sticky");
+%SetNativeFlag(RegExpGetSticky);
+b.InstallGetter(c.prototype,'flags',RegExpGetFlags);
+b.InstallGetter(c.prototype,'sticky',RegExpGetSticky);
+})
+
+<harmony-reflect¥
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.Reflect;
+var d;
+var e=b.ImportNow("reflect_apply");
+var f=b.ImportNow("reflect_construct");
+b.Import(function(g){
+d=g.MakeTypeError;
+});
+function ReflectEnumerate(h){
+if(!(%_IsJSReceiver(h)))
+throw d(16,"Reflect.enumerate")
+return(function*(){for(var i in h)yield i})();
+}
+b.InstallFunctions(c,2,[
+"apply",e,
+"construct",f,
+"enumerate",ReflectEnumerate
+]);
+})
+
+Xharmony-object-observeU
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("ObserveArrayMethods");
+var d=b.ImportNow("ObserveObjectMethods");;
+b.InstallFunctions(a.Object,2,d);
+b.InstallFunctions(a.Array,2,c);
+})
+
+dharmony-sharedarraybufferE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SharedArrayBuffer;
+var d;
+b.Import(function(e){
+d=e.MakeTypeError;
+})
+function SharedArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='SharedArrayBuffer')){
+throw d(42,
+'SharedArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+b.InstallGetter(c.prototype,"byteLength",
+SharedArrayBufferGetByteLen);
+})
+
+0harmony-simd–²
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.SIMD;
+var d;
+var e=b.ImportNow("to_string_tag_symbol");
+b.Import(function(f){
+d=f.MakeTypeError;
+});
+var g=c.Float32x4;
+
+
+var h=c.Int32x4;
+
+var i=c.Int16x8;
+
+var j=c.Int8x16;
+
+
+var k=c.Uint32x4;
+
+var l=c.Uint16x8;
+
+var m=c.Uint8x16;
+
+
+var n=c.Bool32x4;
+
+var o=c.Bool16x8;
+
+var p=c.Bool8x16;
+
+
+
+function Float32x4CheckJS(q){
+return %Float32x4Check(q);
+}
+function Float32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.toString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Float32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Float32x4(";
+s+=%Float32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Float32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Float32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='float32x4'){
+throw d(42,
+"Float32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Float32x4ExtractLaneJS(u,v){
+return %Float32x4ExtractLane(u,v);
+}
+
+
+function Int32x4CheckJS(q){
+return %Int32x4Check(q);
+}
+function Int32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.toString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Int32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Int32x4(";
+s+=%Int32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Int32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int32x4'){
+throw d(42,
+"Int32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Int32x4ExtractLaneJS(u,v){
+return %Int32x4ExtractLane(u,v);
+}
+
+function Int16x8CheckJS(q){
+return %Int16x8Check(q);
+}
+function Int16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.toString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Int16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Int16x8(";
+s+=%Int16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Int16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int16x8'){
+throw d(42,
+"Int16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Int16x8ExtractLaneJS(u,v){
+return %Int16x8ExtractLane(u,v);
+}
+
+function Int8x16CheckJS(q){
+return %Int8x16Check(q);
+}
+function Int8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.toString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Int8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Int8x16(";
+s+=%Int8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Int8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Int8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='int8x16'){
+throw d(42,
+"Int8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Int8x16ExtractLaneJS(u,v){
+return %Int8x16ExtractLane(u,v);
+}
+
+
+function Uint32x4CheckJS(q){
+return %Uint32x4Check(q);
+}
+function Uint32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.toString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint32x4(";
+s+=%Uint32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Uint32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint32x4'){
+throw d(42,
+"Uint32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Uint32x4ExtractLaneJS(u,v){
+return %Uint32x4ExtractLane(u,v);
+}
+
+function Uint16x8CheckJS(q){
+return %Uint16x8Check(q);
+}
+function Uint16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.toString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint16x8(";
+s+=%Uint16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Uint16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint16x8'){
+throw d(42,
+"Uint16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Uint16x8ExtractLaneJS(u,v){
+return %Uint16x8ExtractLane(u,v);
+}
+
+function Uint8x16CheckJS(q){
+return %Uint8x16Check(q);
+}
+function Uint8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.toString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Uint8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Uint8x16(";
+s+=%Uint8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Uint8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Uint8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='uint8x16'){
+throw d(42,
+"Uint8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Uint8x16ExtractLaneJS(u,v){
+return %Uint8x16ExtractLane(u,v);
+}
+
+
+function Bool32x4CheckJS(q){
+return %Bool32x4Check(q);
+}
+function Bool32x4ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.toString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0);
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool32x4ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool32x4(";
+s+=%Bool32x4ExtractLane(r,0).toLocaleString();
+for(var t=1;t<4;t++){
+s+=", "+%Bool32x4ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool32x4ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool32x4'){
+throw d(42,
+"Bool32x4.prototype.valueOf",this);
+}
+return r;
+}
+function Bool32x4ExtractLaneJS(u,v){
+return %Bool32x4ExtractLane(u,v);
+}
+
+function Bool16x8CheckJS(q){
+return %Bool16x8Check(q);
+}
+function Bool16x8ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.toString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0);
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool16x8ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool16x8(";
+s+=%Bool16x8ExtractLane(r,0).toLocaleString();
+for(var t=1;t<8;t++){
+s+=", "+%Bool16x8ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool16x8ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool16x8'){
+throw d(42,
+"Bool16x8.prototype.valueOf",this);
+}
+return r;
+}
+function Bool16x8ExtractLaneJS(u,v){
+return %Bool16x8ExtractLane(u,v);
+}
+
+function Bool8x16CheckJS(q){
+return %Bool8x16Check(q);
+}
+function Bool8x16ToString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.toString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0);
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t);
+}
+return s+")";
+}
+function Bool8x16ToLocaleString(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.toLocaleString",this);
+}
+var s="SIMD.Bool8x16(";
+s+=%Bool8x16ExtractLane(r,0).toLocaleString();
+for(var t=1;t<16;t++){
+s+=", "+%Bool8x16ExtractLane(r,t).toLocaleString();
+}
+return s+")";
+}
+function Bool8x16ValueOf(){
+var r=%_ValueOf(this);
+if(typeof(r)!=='bool8x16'){
+throw d(42,
+"Bool8x16.prototype.valueOf",this);
+}
+return r;
+}
+function Bool8x16ExtractLaneJS(u,v){
+return %Bool8x16ExtractLane(u,v);
+}
+
+
+
+function Int32x4ShiftLeftByScalarJS(u,w){
+return %Int32x4ShiftLeftByScalar(u,w);
+}
+function Int32x4ShiftRightByScalarJS(u,w){
+return %Int32x4ShiftRightByScalar(u,w);
+}
+
+function Int16x8ShiftLeftByScalarJS(u,w){
+return %Int16x8ShiftLeftByScalar(u,w);
+}
+function Int16x8ShiftRightByScalarJS(u,w){
+return %Int16x8ShiftRightByScalar(u,w);
+}
+
+function Int8x16ShiftLeftByScalarJS(u,w){
+return %Int8x16ShiftLeftByScalar(u,w);
+}
+function Int8x16ShiftRightByScalarJS(u,w){
+return %Int8x16ShiftRightByScalar(u,w);
+}
+
+
+function Uint32x4ShiftLeftByScalarJS(u,w){
+return %Uint32x4ShiftLeftByScalar(u,w);
+}
+function Uint32x4ShiftRightByScalarJS(u,w){
+return %Uint32x4ShiftRightByScalar(u,w);
+}
+
+function Uint16x8ShiftLeftByScalarJS(u,w){
+return %Uint16x8ShiftLeftByScalar(u,w);
+}
+function Uint16x8ShiftRightByScalarJS(u,w){
+return %Uint16x8ShiftRightByScalar(u,w);
+}
+
+function Uint8x16ShiftLeftByScalarJS(u,w){
+return %Uint8x16ShiftLeftByScalar(u,w);
+}
+function Uint8x16ShiftRightByScalarJS(u,w){
+return %Uint8x16ShiftRightByScalar(u,w);
+}
+
+
+function Int16x8AddSaturateJS(q,x){
+return %Int16x8AddSaturate(q,x);
+}
+function Int16x8SubSaturateJS(q,x){
+return %Int16x8SubSaturate(q,x);
+}
+
+function Int8x16AddSaturateJS(q,x){
+return %Int8x16AddSaturate(q,x);
+}
+function Int8x16SubSaturateJS(q,x){
+return %Int8x16SubSaturate(q,x);
+}
+
+function Uint8x16AddSaturateJS(q,x){
+return %Uint8x16AddSaturate(q,x);
+}
+function Uint8x16SubSaturateJS(q,x){
+return %Uint8x16SubSaturate(q,x);
+}
+
+function Uint16x8AddSaturateJS(q,x){
+return %Uint16x8AddSaturate(q,x);
+}
+function Uint16x8SubSaturateJS(q,x){
+return %Uint16x8SubSaturate(q,x);
+}
+
+
+function Float32x4NegJS(q){
+return %Float32x4Neg(q);
+}
+
+
+function Int32x4NegJS(q){
+return %Int32x4Neg(q);
+}
+
+function Int16x8NegJS(q){
+return %Int16x8Neg(q);
+}
+
+function Int8x16NegJS(q){
+return %Int8x16Neg(q);
+}
+
+
+function Bool32x4ReplaceLaneJS(u,v,r){
+return %Bool32x4ReplaceLane(u,v,r);
+}
+function Bool32x4AnyTrueJS(y){
+return %Bool32x4AnyTrue(y);
+}
+function Bool32x4AllTrueJS(y){
+return %Bool32x4AllTrue(y);
+}
+
+function Bool16x8ReplaceLaneJS(u,v,r){
+return %Bool16x8ReplaceLane(u,v,r);
+}
+function Bool16x8AnyTrueJS(y){
+return %Bool16x8AnyTrue(y);
+}
+function Bool16x8AllTrueJS(y){
+return %Bool16x8AllTrue(y);
+}
+
+function Bool8x16ReplaceLaneJS(u,v,r){
+return %Bool8x16ReplaceLane(u,v,r);
+}
+function Bool8x16AnyTrueJS(y){
+return %Bool8x16AnyTrue(y);
+}
+function Bool8x16AllTrueJS(y){
+return %Bool8x16AllTrue(y);
+}
+
+
+function Float32x4ReplaceLaneJS(u,v,r){
+return %Float32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Float32x4SelectJS(z,q,x){
+return %Float32x4Select(z,q,x);
+}
+function Float32x4AddJS(q,x){
+return %Float32x4Add(q,x);
+}
+function Float32x4SubJS(q,x){
+return %Float32x4Sub(q,x);
+}
+function Float32x4MulJS(q,x){
+return %Float32x4Mul(q,x);
+}
+function Float32x4MinJS(q,x){
+return %Float32x4Min(q,x);
+}
+function Float32x4MaxJS(q,x){
+return %Float32x4Max(q,x);
+}
+function Float32x4EqualJS(q,x){
+return %Float32x4Equal(q,x);
+}
+function Float32x4NotEqualJS(q,x){
+return %Float32x4NotEqual(q,x);
+}
+function Float32x4LessThanJS(q,x){
+return %Float32x4LessThan(q,x);
+}
+function Float32x4LessThanOrEqualJS(q,x){
+return %Float32x4LessThanOrEqual(q,x);
+}
+function Float32x4GreaterThanJS(q,x){
+return %Float32x4GreaterThan(q,x);
+}
+function Float32x4GreaterThanOrEqualJS(q,x){
+return %Float32x4GreaterThanOrEqual(q,x);
+}
+function Float32x4LoadJS(A,B){
+return %Float32x4Load(A,B);
+}
+function Float32x4StoreJS(A,B,q){
+return %Float32x4Store(A,B,q);
+}
+
+
+function Int32x4ReplaceLaneJS(u,v,r){
+return %Int32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int32x4SelectJS(z,q,x){
+return %Int32x4Select(z,q,x);
+}
+function Int32x4AddJS(q,x){
+return %Int32x4Add(q,x);
+}
+function Int32x4SubJS(q,x){
+return %Int32x4Sub(q,x);
+}
+function Int32x4MulJS(q,x){
+return %Int32x4Mul(q,x);
+}
+function Int32x4MinJS(q,x){
+return %Int32x4Min(q,x);
+}
+function Int32x4MaxJS(q,x){
+return %Int32x4Max(q,x);
+}
+function Int32x4EqualJS(q,x){
+return %Int32x4Equal(q,x);
+}
+function Int32x4NotEqualJS(q,x){
+return %Int32x4NotEqual(q,x);
+}
+function Int32x4LessThanJS(q,x){
+return %Int32x4LessThan(q,x);
+}
+function Int32x4LessThanOrEqualJS(q,x){
+return %Int32x4LessThanOrEqual(q,x);
+}
+function Int32x4GreaterThanJS(q,x){
+return %Int32x4GreaterThan(q,x);
+}
+function Int32x4GreaterThanOrEqualJS(q,x){
+return %Int32x4GreaterThanOrEqual(q,x);
+}
+function Int32x4LoadJS(A,B){
+return %Int32x4Load(A,B);
+}
+function Int32x4StoreJS(A,B,q){
+return %Int32x4Store(A,B,q);
+}
+
+function Int16x8ReplaceLaneJS(u,v,r){
+return %Int16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int16x8SelectJS(z,q,x){
+return %Int16x8Select(z,q,x);
+}
+function Int16x8AddJS(q,x){
+return %Int16x8Add(q,x);
+}
+function Int16x8SubJS(q,x){
+return %Int16x8Sub(q,x);
+}
+function Int16x8MulJS(q,x){
+return %Int16x8Mul(q,x);
+}
+function Int16x8MinJS(q,x){
+return %Int16x8Min(q,x);
+}
+function Int16x8MaxJS(q,x){
+return %Int16x8Max(q,x);
+}
+function Int16x8EqualJS(q,x){
+return %Int16x8Equal(q,x);
+}
+function Int16x8NotEqualJS(q,x){
+return %Int16x8NotEqual(q,x);
+}
+function Int16x8LessThanJS(q,x){
+return %Int16x8LessThan(q,x);
+}
+function Int16x8LessThanOrEqualJS(q,x){
+return %Int16x8LessThanOrEqual(q,x);
+}
+function Int16x8GreaterThanJS(q,x){
+return %Int16x8GreaterThan(q,x);
+}
+function Int16x8GreaterThanOrEqualJS(q,x){
+return %Int16x8GreaterThanOrEqual(q,x);
+}
+function Int16x8LoadJS(A,B){
+return %Int16x8Load(A,B);
+}
+function Int16x8StoreJS(A,B,q){
+return %Int16x8Store(A,B,q);
+}
+
+function Int8x16ReplaceLaneJS(u,v,r){
+return %Int8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Int8x16SelectJS(z,q,x){
+return %Int8x16Select(z,q,x);
+}
+function Int8x16AddJS(q,x){
+return %Int8x16Add(q,x);
+}
+function Int8x16SubJS(q,x){
+return %Int8x16Sub(q,x);
+}
+function Int8x16MulJS(q,x){
+return %Int8x16Mul(q,x);
+}
+function Int8x16MinJS(q,x){
+return %Int8x16Min(q,x);
+}
+function Int8x16MaxJS(q,x){
+return %Int8x16Max(q,x);
+}
+function Int8x16EqualJS(q,x){
+return %Int8x16Equal(q,x);
+}
+function Int8x16NotEqualJS(q,x){
+return %Int8x16NotEqual(q,x);
+}
+function Int8x16LessThanJS(q,x){
+return %Int8x16LessThan(q,x);
+}
+function Int8x16LessThanOrEqualJS(q,x){
+return %Int8x16LessThanOrEqual(q,x);
+}
+function Int8x16GreaterThanJS(q,x){
+return %Int8x16GreaterThan(q,x);
+}
+function Int8x16GreaterThanOrEqualJS(q,x){
+return %Int8x16GreaterThanOrEqual(q,x);
+}
+function Int8x16LoadJS(A,B){
+return %Int8x16Load(A,B);
+}
+function Int8x16StoreJS(A,B,q){
+return %Int8x16Store(A,B,q);
+}
+
+
+function Uint32x4ReplaceLaneJS(u,v,r){
+return %Uint32x4ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint32x4SelectJS(z,q,x){
+return %Uint32x4Select(z,q,x);
+}
+function Uint32x4AddJS(q,x){
+return %Uint32x4Add(q,x);
+}
+function Uint32x4SubJS(q,x){
+return %Uint32x4Sub(q,x);
+}
+function Uint32x4MulJS(q,x){
+return %Uint32x4Mul(q,x);
+}
+function Uint32x4MinJS(q,x){
+return %Uint32x4Min(q,x);
+}
+function Uint32x4MaxJS(q,x){
+return %Uint32x4Max(q,x);
+}
+function Uint32x4EqualJS(q,x){
+return %Uint32x4Equal(q,x);
+}
+function Uint32x4NotEqualJS(q,x){
+return %Uint32x4NotEqual(q,x);
+}
+function Uint32x4LessThanJS(q,x){
+return %Uint32x4LessThan(q,x);
+}
+function Uint32x4LessThanOrEqualJS(q,x){
+return %Uint32x4LessThanOrEqual(q,x);
+}
+function Uint32x4GreaterThanJS(q,x){
+return %Uint32x4GreaterThan(q,x);
+}
+function Uint32x4GreaterThanOrEqualJS(q,x){
+return %Uint32x4GreaterThanOrEqual(q,x);
+}
+function Uint32x4LoadJS(A,B){
+return %Uint32x4Load(A,B);
+}
+function Uint32x4StoreJS(A,B,q){
+return %Uint32x4Store(A,B,q);
+}
+
+function Uint16x8ReplaceLaneJS(u,v,r){
+return %Uint16x8ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint16x8SelectJS(z,q,x){
+return %Uint16x8Select(z,q,x);
+}
+function Uint16x8AddJS(q,x){
+return %Uint16x8Add(q,x);
+}
+function Uint16x8SubJS(q,x){
+return %Uint16x8Sub(q,x);
+}
+function Uint16x8MulJS(q,x){
+return %Uint16x8Mul(q,x);
+}
+function Uint16x8MinJS(q,x){
+return %Uint16x8Min(q,x);
+}
+function Uint16x8MaxJS(q,x){
+return %Uint16x8Max(q,x);
+}
+function Uint16x8EqualJS(q,x){
+return %Uint16x8Equal(q,x);
+}
+function Uint16x8NotEqualJS(q,x){
+return %Uint16x8NotEqual(q,x);
+}
+function Uint16x8LessThanJS(q,x){
+return %Uint16x8LessThan(q,x);
+}
+function Uint16x8LessThanOrEqualJS(q,x){
+return %Uint16x8LessThanOrEqual(q,x);
+}
+function Uint16x8GreaterThanJS(q,x){
+return %Uint16x8GreaterThan(q,x);
+}
+function Uint16x8GreaterThanOrEqualJS(q,x){
+return %Uint16x8GreaterThanOrEqual(q,x);
+}
+function Uint16x8LoadJS(A,B){
+return %Uint16x8Load(A,B);
+}
+function Uint16x8StoreJS(A,B,q){
+return %Uint16x8Store(A,B,q);
+}
+
+function Uint8x16ReplaceLaneJS(u,v,r){
+return %Uint8x16ReplaceLane(u,v,(%_ToNumber(r)));
+}
+function Uint8x16SelectJS(z,q,x){
+return %Uint8x16Select(z,q,x);
+}
+function Uint8x16AddJS(q,x){
+return %Uint8x16Add(q,x);
+}
+function Uint8x16SubJS(q,x){
+return %Uint8x16Sub(q,x);
+}
+function Uint8x16MulJS(q,x){
+return %Uint8x16Mul(q,x);
+}
+function Uint8x16MinJS(q,x){
+return %Uint8x16Min(q,x);
+}
+function Uint8x16MaxJS(q,x){
+return %Uint8x16Max(q,x);
+}
+function Uint8x16EqualJS(q,x){
+return %Uint8x16Equal(q,x);
+}
+function Uint8x16NotEqualJS(q,x){
+return %Uint8x16NotEqual(q,x);
+}
+function Uint8x16LessThanJS(q,x){
+return %Uint8x16LessThan(q,x);
+}
+function Uint8x16LessThanOrEqualJS(q,x){
+return %Uint8x16LessThanOrEqual(q,x);
+}
+function Uint8x16GreaterThanJS(q,x){
+return %Uint8x16GreaterThan(q,x);
+}
+function Uint8x16GreaterThanOrEqualJS(q,x){
+return %Uint8x16GreaterThanOrEqual(q,x);
+}
+function Uint8x16LoadJS(A,B){
+return %Uint8x16Load(A,B);
+}
+function Uint8x16StoreJS(A,B,q){
+return %Uint8x16Store(A,B,q);
+}
+
+
+
+function Int32x4AndJS(q,x){
+return %Int32x4And(q,x);
+}
+function Int32x4OrJS(q,x){
+return %Int32x4Or(q,x);
+}
+function Int32x4XorJS(q,x){
+return %Int32x4Xor(q,x);
+}
+function Int32x4NotJS(q){
+return %Int32x4Not(q);
+}
+
+function Int16x8AndJS(q,x){
+return %Int16x8And(q,x);
+}
+function Int16x8OrJS(q,x){
+return %Int16x8Or(q,x);
+}
+function Int16x8XorJS(q,x){
+return %Int16x8Xor(q,x);
+}
+function Int16x8NotJS(q){
+return %Int16x8Not(q);
+}
+
+function Int8x16AndJS(q,x){
+return %Int8x16And(q,x);
+}
+function Int8x16OrJS(q,x){
+return %Int8x16Or(q,x);
+}
+function Int8x16XorJS(q,x){
+return %Int8x16Xor(q,x);
+}
+function Int8x16NotJS(q){
+return %Int8x16Not(q);
+}
+
+
+function Uint32x4AndJS(q,x){
+return %Uint32x4And(q,x);
+}
+function Uint32x4OrJS(q,x){
+return %Uint32x4Or(q,x);
+}
+function Uint32x4XorJS(q,x){
+return %Uint32x4Xor(q,x);
+}
+function Uint32x4NotJS(q){
+return %Uint32x4Not(q);
+}
+
+function Uint16x8AndJS(q,x){
+return %Uint16x8And(q,x);
+}
+function Uint16x8OrJS(q,x){
+return %Uint16x8Or(q,x);
+}
+function Uint16x8XorJS(q,x){
+return %Uint16x8Xor(q,x);
+}
+function Uint16x8NotJS(q){
+return %Uint16x8Not(q);
+}
+
+function Uint8x16AndJS(q,x){
+return %Uint8x16And(q,x);
+}
+function Uint8x16OrJS(q,x){
+return %Uint8x16Or(q,x);
+}
+function Uint8x16XorJS(q,x){
+return %Uint8x16Xor(q,x);
+}
+function Uint8x16NotJS(q){
+return %Uint8x16Not(q);
+}
+
+
+function Bool32x4AndJS(q,x){
+return %Bool32x4And(q,x);
+}
+function Bool32x4OrJS(q,x){
+return %Bool32x4Or(q,x);
+}
+function Bool32x4XorJS(q,x){
+return %Bool32x4Xor(q,x);
+}
+function Bool32x4NotJS(q){
+return %Bool32x4Not(q);
+}
+
+function Bool16x8AndJS(q,x){
+return %Bool16x8And(q,x);
+}
+function Bool16x8OrJS(q,x){
+return %Bool16x8Or(q,x);
+}
+function Bool16x8XorJS(q,x){
+return %Bool16x8Xor(q,x);
+}
+function Bool16x8NotJS(q){
+return %Bool16x8Not(q);
+}
+
+function Bool8x16AndJS(q,x){
+return %Bool8x16And(q,x);
+}
+function Bool8x16OrJS(q,x){
+return %Bool8x16Or(q,x);
+}
+function Bool8x16XorJS(q,x){
+return %Bool8x16Xor(q,x);
+}
+function Bool8x16NotJS(q){
+return %Bool8x16Not(q);
+}
+
+
+
+function Float32x4FromInt32x4JS(q){
+return %Float32x4FromInt32x4(q);
+}
+
+function Float32x4FromUint32x4JS(q){
+return %Float32x4FromUint32x4(q);
+}
+
+function Int32x4FromFloat32x4JS(q){
+return %Int32x4FromFloat32x4(q);
+}
+
+function Int32x4FromUint32x4JS(q){
+return %Int32x4FromUint32x4(q);
+}
+
+function Uint32x4FromFloat32x4JS(q){
+return %Uint32x4FromFloat32x4(q);
+}
+
+function Uint32x4FromInt32x4JS(q){
+return %Uint32x4FromInt32x4(q);
+}
+
+function Int16x8FromUint16x8JS(q){
+return %Int16x8FromUint16x8(q);
+}
+
+function Uint16x8FromInt16x8JS(q){
+return %Uint16x8FromInt16x8(q);
+}
+
+function Int8x16FromUint8x16JS(q){
+return %Int8x16FromUint8x16(q);
+}
+
+function Uint8x16FromInt8x16JS(q){
+return %Uint8x16FromInt8x16(q);
+}
+
+
+function Float32x4FromInt32x4BitsJS(q){
+return %Float32x4FromInt32x4Bits(q);
+}
+
+function Float32x4FromUint32x4BitsJS(q){
+return %Float32x4FromUint32x4Bits(q);
+}
+
+function Float32x4FromInt16x8BitsJS(q){
+return %Float32x4FromInt16x8Bits(q);
+}
+
+function Float32x4FromUint16x8BitsJS(q){
+return %Float32x4FromUint16x8Bits(q);
+}
+
+function Float32x4FromInt8x16BitsJS(q){
+return %Float32x4FromInt8x16Bits(q);
+}
+
+function Float32x4FromUint8x16BitsJS(q){
+return %Float32x4FromUint8x16Bits(q);
+}
+
+function Int32x4FromFloat32x4BitsJS(q){
+return %Int32x4FromFloat32x4Bits(q);
+}
+
+function Int32x4FromUint32x4BitsJS(q){
+return %Int32x4FromUint32x4Bits(q);
+}
+
+function Int32x4FromInt16x8BitsJS(q){
+return %Int32x4FromInt16x8Bits(q);
+}
+
+function Int32x4FromUint16x8BitsJS(q){
+return %Int32x4FromUint16x8Bits(q);
+}
+
+function Int32x4FromInt8x16BitsJS(q){
+return %Int32x4FromInt8x16Bits(q);
+}
+
+function Int32x4FromUint8x16BitsJS(q){
+return %Int32x4FromUint8x16Bits(q);
+}
+
+function Uint32x4FromFloat32x4BitsJS(q){
+return %Uint32x4FromFloat32x4Bits(q);
+}
+
+function Uint32x4FromInt32x4BitsJS(q){
+return %Uint32x4FromInt32x4Bits(q);
+}
+
+function Uint32x4FromInt16x8BitsJS(q){
+return %Uint32x4FromInt16x8Bits(q);
+}
+
+function Uint32x4FromUint16x8BitsJS(q){
+return %Uint32x4FromUint16x8Bits(q);
+}
+
+function Uint32x4FromInt8x16BitsJS(q){
+return %Uint32x4FromInt8x16Bits(q);
+}
+
+function Uint32x4FromUint8x16BitsJS(q){
+return %Uint32x4FromUint8x16Bits(q);
+}
+
+function Int16x8FromFloat32x4BitsJS(q){
+return %Int16x8FromFloat32x4Bits(q);
+}
+
+function Int16x8FromInt32x4BitsJS(q){
+return %Int16x8FromInt32x4Bits(q);
+}
+
+function Int16x8FromUint32x4BitsJS(q){
+return %Int16x8FromUint32x4Bits(q);
+}
+
+function Int16x8FromUint16x8BitsJS(q){
+return %Int16x8FromUint16x8Bits(q);
+}
+
+function Int16x8FromInt8x16BitsJS(q){
+return %Int16x8FromInt8x16Bits(q);
+}
+
+function Int16x8FromUint8x16BitsJS(q){
+return %Int16x8FromUint8x16Bits(q);
+}
+
+function Uint16x8FromFloat32x4BitsJS(q){
+return %Uint16x8FromFloat32x4Bits(q);
+}
+
+function Uint16x8FromInt32x4BitsJS(q){
+return %Uint16x8FromInt32x4Bits(q);
+}
+
+function Uint16x8FromUint32x4BitsJS(q){
+return %Uint16x8FromUint32x4Bits(q);
+}
+
+function Uint16x8FromInt16x8BitsJS(q){
+return %Uint16x8FromInt16x8Bits(q);
+}
+
+function Uint16x8FromInt8x16BitsJS(q){
+return %Uint16x8FromInt8x16Bits(q);
+}
+
+function Uint16x8FromUint8x16BitsJS(q){
+return %Uint16x8FromUint8x16Bits(q);
+}
+
+function Int8x16FromFloat32x4BitsJS(q){
+return %Int8x16FromFloat32x4Bits(q);
+}
+
+function Int8x16FromInt32x4BitsJS(q){
+return %Int8x16FromInt32x4Bits(q);
+}
+
+function Int8x16FromUint32x4BitsJS(q){
+return %Int8x16FromUint32x4Bits(q);
+}
+
+function Int8x16FromInt16x8BitsJS(q){
+return %Int8x16FromInt16x8Bits(q);
+}
+
+function Int8x16FromUint16x8BitsJS(q){
+return %Int8x16FromUint16x8Bits(q);
+}
+
+function Int8x16FromUint8x16BitsJS(q){
+return %Int8x16FromUint8x16Bits(q);
+}
+
+function Uint8x16FromFloat32x4BitsJS(q){
+return %Uint8x16FromFloat32x4Bits(q);
+}
+
+function Uint8x16FromInt32x4BitsJS(q){
+return %Uint8x16FromInt32x4Bits(q);
+}
+
+function Uint8x16FromUint32x4BitsJS(q){
+return %Uint8x16FromUint32x4Bits(q);
+}
+
+function Uint8x16FromInt16x8BitsJS(q){
+return %Uint8x16FromInt16x8Bits(q);
+}
+
+function Uint8x16FromUint16x8BitsJS(q){
+return %Uint8x16FromUint16x8Bits(q);
+}
+
+function Uint8x16FromInt8x16BitsJS(q){
+return %Uint8x16FromInt8x16Bits(q);
+}
+
+
+function Float32x4Load1JS(A,B){
+return %Float32x4Load1(A,B);
+}
+function Float32x4Store1JS(A,B,q){
+return %Float32x4Store1(A,B,q);
+}
+
+function Float32x4Load2JS(A,B){
+return %Float32x4Load2(A,B);
+}
+function Float32x4Store2JS(A,B,q){
+return %Float32x4Store2(A,B,q);
+}
+
+function Float32x4Load3JS(A,B){
+return %Float32x4Load3(A,B);
+}
+function Float32x4Store3JS(A,B,q){
+return %Float32x4Store3(A,B,q);
+}
+
+function Int32x4Load1JS(A,B){
+return %Int32x4Load1(A,B);
+}
+function Int32x4Store1JS(A,B,q){
+return %Int32x4Store1(A,B,q);
+}
+
+function Int32x4Load2JS(A,B){
+return %Int32x4Load2(A,B);
+}
+function Int32x4Store2JS(A,B,q){
+return %Int32x4Store2(A,B,q);
+}
+
+function Int32x4Load3JS(A,B){
+return %Int32x4Load3(A,B);
+}
+function Int32x4Store3JS(A,B,q){
+return %Int32x4Store3(A,B,q);
+}
+
+function Uint32x4Load1JS(A,B){
+return %Uint32x4Load1(A,B);
+}
+function Uint32x4Store1JS(A,B,q){
+return %Uint32x4Store1(A,B,q);
+}
+
+function Uint32x4Load2JS(A,B){
+return %Uint32x4Load2(A,B);
+}
+function Uint32x4Store2JS(A,B,q){
+return %Uint32x4Store2(A,B,q);
+}
+
+function Uint32x4Load3JS(A,B){
+return %Uint32x4Load3(A,B);
+}
+function Uint32x4Store3JS(A,B,q){
+return %Uint32x4Store3(A,B,q);
+}
+
+
+function Float32x4Splat(y){
+return %CreateFloat32x4(y,y,y,y);
+}
+function Float32x4SwizzleJS(q,C,D,E,F){
+return %Float32x4Swizzle(q,C,D,E,F);
+}
+function Float32x4ShuffleJS(q,x,C,D,E,F){
+return %Float32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Int32x4Splat(y){
+return %CreateInt32x4(y,y,y,y);
+}
+function Int32x4SwizzleJS(q,C,D,E,F){
+return %Int32x4Swizzle(q,C,D,E,F);
+}
+function Int32x4ShuffleJS(q,x,C,D,E,F){
+return %Int32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Uint32x4Splat(y){
+return %CreateUint32x4(y,y,y,y);
+}
+function Uint32x4SwizzleJS(q,C,D,E,F){
+return %Uint32x4Swizzle(q,C,D,E,F);
+}
+function Uint32x4ShuffleJS(q,x,C,D,E,F){
+return %Uint32x4Shuffle(q,x,C,D,E,F);
+}
+
+function Bool32x4Splat(y){
+return %CreateBool32x4(y,y,y,y);
+}
+function Bool32x4SwizzleJS(q,C,D,E,F){
+return %Bool32x4Swizzle(q,C,D,E,F);
+}
+function Bool32x4ShuffleJS(q,x,C,D,E,F){
+return %Bool32x4Shuffle(q,x,C,D,E,F);
+}
+
+
+function Int16x8Splat(y){
+return %CreateInt16x8(y,y,y,y,y,y,y,y);
+}
+function Int16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Int16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Int16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Int16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Uint16x8Splat(y){
+return %CreateUint16x8(y,y,y,y,y,y,y,y);
+}
+function Uint16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Uint16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Uint16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Uint16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+function Bool16x8Splat(y){
+return %CreateBool16x8(y,y,y,y,y,y,y,y);
+}
+function Bool16x8SwizzleJS(q,C,D,E,F,G,H,I,J){
+return %Bool16x8Swizzle(q,C,D,E,F,G,H,I,J);
+}
+function Bool16x8ShuffleJS(q,x,C,D,E,F,G,H,I,J){
+return %Bool16x8Shuffle(q,x,C,D,E,F,G,H,I,J);
+}
+
+
+function Int8x16Splat(y){
+return %CreateInt8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Int8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Int8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Int8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Int8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Uint8x16Splat(y){
+return %CreateUint8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Uint8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Uint8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Uint8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Uint8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+function Bool8x16Splat(y){
+return %CreateBool8x16(y,y,y,y,y,y,y,y,y,y,y,y,y,y,y,y);
+}
+function Bool8x16SwizzleJS(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+return %Bool8x16Swizzle(q,C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15);
+}
+function Bool8x16ShuffleJS(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15){
+return %Bool8x16Shuffle(q,x,C,D,E,F,G,H,I,J,c8,c9,c10,
+c11,c12,c13,c14,c15);
+}
+
+
+function Float32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Float32x4");
+}
+return %CreateFloat32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Int32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Int32x4");
+}
+return %CreateInt32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Uint32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Uint32x4");
+}
+return %CreateUint32x4((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)));
+}
+function Bool32x4Constructor(C,D,E,F){
+if(!(new.target===(void 0))){
+throw d(62,"Bool32x4");
+}
+return %CreateBool32x4(C,D,E,F);
+}
+function Int16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Int16x8");
+}
+return %CreateInt16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Uint16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Uint16x8");
+}
+return %CreateUint16x8((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)));
+}
+function Bool16x8Constructor(C,D,E,F,G,H,I,J){
+if(!(new.target===(void 0))){
+throw d(62,"Bool16x8");
+}
+return %CreateBool16x8(C,D,E,F,G,H,I,J);
+}
+function Int8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Int8x16");
+}
+return %CreateInt8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Uint8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Uint8x16");
+}
+return %CreateUint8x16((%_ToNumber(C)),(%_ToNumber(D)),
+(%_ToNumber(E)),(%_ToNumber(F)),
+(%_ToNumber(G)),(%_ToNumber(H)),
+(%_ToNumber(I)),(%_ToNumber(J)),
+(%_ToNumber(c8)),(%_ToNumber(c9)),
+(%_ToNumber(c10)),(%_ToNumber(c11)),
+(%_ToNumber(c12)),(%_ToNumber(c13)),
+(%_ToNumber(c14)),(%_ToNumber(c15)));
+}
+function Bool8x16Constructor(C,D,E,F,G,H,I,J,c8,c9,c10,c11,
+c12,c13,c14,c15){
+if(!(new.target===(void 0))){
+throw d(62,"Bool8x16");
+}
+return %CreateBool8x16(C,D,E,F,G,H,I,J,c8,c9,c10,c11,c12,
+c13,c14,c15);
+}
+function Float32x4AbsJS(q){
+return %Float32x4Abs(q);
+}
+function Float32x4SqrtJS(q){
+return %Float32x4Sqrt(q);
+}
+function Float32x4RecipApproxJS(q){
+return %Float32x4RecipApprox(q);
+}
+function Float32x4RecipSqrtApproxJS(q){
+return %Float32x4RecipSqrtApprox(q);
+}
+function Float32x4DivJS(q,x){
+return %Float32x4Div(q,x);
+}
+function Float32x4MinNumJS(q,x){
+return %Float32x4MinNum(q,x);
+}
+function Float32x4MaxNumJS(q,x){
+return %Float32x4MaxNum(q,x);
+}
+%AddNamedProperty(c,e,'SIMD',1|2);
+%SetCode(g,Float32x4Constructor);
+%FunctionSetPrototype(g,{});
+%AddNamedProperty(g.prototype,'constructor',g,
+2);
+%AddNamedProperty(g.prototype,e,'Float32x4',
+2|1);
+b.InstallFunctions(g.prototype,2,[
+'toLocaleString',Float32x4ToLocaleString,
+'toString',Float32x4ToString,
+'valueOf',Float32x4ValueOf,
+]);
+
+
+%SetCode(h,Int32x4Constructor);
+%FunctionSetPrototype(h,{});
+%AddNamedProperty(h.prototype,'constructor',h,
+2);
+%AddNamedProperty(h.prototype,e,'Int32x4',
+2|1);
+b.InstallFunctions(h.prototype,2,[
+'toLocaleString',Int32x4ToLocaleString,
+'toString',Int32x4ToString,
+'valueOf',Int32x4ValueOf,
+]);
+
+%SetCode(i,Int16x8Constructor);
+%FunctionSetPrototype(i,{});
+%AddNamedProperty(i.prototype,'constructor',i,
+2);
+%AddNamedProperty(i.prototype,e,'Int16x8',
+2|1);
+b.InstallFunctions(i.prototype,2,[
+'toLocaleString',Int16x8ToLocaleString,
+'toString',Int16x8ToString,
+'valueOf',Int16x8ValueOf,
+]);
+
+%SetCode(j,Int8x16Constructor);
+%FunctionSetPrototype(j,{});
+%AddNamedProperty(j.prototype,'constructor',j,
+2);
+%AddNamedProperty(j.prototype,e,'Int8x16',
+2|1);
+b.InstallFunctions(j.prototype,2,[
+'toLocaleString',Int8x16ToLocaleString,
+'toString',Int8x16ToString,
+'valueOf',Int8x16ValueOf,
+]);
+
+
+%SetCode(k,Uint32x4Constructor);
+%FunctionSetPrototype(k,{});
+%AddNamedProperty(k.prototype,'constructor',k,
+2);
+%AddNamedProperty(k.prototype,e,'Uint32x4',
+2|1);
+b.InstallFunctions(k.prototype,2,[
+'toLocaleString',Uint32x4ToLocaleString,
+'toString',Uint32x4ToString,
+'valueOf',Uint32x4ValueOf,
+]);
+
+%SetCode(l,Uint16x8Constructor);
+%FunctionSetPrototype(l,{});
+%AddNamedProperty(l.prototype,'constructor',l,
+2);
+%AddNamedProperty(l.prototype,e,'Uint16x8',
+2|1);
+b.InstallFunctions(l.prototype,2,[
+'toLocaleString',Uint16x8ToLocaleString,
+'toString',Uint16x8ToString,
+'valueOf',Uint16x8ValueOf,
+]);
+
+%SetCode(m,Uint8x16Constructor);
+%FunctionSetPrototype(m,{});
+%AddNamedProperty(m.prototype,'constructor',m,
+2);
+%AddNamedProperty(m.prototype,e,'Uint8x16',
+2|1);
+b.InstallFunctions(m.prototype,2,[
+'toLocaleString',Uint8x16ToLocaleString,
+'toString',Uint8x16ToString,
+'valueOf',Uint8x16ValueOf,
+]);
+
+
+%SetCode(n,Bool32x4Constructor);
+%FunctionSetPrototype(n,{});
+%AddNamedProperty(n.prototype,'constructor',n,
+2);
+%AddNamedProperty(n.prototype,e,'Bool32x4',
+2|1);
+b.InstallFunctions(n.prototype,2,[
+'toLocaleString',Bool32x4ToLocaleString,
+'toString',Bool32x4ToString,
+'valueOf',Bool32x4ValueOf,
+]);
+
+%SetCode(o,Bool16x8Constructor);
+%FunctionSetPrototype(o,{});
+%AddNamedProperty(o.prototype,'constructor',o,
+2);
+%AddNamedProperty(o.prototype,e,'Bool16x8',
+2|1);
+b.InstallFunctions(o.prototype,2,[
+'toLocaleString',Bool16x8ToLocaleString,
+'toString',Bool16x8ToString,
+'valueOf',Bool16x8ValueOf,
+]);
+
+%SetCode(p,Bool8x16Constructor);
+%FunctionSetPrototype(p,{});
+%AddNamedProperty(p.prototype,'constructor',p,
+2);
+%AddNamedProperty(p.prototype,e,'Bool8x16',
+2|1);
+b.InstallFunctions(p.prototype,2,[
+'toLocaleString',Bool8x16ToLocaleString,
+'toString',Bool8x16ToString,
+'valueOf',Bool8x16ValueOf,
+]);
+
+
+
+b.InstallFunctions(g,2,[
+'splat',Float32x4Splat,
+'check',Float32x4CheckJS,
+'extractLane',Float32x4ExtractLaneJS,
+'replaceLane',Float32x4ReplaceLaneJS,
+'neg',Float32x4NegJS,
+'abs',Float32x4AbsJS,
+'sqrt',Float32x4SqrtJS,
+'reciprocalApproximation',Float32x4RecipApproxJS,
+'reciprocalSqrtApproximation',Float32x4RecipSqrtApproxJS,
+'add',Float32x4AddJS,
+'sub',Float32x4SubJS,
+'mul',Float32x4MulJS,
+'div',Float32x4DivJS,
+'min',Float32x4MinJS,
+'max',Float32x4MaxJS,
+'minNum',Float32x4MinNumJS,
+'maxNum',Float32x4MaxNumJS,
+'lessThan',Float32x4LessThanJS,
+'lessThanOrEqual',Float32x4LessThanOrEqualJS,
+'greaterThan',Float32x4GreaterThanJS,
+'greaterThanOrEqual',Float32x4GreaterThanOrEqualJS,
+'equal',Float32x4EqualJS,
+'notEqual',Float32x4NotEqualJS,
+'select',Float32x4SelectJS,
+'swizzle',Float32x4SwizzleJS,
+'shuffle',Float32x4ShuffleJS,
+'fromInt32x4',Float32x4FromInt32x4JS,
+'fromUint32x4',Float32x4FromUint32x4JS,
+'fromInt32x4Bits',Float32x4FromInt32x4BitsJS,
+'fromUint32x4Bits',Float32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Float32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Float32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Float32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Float32x4FromUint8x16BitsJS,
+'load',Float32x4LoadJS,
+'load1',Float32x4Load1JS,
+'load2',Float32x4Load2JS,
+'load3',Float32x4Load3JS,
+'store',Float32x4StoreJS,
+'store1',Float32x4Store1JS,
+'store2',Float32x4Store2JS,
+'store3',Float32x4Store3JS,
+]);
+b.InstallFunctions(h,2,[
+'splat',Int32x4Splat,
+'check',Int32x4CheckJS,
+'extractLane',Int32x4ExtractLaneJS,
+'replaceLane',Int32x4ReplaceLaneJS,
+'neg',Int32x4NegJS,
+'add',Int32x4AddJS,
+'sub',Int32x4SubJS,
+'mul',Int32x4MulJS,
+'min',Int32x4MinJS,
+'max',Int32x4MaxJS,
+'and',Int32x4AndJS,
+'or',Int32x4OrJS,
+'xor',Int32x4XorJS,
+'not',Int32x4NotJS,
+'shiftLeftByScalar',Int32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Int32x4ShiftRightByScalarJS,
+'lessThan',Int32x4LessThanJS,
+'lessThanOrEqual',Int32x4LessThanOrEqualJS,
+'greaterThan',Int32x4GreaterThanJS,
+'greaterThanOrEqual',Int32x4GreaterThanOrEqualJS,
+'equal',Int32x4EqualJS,
+'notEqual',Int32x4NotEqualJS,
+'select',Int32x4SelectJS,
+'swizzle',Int32x4SwizzleJS,
+'shuffle',Int32x4ShuffleJS,
+'fromFloat32x4',Int32x4FromFloat32x4JS,
+'fromUint32x4',Int32x4FromUint32x4JS,
+'fromFloat32x4Bits',Int32x4FromFloat32x4BitsJS,
+'fromUint32x4Bits',Int32x4FromUint32x4BitsJS,
+'fromInt16x8Bits',Int32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Int32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Int32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Int32x4FromUint8x16BitsJS,
+'load',Int32x4LoadJS,
+'load1',Int32x4Load1JS,
+'load2',Int32x4Load2JS,
+'load3',Int32x4Load3JS,
+'store',Int32x4StoreJS,
+'store1',Int32x4Store1JS,
+'store2',Int32x4Store2JS,
+'store3',Int32x4Store3JS,
+]);
+b.InstallFunctions(k,2,[
+'splat',Uint32x4Splat,
+'check',Uint32x4CheckJS,
+'extractLane',Uint32x4ExtractLaneJS,
+'replaceLane',Uint32x4ReplaceLaneJS,
+'add',Uint32x4AddJS,
+'sub',Uint32x4SubJS,
+'mul',Uint32x4MulJS,
+'min',Uint32x4MinJS,
+'max',Uint32x4MaxJS,
+'and',Uint32x4AndJS,
+'or',Uint32x4OrJS,
+'xor',Uint32x4XorJS,
+'not',Uint32x4NotJS,
+'shiftLeftByScalar',Uint32x4ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint32x4ShiftRightByScalarJS,
+'lessThan',Uint32x4LessThanJS,
+'lessThanOrEqual',Uint32x4LessThanOrEqualJS,
+'greaterThan',Uint32x4GreaterThanJS,
+'greaterThanOrEqual',Uint32x4GreaterThanOrEqualJS,
+'equal',Uint32x4EqualJS,
+'notEqual',Uint32x4NotEqualJS,
+'select',Uint32x4SelectJS,
+'swizzle',Uint32x4SwizzleJS,
+'shuffle',Uint32x4ShuffleJS,
+'fromFloat32x4',Uint32x4FromFloat32x4JS,
+'fromInt32x4',Uint32x4FromInt32x4JS,
+'fromFloat32x4Bits',Uint32x4FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint32x4FromInt32x4BitsJS,
+'fromInt16x8Bits',Uint32x4FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint32x4FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint32x4FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint32x4FromUint8x16BitsJS,
+'load',Uint32x4LoadJS,
+'load1',Uint32x4Load1JS,
+'load2',Uint32x4Load2JS,
+'load3',Uint32x4Load3JS,
+'store',Uint32x4StoreJS,
+'store1',Uint32x4Store1JS,
+'store2',Uint32x4Store2JS,
+'store3',Uint32x4Store3JS,
+]);
+b.InstallFunctions(n,2,[
+'splat',Bool32x4Splat,
+'check',Bool32x4CheckJS,
+'extractLane',Bool32x4ExtractLaneJS,
+'replaceLane',Bool32x4ReplaceLaneJS,
+'and',Bool32x4AndJS,
+'or',Bool32x4OrJS,
+'xor',Bool32x4XorJS,
+'not',Bool32x4NotJS,
+'anyTrue',Bool32x4AnyTrueJS,
+'allTrue',Bool32x4AllTrueJS,
+'swizzle',Bool32x4SwizzleJS,
+'shuffle',Bool32x4ShuffleJS,
+]);
+b.InstallFunctions(i,2,[
+'splat',Int16x8Splat,
+'check',Int16x8CheckJS,
+'extractLane',Int16x8ExtractLaneJS,
+'replaceLane',Int16x8ReplaceLaneJS,
+'neg',Int16x8NegJS,
+'add',Int16x8AddJS,
+'sub',Int16x8SubJS,
+'addSaturate',Int16x8AddSaturateJS,
+'subSaturate',Int16x8SubSaturateJS,
+'mul',Int16x8MulJS,
+'min',Int16x8MinJS,
+'max',Int16x8MaxJS,
+'and',Int16x8AndJS,
+'or',Int16x8OrJS,
+'xor',Int16x8XorJS,
+'not',Int16x8NotJS,
+'shiftLeftByScalar',Int16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Int16x8ShiftRightByScalarJS,
+'lessThan',Int16x8LessThanJS,
+'lessThanOrEqual',Int16x8LessThanOrEqualJS,
+'greaterThan',Int16x8GreaterThanJS,
+'greaterThanOrEqual',Int16x8GreaterThanOrEqualJS,
+'equal',Int16x8EqualJS,
+'notEqual',Int16x8NotEqualJS,
+'select',Int16x8SelectJS,
+'swizzle',Int16x8SwizzleJS,
+'shuffle',Int16x8ShuffleJS,
+'fromUint16x8',Int16x8FromUint16x8JS,
+'fromFloat32x4Bits',Int16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Int16x8FromUint32x4BitsJS,
+'fromUint16x8Bits',Int16x8FromUint16x8BitsJS,
+'fromInt8x16Bits',Int16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Int16x8FromUint8x16BitsJS,
+'load',Int16x8LoadJS,
+'store',Int16x8StoreJS,
+]);
+b.InstallFunctions(l,2,[
+'splat',Uint16x8Splat,
+'check',Uint16x8CheckJS,
+'extractLane',Uint16x8ExtractLaneJS,
+'replaceLane',Uint16x8ReplaceLaneJS,
+'add',Uint16x8AddJS,
+'sub',Uint16x8SubJS,
+'addSaturate',Uint16x8AddSaturateJS,
+'subSaturate',Uint16x8SubSaturateJS,
+'mul',Uint16x8MulJS,
+'min',Uint16x8MinJS,
+'max',Uint16x8MaxJS,
+'and',Uint16x8AndJS,
+'or',Uint16x8OrJS,
+'xor',Uint16x8XorJS,
+'not',Uint16x8NotJS,
+'shiftLeftByScalar',Uint16x8ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint16x8ShiftRightByScalarJS,
+'lessThan',Uint16x8LessThanJS,
+'lessThanOrEqual',Uint16x8LessThanOrEqualJS,
+'greaterThan',Uint16x8GreaterThanJS,
+'greaterThanOrEqual',Uint16x8GreaterThanOrEqualJS,
+'equal',Uint16x8EqualJS,
+'notEqual',Uint16x8NotEqualJS,
+'select',Uint16x8SelectJS,
+'swizzle',Uint16x8SwizzleJS,
+'shuffle',Uint16x8ShuffleJS,
+'fromInt16x8',Uint16x8FromInt16x8JS,
+'fromFloat32x4Bits',Uint16x8FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint16x8FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint16x8FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint16x8FromInt16x8BitsJS,
+'fromInt8x16Bits',Uint16x8FromInt8x16BitsJS,
+'fromUint8x16Bits',Uint16x8FromUint8x16BitsJS,
+'load',Uint16x8LoadJS,
+'store',Uint16x8StoreJS,
+]);
+b.InstallFunctions(o,2,[
+'splat',Bool16x8Splat,
+'check',Bool16x8CheckJS,
+'extractLane',Bool16x8ExtractLaneJS,
+'replaceLane',Bool16x8ReplaceLaneJS,
+'and',Bool16x8AndJS,
+'or',Bool16x8OrJS,
+'xor',Bool16x8XorJS,
+'not',Bool16x8NotJS,
+'anyTrue',Bool16x8AnyTrueJS,
+'allTrue',Bool16x8AllTrueJS,
+'swizzle',Bool16x8SwizzleJS,
+'shuffle',Bool16x8ShuffleJS,
+]);
+b.InstallFunctions(j,2,[
+'splat',Int8x16Splat,
+'check',Int8x16CheckJS,
+'extractLane',Int8x16ExtractLaneJS,
+'replaceLane',Int8x16ReplaceLaneJS,
+'neg',Int8x16NegJS,
+'add',Int8x16AddJS,
+'sub',Int8x16SubJS,
+'addSaturate',Int8x16AddSaturateJS,
+'subSaturate',Int8x16SubSaturateJS,
+'mul',Int8x16MulJS,
+'min',Int8x16MinJS,
+'max',Int8x16MaxJS,
+'and',Int8x16AndJS,
+'or',Int8x16OrJS,
+'xor',Int8x16XorJS,
+'not',Int8x16NotJS,
+'shiftLeftByScalar',Int8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Int8x16ShiftRightByScalarJS,
+'lessThan',Int8x16LessThanJS,
+'lessThanOrEqual',Int8x16LessThanOrEqualJS,
+'greaterThan',Int8x16GreaterThanJS,
+'greaterThanOrEqual',Int8x16GreaterThanOrEqualJS,
+'equal',Int8x16EqualJS,
+'notEqual',Int8x16NotEqualJS,
+'select',Int8x16SelectJS,
+'swizzle',Int8x16SwizzleJS,
+'shuffle',Int8x16ShuffleJS,
+'fromUint8x16',Int8x16FromUint8x16JS,
+'fromFloat32x4Bits',Int8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Int8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Int8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Int8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Int8x16FromUint16x8BitsJS,
+'fromUint8x16Bits',Int8x16FromUint8x16BitsJS,
+'load',Int8x16LoadJS,
+'store',Int8x16StoreJS,
+]);
+b.InstallFunctions(m,2,[
+'splat',Uint8x16Splat,
+'check',Uint8x16CheckJS,
+'extractLane',Uint8x16ExtractLaneJS,
+'replaceLane',Uint8x16ReplaceLaneJS,
+'add',Uint8x16AddJS,
+'sub',Uint8x16SubJS,
+'addSaturate',Uint8x16AddSaturateJS,
+'subSaturate',Uint8x16SubSaturateJS,
+'mul',Uint8x16MulJS,
+'min',Uint8x16MinJS,
+'max',Uint8x16MaxJS,
+'and',Uint8x16AndJS,
+'or',Uint8x16OrJS,
+'xor',Uint8x16XorJS,
+'not',Uint8x16NotJS,
+'shiftLeftByScalar',Uint8x16ShiftLeftByScalarJS,
+'shiftRightByScalar',Uint8x16ShiftRightByScalarJS,
+'lessThan',Uint8x16LessThanJS,
+'lessThanOrEqual',Uint8x16LessThanOrEqualJS,
+'greaterThan',Uint8x16GreaterThanJS,
+'greaterThanOrEqual',Uint8x16GreaterThanOrEqualJS,
+'equal',Uint8x16EqualJS,
+'notEqual',Uint8x16NotEqualJS,
+'select',Uint8x16SelectJS,
+'swizzle',Uint8x16SwizzleJS,
+'shuffle',Uint8x16ShuffleJS,
+'fromInt8x16',Uint8x16FromInt8x16JS,
+'fromFloat32x4Bits',Uint8x16FromFloat32x4BitsJS,
+'fromInt32x4Bits',Uint8x16FromInt32x4BitsJS,
+'fromUint32x4Bits',Uint8x16FromUint32x4BitsJS,
+'fromInt16x8Bits',Uint8x16FromInt16x8BitsJS,
+'fromUint16x8Bits',Uint8x16FromUint16x8BitsJS,
+'fromInt8x16Bits',Uint8x16FromInt8x16BitsJS,
+'load',Uint8x16LoadJS,
+'store',Uint8x16StoreJS,
+]);
+b.InstallFunctions(p,2,[
+'splat',Bool8x16Splat,
+'check',Bool8x16CheckJS,
+'extractLane',Bool8x16ExtractLaneJS,
+'replaceLane',Bool8x16ReplaceLaneJS,
+'and',Bool8x16AndJS,
+'or',Bool8x16OrJS,
+'xor',Bool8x16XorJS,
+'not',Bool8x16NotJS,
+'anyTrue',Bool8x16AnyTrueJS,
+'allTrue',Bool8x16AllTrueJS,
+'swizzle',Bool8x16SwizzleJS,
+'shuffle',Bool8x16ShuffleJS,
+]);
+b.Export(function(K){
+K.Float32x4ToString=Float32x4ToString;
+K.Int32x4ToString=Int32x4ToString;
+K.Uint32x4ToString=Uint32x4ToString;
+K.Bool32x4ToString=Bool32x4ToString;
+K.Int16x8ToString=Int16x8ToString;
+K.Uint16x8ToString=Uint16x8ToString;
+K.Bool16x8ToString=Bool16x8ToString;
+K.Int8x16ToString=Int8x16ToString;
+K.Uint8x16ToString=Uint8x16ToString;
+K.Bool8x16ToString=Bool8x16ToString;
+});
+})
+
+<harmony-speciesE
+(function(a,b,c){
+"use strict";
+%CheckIsBootstrapping();
+var d=a.Array;
+var e=a.Uint8Array.__proto__;
+var f=a.Map;
+var g=a.Set;
+var h=a.ArrayBuffer;
+var i=a.Promise;
+var j=a.RegExp;
+var k=b.ImportNow("species_symbol");
+function ArraySpecies(){
+return this;
+}
+function TypedArraySpecies(){
+return this;
+}
+function MapSpecies(){
+return this;
+}
+function SetSpecies(){
+return this;
+}
+function ArrayBufferSpecies(){
+return this;
+}
+function PromiseSpecies(){
+return this;
+}
+function RegExpSpecies(){
+return this;
+}
+b.InstallGetter(d,k,ArraySpecies,2);
+b.InstallGetter(e,k,TypedArraySpecies,2);
+b.InstallGetter(f,k,MapSpecies,2);
+b.InstallGetter(g,k,SetSpecies,2);
+b.InstallGetter(h,k,ArrayBufferSpecies,
+2);
+b.InstallGetter(i,k,PromiseSpecies,2);
+b.InstallGetter(j,k,RegExpSpecies,2);
+});
+
+\harmony-unicode-regexps±
+(function(a,b){
+'use strict';
+%CheckIsBootstrapping();
+var c=a.RegExp;
+var d=c.prototype;
+var e;
+b.Import(function(f){
+e=f.MakeTypeError;
+});
+function RegExpGetUnicode(){
+if(!(%_IsRegExp(this))){
+if(this===d){
+%IncrementUseCounter(13);
+return(void 0);
+}
+throw e(131,"RegExp.prototype.unicode");
+}
+return!!(%_RegExpFlags(this)&16);
+}
+%FunctionSetName(RegExpGetUnicode,"RegExp.prototype.unicode");
+%SetNativeFlag(RegExpGetUnicode);
+b.InstallGetter(c.prototype,'unicode',RegExpGetUnicode);
+})
+
+4promise-extra‰
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Promise;
+var d=b.ImportNow("PromiseChain");
+var e=b.ImportNow("PromiseDeferred");
+var f=b.ImportNow("PromiseResolved");
+b.InstallFunctions(c.prototype,2,[
+"chain",d,
+]);
+b.InstallFunctions(c,2,[
+"defer",e,
+"accept",f,
+]);
+})
+
+XReadableStreamTempStubm
+(function(global, binding, v8) {
+  'use strict';
+  const TypeError = global.TypeError;
+  const defineProperty = global.Object.defineProperty;
+  class ReadableStream {
+    constructor() {
+      throw new TypeError('Illegal constructor');
+    }
+    getReader() {
+      throw new TypeError('Illegal invocation');
+    }
+    cancel() {
+      throw new TypeError('Illegal invocation');
+    }
+  }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+dByteLengthQueuingStrategyÑ
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class ByteLengthQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return chunk.byteLength; }
+  }
+  defineProperty(global, 'ByteLengthQueuingStrategy', {
+    value: ByteLengthQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+PCountQueuingStrategyY
+(function(global, binding, v8) {
+  'use strict';
+  const defineProperty = global.Object.defineProperty;
+  class CountQueuingStrategy {
+    constructor(options) {
+      defineProperty(this, 'highWaterMark', {
+        value: options.highWaterMark,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    size(chunk) { return 1; }
+  }
+  defineProperty(global, 'CountQueuingStrategy', {
+    value: CountQueuingStrategy,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+});
+8ReadableStreamVg

+(function(global, binding, v8) {
+  'use strict';
+  const readableStreamController = v8.createPrivateSymbol('[[controller]]');
+  const readableStreamQueue = v8.createPrivateSymbol('[[queue]]');
+  const readableStreamQueueSize =
+      v8.createPrivateSymbol('[[queue]] total size');
+  const readableStreamReader = v8.createPrivateSymbol('[[reader]]');
+  const readableStreamState = v8.createPrivateSymbol('[[state]]');
+  const readableStreamStoredError = v8.createPrivateSymbol('[[storedError]]');
+  const readableStreamStrategySize = v8.createPrivateSymbol('[[strategySize]]');
+  const readableStreamStrategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
+  const readableStreamUnderlyingSource =
+      v8.createPrivateSymbol('[[underlyingSource]]');
+  const readableStreamControllerControlledReadableStream =
+      v8.createPrivateSymbol('[[controlledReadableStream]]');
+  const readableStreamReaderClosedPromise =
+      v8.createPrivateSymbol('[[closedPromise]]');
+  const readableStreamReaderOwnerReadableStream =
+      v8.createPrivateSymbol('[[ownerReadableStream]]');
+  const readableStreamReaderReadRequests =
+      v8.createPrivateSymbol('[[readRequests]]');
+  const STATE_READABLE = 0;
+  const STATE_CLOSED = 1;
+  const STATE_ERRORED = 2;
+  const readableStreamBits = v8.createPrivateSymbol(
+      'bit field for [[started]], [[closeRequested]], [[pulling]], [[pullAgain]], [[disturbed]]');
+  const STARTED = 0b1;
+  const CLOSE_REQUESTED = 0b10;
+  const PULLING = 0b100;
+  const PULL_AGAIN = 0b1000;
+  const DISTURBED = 0b10000;
+  const undefined = global.undefined;
+  const Infinity = global.Infinity;
+  const defineProperty = global.Object.defineProperty;
+  const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty);
+  const callFunction = v8.uncurryThis(global.Function.prototype.call);
+  const TypeError = global.TypeError;
+  const RangeError = global.RangeError;
+  const Number = global.Number;
+  const Number_isNaN = Number.isNaN;
+  const Number_isFinite = Number.isFinite;
+  const Promise = global.Promise;
+  const thenPromise = v8.uncurryThis(Promise.prototype.then);
+  const Promise_resolve = v8.simpleBind(Promise.resolve, Promise);
+  const Promise_reject = v8.simpleBind(Promise.reject, Promise);
+  const errIllegalInvocation = 'Illegal invocation';
+  const errIllegalConstructor = 'Illegal constructor';
+  const errCancelLockedStream =
+      'Cannot cancel a readable stream that is locked to a reader';
+  const errEnqueueInCloseRequestedStream =
+      'Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed';
+  const errCancelReleasedReader =
+      'This readable stream reader has been released and cannot be used to cancel its previous owner stream';
+  const errReadReleasedReader =
+      'This readable stream reader has been released and cannot be used to read from its previous owner stream';
+  const errCloseCloseRequestedStream =
+      'Cannot close a readable stream that has already been requested to be closed';
+  const errCloseErroredStream = 'Cannot close an errored readable stream';
+  const errErrorClosedStream = 'Cannot error a close readable stream';
+  const errErrorErroredStream =
+      'Cannot error a readable stream that is already errored';
+  const errReaderConstructorBadArgument =
+      'ReadableStreamReader constructor argument is not a readable stream';
+  const errReaderConstructorStreamAlreadyLocked =
+      'ReadableStreamReader constructor can only accept readable streams that are not yet locked to a reader';
+  const errReleaseReaderWithPendingRead =
+      'Cannot release a readable stream reader when it still has outstanding read() calls that have not yet settled';
+  const errReleasedReaderClosedPromise =
+      'This readable stream reader has been released and cannot be used to monitor the stream\'s state';
+  const errInvalidSize =
+      'The return value of a queuing strategy\'s size function must be a finite, non-NaN, non-negative number';
+  const errSizeNotAFunction =
+      'A queuing strategy\'s size property must be a function';
+  const errInvalidHWM =
+      'A queueing strategy\'s highWaterMark property must be a nonnegative, non-NaN number';
+  const errTmplMustBeFunctionOrUndefined = name =>
+      `${name} must be a function or undefined`;
+  class ReadableStream {
+    constructor() {
+      const underlyingSource = arguments[0] === undefined ? {} : arguments[0];
+      const strategy = arguments[1] === undefined ? {} : arguments[1];
+      const size = strategy.size;
+      let highWaterMark = strategy.highWaterMark;
+      if (highWaterMark === undefined) {
+        highWaterMark = 1;
+      }
+      const normalizedStrategy =
+          ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
+      this[readableStreamUnderlyingSource] = underlyingSource;
+      this[readableStreamQueue] = new v8.InternalPackedArray();
+      this[readableStreamQueueSize] = 0;
+      this[readableStreamState] = STATE_READABLE;
+      this[readableStreamBits] = 0b0;
+      this[readableStreamReader] = undefined;
+      this[readableStreamStoredError] = undefined;
+      this[readableStreamStrategySize] = normalizedStrategy.size;
+      this[readableStreamStrategyHWM] = normalizedStrategy.highWaterMark;
+      const controller = new ReadableStreamController(this);
+      this[readableStreamController] = controller;
+      const startResult = CallOrNoop(
+          underlyingSource, 'start', controller, 'underlyingSource.start');
+      thenPromise(Promise_resolve(startResult),
+          () => {
+            this[readableStreamBits] |= STARTED;
+            RequestReadableStreamPull(this);
+          },
+          r => {
+            if (this[readableStreamState] === STATE_READABLE) {
+              return ErrorReadableStream(this, r);
+            }
+          });
+    }
+    get locked() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return IsReadableStreamLocked(this);
+    }
+    cancel(reason) {
+      if (IsReadableStream(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (IsReadableStreamLocked(this) === true) {
+        return Promise_reject(new TypeError(errCancelLockedStream));
+      }
+      return CancelReadableStream(this, reason);
+    }
+    getReader() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return AcquireReadableStreamReader(this);
+    }
+    tee() {
+      if (IsReadableStream(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return TeeReadableStream(this);
+    }
+  }
+  class ReadableStreamController {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      if (stream[readableStreamController] !== undefined) {
+        throw new TypeError(errIllegalConstructor);
+      }
+      this[readableStreamControllerControlledReadableStream] = stream;
+    }
+    get desiredSize() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      return GetReadableStreamDesiredSize(
+          this[readableStreamControllerControlledReadableStream]);
+    }
+    close() {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errCloseCloseRequestedStream);
+      }
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw new TypeError(errCloseErroredStream);
+      }
+      return CloseReadableStream(stream);
+    }
+    enqueue(chunk) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      if (stream[readableStreamState] === STATE_ERRORED) {
+        throw stream[readableStreamStoredError];
+      }
+      if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+        throw new TypeError(errEnqueueInCloseRequestedStream);
+      }
+      return EnqueueInReadableStream(stream, chunk);
+    }
+    error(e) {
+      if (IsReadableStreamController(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamControllerControlledReadableStream];
+      const state = stream[readableStreamState];
+      if (state !== STATE_READABLE) {
+        if (state === STATE_ERRORED) {
+          throw new TypeError(errErrorErroredStream);
+        }
+        if (state === STATE_CLOSED) {
+          throw new TypeError(errErrorClosedStream);
+        }
+      }
+      return ErrorReadableStream(stream, e);
+    }
+  }
+  class ReadableStreamReader {
+    constructor(stream) {
+      if (IsReadableStream(stream) === false) {
+        throw new TypeError(errReaderConstructorBadArgument);
+      }
+      if (IsReadableStreamLocked(stream) === true) {
+        throw new TypeError(errReaderConstructorStreamAlreadyLocked);
+      }
+      this[readableStreamReaderOwnerReadableStream] = stream;
+      stream[readableStreamReader] = this;
+      this[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+      switch (stream[readableStreamState]) {
+        case STATE_READABLE:
+          this[readableStreamReaderClosedPromise] = v8.createPromise();
+          break;
+        case STATE_CLOSED:
+          this[readableStreamReaderClosedPromise] = Promise_resolve(undefined);
+          break;
+        case STATE_ERRORED:
+          this[readableStreamReaderClosedPromise] =
+              Promise_reject(stream[readableStreamStoredError]);
+          break;
+      }
+    }
+    get closed() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      return this[readableStreamReaderClosedPromise];
+    }
+    cancel(reason) {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return Promise_reject(new TypeError(errCancelReleasedReader));
+      }
+      return CancelReadableStream(stream, reason);
+    }
+    read() {
+      if (IsReadableStreamReader(this) === false) {
+        return Promise_reject(new TypeError(errIllegalInvocation));
+      }
+      if (this[readableStreamReaderOwnerReadableStream] === undefined) {
+        return Promise_reject(new TypeError(errReadReleasedReader));
+      }
+      return ReadFromReadableStreamReader(this);
+    }
+    releaseLock() {
+      if (IsReadableStreamReader(this) === false) {
+        throw new TypeError(errIllegalInvocation);
+      }
+      const stream = this[readableStreamReaderOwnerReadableStream];
+      if (stream === undefined) {
+        return undefined;
+      }
+      if (this[readableStreamReaderReadRequests].length > 0) {
+        throw new TypeError(errReleaseReaderWithPendingRead);
+      }
+      if (stream[readableStreamState] === STATE_READABLE) {
+        v8.rejectPromise(this[readableStreamReaderClosedPromise],
+            new TypeError(errReleasedReaderClosedPromise));
+      } else {
+        this[readableStreamReaderClosedPromise] = Promise_reject(new TypeError(
+            errReleasedReaderClosedPromise));
+      }
+      this[readableStreamReaderOwnerReadableStream][readableStreamReader] =
+          undefined;
+      this[readableStreamReaderOwnerReadableStream] = undefined;
+    }
+  }
+  function AcquireReadableStreamReader(stream) {
+    return new ReadableStreamReader(stream);
+  }
+  function CancelReadableStream(stream, reason) {
+    stream[readableStreamBits] |= DISTURBED;
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED) {
+      return Promise_resolve(undefined);
+    }
+    if (state === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    FinishClosingReadableStream(stream);
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const sourceCancelPromise = PromiseCallOrNoop(
+        underlyingSource, 'cancel', reason, 'underlyingSource.cancel');
+    return thenPromise(sourceCancelPromise, () => undefined);
+  }
+  function CloseReadableStream(stream) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    stream[readableStreamBits] |= CLOSE_REQUESTED;
+    if (stream[readableStreamQueue].length === 0) {
+      return FinishClosingReadableStream(stream);
+    }
+  }
+  function EnqueueInReadableStream(stream, chunk) {
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return undefined;
+    }
+    if (IsReadableStreamLocked(stream) === true &&
+        stream[readableStreamReader][readableStreamReaderReadRequests].length >
+            0) {
+      const readRequest =
+          stream[readableStreamReader][readableStreamReaderReadRequests]
+              .shift();
+      v8.resolvePromise(readRequest, CreateIterResultObject(chunk, false));
+    } else {
+      let chunkSize = 1;
+      const strategySize = stream[readableStreamStrategySize];
+      if (strategySize !== undefined) {
+        try {
+          chunkSize = strategySize(chunk);
+        } catch (chunkSizeE) {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            ErrorReadableStream(stream, chunkSizeE);
+          }
+          throw chunkSizeE;
+        }
+      }
+      try {
+        EnqueueValueWithSize(stream, chunk, chunkSize);
+      } catch (enqueueE) {
+        if (stream[readableStreamState] === STATE_READABLE) {
+          ErrorReadableStream(stream, enqueueE);
+        }
+        throw enqueueE;
+      }
+    }
+    RequestReadableStreamPull(stream);
+  }
+  function ErrorReadableStream(stream, e) {
+    stream[readableStreamQueue] = new v8.InternalPackedArray();
+    stream[readableStreamStoredError] = e;
+    stream[readableStreamState] = STATE_ERRORED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.rejectPromise(readRequests[i], e);
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.rejectPromise(reader[readableStreamReaderClosedPromise], e);
+  }
+  function FinishClosingReadableStream(stream) {
+    stream[readableStreamState] = STATE_CLOSED;
+    const reader = stream[readableStreamReader];
+    if (reader === undefined) {
+      return undefined;
+    }
+    const readRequests = reader[readableStreamReaderReadRequests];
+    for (let i = 0; i < readRequests.length; ++i) {
+      v8.resolvePromise(
+          readRequests[i], CreateIterResultObject(undefined, true));
+    }
+    reader[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
+    v8.resolvePromise(reader[readableStreamReaderClosedPromise], undefined);
+  }
+  function GetReadableStreamDesiredSize(stream) {
+    const queueSize = GetTotalQueueSize(stream);
+    return stream[readableStreamStrategyHWM] - queueSize;
+  }
+  function IsReadableStream(x) {
+    return hasOwnProperty(x, readableStreamUnderlyingSource);
+  }
+  function IsReadableStreamDisturbed(stream) {
+    return stream[readableStreamBits] & DISTURBED;
+  }
+  function IsReadableStreamLocked(stream) {
+    return stream[readableStreamReader] !== undefined;
+  }
+  function IsReadableStreamController(x) {
+    return hasOwnProperty(x, readableStreamControllerControlledReadableStream);
+  }
+  function IsReadableStreamReader(x) {
+    return hasOwnProperty(x, readableStreamReaderOwnerReadableStream);
+  }
+  function ReadFromReadableStreamReader(reader) {
+    const stream = reader[readableStreamReaderOwnerReadableStream];
+    stream[readableStreamBits] |= DISTURBED;
+    if (stream[readableStreamState] === STATE_CLOSED) {
+      return Promise_resolve(CreateIterResultObject(undefined, true));
+    }
+    if (stream[readableStreamState] === STATE_ERRORED) {
+      return Promise_reject(stream[readableStreamStoredError]);
+    }
+    const queue = stream[readableStreamQueue];
+    if (queue.length > 0) {
+      const chunk = DequeueValue(stream);
+      if (stream[readableStreamBits] & CLOSE_REQUESTED && queue.length === 0) {
+        FinishClosingReadableStream(stream);
+      } else {
+        RequestReadableStreamPull(stream);
+      }
+      return Promise_resolve(CreateIterResultObject(chunk, false));
+    } else {
+      const readRequest = v8.createPromise();
+      reader[readableStreamReaderReadRequests].push(readRequest);
+      RequestReadableStreamPull(stream);
+      return readRequest;
+    }
+  }
+  function RequestReadableStreamPull(stream) {
+    const shouldPull = ShouldReadableStreamPull(stream);
+    if (shouldPull === false) {
+      return undefined;
+    }
+    if (stream[readableStreamBits] & PULLING) {
+      stream[readableStreamBits] |= PULL_AGAIN;
+      return undefined;
+    }
+    stream[readableStreamBits] |= PULLING;
+    const underlyingSource = stream[readableStreamUnderlyingSource];
+    const controller = stream[readableStreamController];
+    const pullPromise = PromiseCallOrNoop(
+        underlyingSource, 'pull', controller, 'underlyingSource.pull');
+    thenPromise(pullPromise,
+        () => {
+          stream[readableStreamBits] &= ~PULLING;
+          if (stream[readableStreamBits] & PULL_AGAIN) {
+            stream[readableStreamBits] &= ~PULL_AGAIN;
+            return RequestReadableStreamPull(stream);
+          }
+        },
+        e => {
+          if (stream[readableStreamState] === STATE_READABLE) {
+            return ErrorReadableStream(stream, e);
+          }
+        });
+  }
+  function ShouldReadableStreamPull(stream) {
+    const state = stream[readableStreamState];
+    if (state === STATE_CLOSED || state === STATE_ERRORED) {
+      return false;
+    }
+    if (stream[readableStreamBits] & CLOSE_REQUESTED) {
+      return false;
+    }
+    if (!(stream[readableStreamBits] & STARTED)) {
+      return false;
+    }
+    if (IsReadableStreamLocked(stream) === true) {
+      const reader = stream[readableStreamReader];
+      const readRequests = reader[readableStreamReaderReadRequests];
+      if (readRequests.length > 0) {
+        return true;
+      }
+    }
+    const desiredSize = GetReadableStreamDesiredSize(stream);
+    if (desiredSize > 0) {
+      return true;
+    }
+    return false;
+  }
+  function TeeReadableStream(stream) {
+    const reader = AcquireReadableStreamReader(stream);
+    let closedOrErrored = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let promise = v8.createPromise();
+    const branch1 = new ReadableStream({pull, cancel: cancel1});
+    const branch2 = new ReadableStream({pull, cancel: cancel2});
+    thenPromise(
+        reader[readableStreamReaderClosedPromise], undefined, function(r) {
+          if (closedOrErrored === true) {
+            return;
+          }
+          ErrorReadableStream(branch1, r);
+          ErrorReadableStream(branch2, r);
+          closedOrErrored = true;
+        });
+    return [branch1, branch2];
+    function pull() {
+      return thenPromise(
+          ReadFromReadableStreamReader(reader), function(result) {
+            const value = result.value;
+            const done = result.done;
+            if (done === true && closedOrErrored === false) {
+              CloseReadableStream(branch1);
+              CloseReadableStream(branch2);
+              closedOrErrored = true;
+            }
+            if (closedOrErrored === true) {
+              return;
+            }
+            if (canceled1 === false) {
+              EnqueueInReadableStream(branch1, value);
+            }
+            if (canceled2 === false) {
+              EnqueueInReadableStream(branch2, value);
+            }
+          });
+    }
+    function cancel1(reason) {
+      canceled1 = true;
+      reason1 = reason;
+      if (canceled2 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+    function cancel2(reason) {
+      canceled2 = true;
+      reason2 = reason;
+      if (canceled1 === true) {
+        const compositeReason = [reason1, reason2];
+        const cancelResult = CancelReadableStream(stream, compositeReason);
+        v8.resolvePromise(promise, cancelResult);
+      }
+      return promise;
+    }
+  }
+  function DequeueValue(stream) {
+    const result = stream[readableStreamQueue].shift();
+    stream[readableStreamQueueSize] -= result.size;
+    return result.value;
+  }
+  function EnqueueValueWithSize(stream, value, size) {
+    size = Number(size);
+    if (Number_isNaN(size) || size === +Infinity || size < 0) {
+      throw new RangeError(errInvalidSize);
+    }
+    stream[readableStreamQueueSize] += size;
+    stream[readableStreamQueue].push({value, size});
+  }
+  function GetTotalQueueSize(stream) { return stream[readableStreamQueueSize]; }
+  function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) {
+    if (size !== undefined && typeof size !== 'function') {
+      throw new TypeError(errSizeNotAFunction);
+    }
+    highWaterMark = Number(highWaterMark);
+    if (Number_isNaN(highWaterMark)) {
+      throw new TypeError(errInvalidHWM);
+    }
+    if (highWaterMark < 0) {
+      throw new RangeError(errInvalidHWM);
+    }
+    return {size, highWaterMark};
+  }
+  function CallOrNoop(O, P, arg, nameForError) {
+    const method = O[P];
+    if (method === undefined) {
+      return undefined;
+    }
+    if (typeof method !== 'function') {
+      throw new TypeError(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    return callFunction(method, O, arg);
+  }
+  function PromiseCallOrNoop(O, P, arg, nameForError) {
+    let method;
+    try {
+      method = O[P];
+    } catch (methodE) {
+      return Promise_reject(methodE);
+    }
+    if (method === undefined) {
+      return Promise_resolve(undefined);
+    }
+    if (typeof method !== 'function') {
+      return Promise_reject(errTmplMustBeFunctionOrUndefined(nameForError));
+    }
+    try {
+      return Promise_resolve(callFunction(method, O, arg));
+    } catch (e) {
+      return Promise_reject(e);
+    }
+  }
+  function CreateIterResultObject(value, done) { return {value, done}; }
+  defineProperty(global, 'ReadableStream', {
+    value: ReadableStream,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+  binding.AcquireReadableStreamReader = AcquireReadableStreamReader;
+  binding.IsReadableStream = IsReadableStream;
+  binding.IsReadableStreamDisturbed = IsReadableStreamDisturbed;
+  binding.IsReadableStreamLocked = IsReadableStreamLocked;
+  binding.IsReadableStreamReader = IsReadableStreamReader;
+  binding.ReadFromReadableStreamReader = ReadFromReadableStreamReader;
+});

DiscordCanary/resources/node_modules/discord_domtimer/index.js

@@ -0,0 +1 @@
+module.exports = require('./discord_domtimer.node');

DiscordCanary/resources/node_modules/discord_overlay/index.js

@@ -0,0 +1 @@
+module.exports = require('./discord_overlay.node');

DiscordCanary/resources/node_modules/discord_toaster/index.js

@@ -0,0 +1,32 @@
+var os = require('os');
+
+var stubVersion = {
+  supported: function() {
+    return false;
+  },
+  setAppID: function() {
+    return false;
+  },
+  show: function(junk) {
+    console.error('unsupported');
+  }
+};
+
+var correctType = (os.type() == 'Windows_NT');
+var correctPlatform = (os.platform() == 'win32');
+
+if (correctType && correctPlatform) {
+  try {
+    var toasterLib = require('./discord_toaster.node');
+  } catch (e) {
+    try {
+      var toasterLib = require('./build/Release/discord_toaster');
+    } catch (e) {
+      toasterLib = stubVersion;
+    }
+  }
+  module.exports = toasterLib;
+}
+else {
+  module.exports = stubVersion;
+}

run-discord

@@ -0,0 +1,3 @@
+#!/bin/zsh -f
+
+~/bin/DiscordCanary/DiscordCanary