+\f\14debug֖\ 2
+"use strict";
+var kDefaultBacktraceLength=10;
+var Debug={};
+var sourceLineBeginningSkip=/^(?:\s*(?:\/\*.*?\*\/)*)*/;
+Debug.DebugEvent={Break:1,
+Exception:2,
+NewFunction:3,
+BeforeCompile:4,
+AfterCompile:5,
+CompileError:6,
+PromiseEvent:7,
+AsyncTaskEvent:8,
+BreakForCommand:9};
+Debug.ExceptionBreak={Caught:0,
+Uncaught:1};
+Debug.StepAction={StepOut:0,
+StepNext:1,
+StepIn:2,
+StepMin:3,
+StepInMin:4,
+StepFrame:5};
+Debug.ScriptType={Native:0,
+Extension:1,
+Normal:2};
+Debug.ScriptCompilationType={Host:0,
+Eval:1,
+JSON:2};
+Debug.ScriptBreakPointType={ScriptId:0,
+ScriptName:1,
+ScriptRegExp:2};
+Debug.BreakPositionAlignment={
+Statement:0,
+BreakPosition:1
+};
+function ScriptTypeFlag(a){
+return(1<<a);
+}
+var next_response_seq=0;
+var next_break_point_number=1;
+var break_points=[];
+var script_break_points=[];
+var debugger_flags={
+breakPointsActive:{
+value:true,
+getValue:function(){return this.value;},
+setValue:function(a){
+this.value=!!a;
+%SetDisableBreak(!this.value);
+}
+},
+breakOnCaughtException:{
+getValue:function(){return Debug.isBreakOnException();},
+setValue:function(a){
+if(a){
+Debug.setBreakOnException();
+}else{
+Debug.clearBreakOnException();
+}
+}
+},
+breakOnUncaughtException:{
+getValue:function(){return Debug.isBreakOnUncaughtException();},
+setValue:function(a){
+if(a){
+Debug.setBreakOnUncaughtException();
+}else{
+Debug.clearBreakOnUncaughtException();
+}
+}
+},
+};
+function MakeBreakPoint(a,b){
+var c=new BreakPoint(a,b);
+break_points.push(c);
+return c;
+}
+function BreakPoint(a,b){
+this.source_position_=a;
+if(b){
+this.script_break_point_=b;
+}else{
+this.number_=next_break_point_number++;
+}
+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(a){
+this.condition_=a;
+};
+BreakPoint.prototype.setIgnoreCount=function(a){
+this.ignoreCount_=a;
+};
+BreakPoint.prototype.isTriggered=function(a){
+if(!this.active())return false;
+if(this.condition()){
+try{
+var b=a.frame(0).evaluate(this.condition());
+if(!(b instanceof ValueMirror)||!%ToBoolean(b.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(a,b){
+return b.isTriggered(MakeExecutionState(a));
+}
+function ScriptBreakPoint(type,script_id_or_name,opt_line,opt_column,
+opt_groupId,opt_position_alignment){
+this.type_=type;
+if(type==Debug.ScriptBreakPointType.ScriptId){
+this.script_id_=script_id_or_name;
+}else if(type==Debug.ScriptBreakPointType.ScriptName){
+this.script_name_=script_id_or_name;
+}else if(type==Debug.ScriptBreakPointType.ScriptRegExp){
+this.script_regexp_object_=new RegExp(script_id_or_name);
+}else{
+throw new Error("Unexpected breakpoint type "+type);
+}
+this.line_=opt_line||0;
+this.column_=opt_column;
+this.groupId_=opt_groupId;
+this.position_alignment_=(opt_position_alignment===(void 0))
+?Debug.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(a){
+var b=new ScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,
+a.id,this.line_,this.column_,this.groupId_,
+this.position_alignment_);
+b.number_=next_break_point_number++;
+script_break_points.push(b);
+b.hit_count_=this.hit_count_;
+b.active_=this.active_;
+b.condition_=this.condition_;
+b.ignoreCount_=this.ignoreCount_;
+return b;
+};
+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 a=[];
+for(var b=0;b<this.break_points_.length;b++){
+a.push(this.break_points_[b].actual_location);
+}
+return a;
+};
+ScriptBreakPoint.prototype.update_positions=function(a,b){
+this.line_=a;
+this.column_=b;
+};
+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(a){
+this.condition_=a;
+};
+ScriptBreakPoint.prototype.setIgnoreCount=function(a){
+this.ignoreCount_=a;
+for(var b=0;b<this.break_points_.length;b++){
+this.break_points_[b].setIgnoreCount(a);
+}
+};
+ScriptBreakPoint.prototype.matchesScript=function(a){
+if(this.type_==Debug.ScriptBreakPointType.ScriptId){
+return this.script_id_==a.id;
+}else{
+if(!(a.line_offset<=this.line_&&
+this.line_<a.line_offset+a.lineCount())){
+return false;
+}
+if(this.type_==Debug.ScriptBreakPointType.ScriptName){
+return this.script_name_==a.nameOrSourceURL();
+}else if(this.type_==Debug.ScriptBreakPointType.ScriptRegExp){
+return this.script_regexp_object_.test(a.nameOrSourceURL());
+}else{
+throw new Error("Unexpected breakpoint type "+this.type_);
+}
+}
+};
+ScriptBreakPoint.prototype.set=function(a){
+var b=this.column();
+var c=this.line();
+if((b===(void 0))){
+var d=a.sourceLine(this.line());
+if(!a.sourceColumnStart_){
+a.sourceColumnStart_=new Array(a.lineCount());
+}
+if((a.sourceColumnStart_[c]===(void 0))){
+a.sourceColumnStart_[c]=
+d.match(sourceLineBeginningSkip)[0].length;
+}
+b=a.sourceColumnStart_[c];
+}
+var e=Debug.findScriptSourcePosition(a,this.line(),b);
+if((e===null))return;
+var f=MakeBreakPoint(e,this);
+f.setIgnoreCount(this.ignoreCount());
+var g=%SetScriptBreakPoint(a,e,
+this.position_alignment_,
+f);
+if((g===(void 0))){
+g=e;
+}
+var h=a.locationFromPosition(g,true);
+f.actual_location={line:h.line,
+column:h.column,
+script_id:a.id};
+this.break_points_.push(f);
+return f;
+};
+ScriptBreakPoint.prototype.clear=function(){
+var a=[];
+for(var b=0;b<break_points.length;b++){
+if(break_points[b].script_break_point()&&
+break_points[b].script_break_point()===this){
+%ClearBreakPoint(break_points[b]);
+}else{
+a.push(break_points[b]);
+}
+}
+break_points=a;
+this.break_points_=[];
+};
+function UpdateScriptBreakPoints(a){
+for(var b=0;b<script_break_points.length;b++){
+var c=script_break_points[b];
+if((c.type()==Debug.ScriptBreakPointType.ScriptName||
+c.type()==Debug.ScriptBreakPointType.ScriptRegExp)&&
+c.matchesScript(a)){
+c.set(a);
+}
+}
+}
+function GetScriptBreakPoints(a){
+var b=[];
+for(var c=0;c<script_break_points.length;c++){
+if(script_break_points[c].matchesScript(a)){
+b.push(script_break_points[c]);
+}
+}
+return b;
+}
+Debug.setListener=function(a,b){
+if(!(%_IsFunction(a))&&!(a===(void 0))&&!(a===null)){
+throw new Error('Parameters have wrong types.');
+}
+%SetDebugEventListener(a,b);
+};
+Debug.breakLocations=function(a,b){
+if(!(%_IsFunction(a)))throw new Error('Parameters have wrong types.');
+var c=(b===(void 0))
+?Debug.BreakPositionAlignment.Statement:b;
+return %GetBreakLocations(a,c);
+};
+Debug.findScript=function(a){
+if((%_IsFunction(a))){
+return %FunctionGetScript(a);
+}else if((%_IsRegExp(a))){
+var b=Debug.scripts();
+var c=null;
+var d=0;
+for(var e in b){
+var g=b[e];
+if(a.test(g.name)){
+c=g;
+d++;
+}
+}
+if(d==1){
+return c;
+}else{
+return undefined;
+}
+}else{
+return %GetScript(a);
+}
+};
+Debug.scriptSource=function(a){
+return this.findScript(a).source;
+};
+Debug.source=function(a){
+if(!(%_IsFunction(a)))throw new Error('Parameters have wrong types.');
+return %FunctionGetSourceCode(a);
+};
+Debug.sourcePosition=function(a){
+if(!(%_IsFunction(a)))throw new Error('Parameters have wrong types.');
+return %FunctionGetScriptSourcePosition(a);
+};
+Debug.findFunctionSourceLocation=function(a,b,c){
+var d=%FunctionGetScript(a);
+var e=%FunctionGetScriptSourcePosition(a);
+return d.locationFromLine(b,c,e);
+};
+Debug.findScriptSourcePosition=function(a,b,c){
+var d=a.locationFromLine(b,c);
+return d?d.position:null;
+};
+Debug.findBreakPoint=function(a,b){
+var c;
+for(var d=0;d<break_points.length;d++){
+if(break_points[d].number()==a){
+c=break_points[d];
+if(b){
+break_points.splice(d,1);
+}
+break;
+}
+}
+if(c){
+return c;
+}else{
+return this.findScriptBreakPoint(a,b);
+}
+};
+Debug.findBreakPointActualLocations=function(a){
+for(var b=0;b<script_break_points.length;b++){
+if(script_break_points[b].number()==a){
+return script_break_points[b].actual_locations();
+}
+}
+for(var b=0;b<break_points.length;b++){
+if(break_points[b].number()==a){
+return[break_points[b].actual_location];
+}
+}
+return[];
+};
+Debug.setBreakPoint=function(a,b,c,d){
+if(!(%_IsFunction(a)))throw new Error('Parameters have wrong types.');
+if(%FunctionIsAPIFunction(a)){
+throw new Error('Cannot set break point in native code.');
+}
+var e=
+this.findFunctionSourceLocation(a,b,c).position;
+var g=e-this.sourcePosition(a);
+var h=%FunctionGetScript(a);
+if(h.type==Debug.ScriptType.Native){
+throw new Error('Cannot set break point in native code.');
+}
+if(h&&h.id){
+g+=%FunctionGetScriptSourcePosition(a);
+var i=h.locationFromPosition(g,false);
+return this.setScriptBreakPointById(h.id,
+i.line,i.column,
+d);
+}else{
+var j=MakeBreakPoint(g);
+var k=
+%SetFunctionBreakPoint(a,g,j);
+k+=this.sourcePosition(a);
+var l=h.locationFromPosition(k,true);
+j.actual_location={line:l.line,
+column:l.column,
+script_id:h.id};
+j.setCondition(d);
+return j.number();
+}
+};
+Debug.setBreakPointByScriptIdAndPosition=function(script_id,position,
+condition,enabled,
+opt_position_alignment)
+{
+var a=MakeBreakPoint(position);
+a.setCondition(condition);
+if(!enabled){
+a.disable();
+}
+var b=this.scripts();
+var c=(opt_position_alignment===(void 0))
+?Debug.BreakPositionAlignment.Statement:opt_position_alignment;
+for(var d=0;d<b.length;d++){
+if(script_id==b[d].id){
+a.actual_position=%SetScriptBreakPoint(b[d],position,
+c,a);
+break;
+}
+}
+return a;
+};
+Debug.enableBreakPoint=function(a){
+var b=this.findBreakPoint(a,false);
+if(b){
+b.enable();
+}
+};
+Debug.disableBreakPoint=function(a){
+var b=this.findBreakPoint(a,false);
+if(b){
+b.disable();
+}
+};
+Debug.changeBreakPointCondition=function(a,b){
+var c=this.findBreakPoint(a,false);
+c.setCondition(b);
+};
+Debug.changeBreakPointIgnoreCount=function(a,b){
+if(b<0){
+throw new Error('Invalid argument');
+}
+var c=this.findBreakPoint(a,false);
+c.setIgnoreCount(b);
+};
+Debug.clearBreakPoint=function(a){
+var b=this.findBreakPoint(a,true);
+if(b){
+return %ClearBreakPoint(b);
+}else{
+b=this.findScriptBreakPoint(a,true);
+if(!b){
+throw new Error('Invalid breakpoint');
+}
+}
+};
+Debug.clearAllBreakPoints=function(){
+for(var a=0;a<break_points.length;a++){
+var b=break_points[a];
+%ClearBreakPoint(b);
+}
+break_points=[];
+};
+Debug.disableAllBreakPoints=function(){
+for(var a=1;a<next_break_point_number;a++){
+Debug.disableBreakPoint(a);
+}
+%ChangeBreakOnException(Debug.ExceptionBreak.Caught,false);
+%ChangeBreakOnException(Debug.ExceptionBreak.Uncaught,false);
+};
+Debug.findScriptBreakPoint=function(a,b){
+var c;
+for(var d=0;d<script_break_points.length;d++){
+if(script_break_points[d].number()==a){
+c=script_break_points[d];
+if(b){
+c.clear();
+script_break_points.splice(d,1);
+}
+break;
+}
+}
+return c;
+};
+Debug.setScriptBreakPoint=function(type,script_id_or_name,
+opt_line,opt_column,opt_condition,
+opt_groupId,opt_position_alignment){
+var a=
+new ScriptBreakPoint(type,script_id_or_name,opt_line,opt_column,
+opt_groupId,opt_position_alignment);
+a.number_=next_break_point_number++;
+a.setCondition(opt_condition);
+script_break_points.push(a);
+var b=this.scripts();
+for(var c=0;c<b.length;c++){
+if(a.matchesScript(b[c])){
+a.set(b[c]);
+}
+}
+return a.number();
+};
+Debug.setScriptBreakPointById=function(script_id,
+opt_line,opt_column,
+opt_condition,opt_groupId,
+opt_position_alignment){
+return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,
+script_id,opt_line,opt_column,
+opt_condition,opt_groupId,
+opt_position_alignment);
+};
+Debug.setScriptBreakPointByName=function(script_name,
+opt_line,opt_column,
+opt_condition,opt_groupId){
+return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptName,
+script_name,opt_line,opt_column,
+opt_condition,opt_groupId);
+};
+Debug.setScriptBreakPointByRegExp=function(script_regexp,
+opt_line,opt_column,
+opt_condition,opt_groupId){
+return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptRegExp,
+script_regexp,opt_line,opt_column,
+opt_condition,opt_groupId);
+};
+Debug.enableScriptBreakPoint=function(a){
+var b=this.findScriptBreakPoint(a,false);
+b.enable();
+};
+Debug.disableScriptBreakPoint=function(a){
+var b=this.findScriptBreakPoint(a,false);
+b.disable();
+};
+Debug.changeScriptBreakPointCondition=function(
+break_point_number,condition){
+var a=this.findScriptBreakPoint(break_point_number,false);
+a.setCondition(condition);
+};
+Debug.changeScriptBreakPointIgnoreCount=function(
+break_point_number,ignoreCount){
+if(ignoreCount<0){
+throw new Error('Invalid argument');
+}
+var a=this.findScriptBreakPoint(break_point_number,false);
+a.setIgnoreCount(ignoreCount);
+};
+Debug.scriptBreakPoints=function(){
+return script_break_points;
+};
+Debug.clearStepping=function(){
+%ClearStepping();
+};
+Debug.setBreakOnException=function(){
+return %ChangeBreakOnException(Debug.ExceptionBreak.Caught,true);
+};
+Debug.clearBreakOnException=function(){
+return %ChangeBreakOnException(Debug.ExceptionBreak.Caught,false);
+};
+Debug.isBreakOnException=function(){
+return!!%IsBreakOnException(Debug.ExceptionBreak.Caught);
+};
+Debug.setBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(Debug.ExceptionBreak.Uncaught,true);
+};
+Debug.clearBreakOnUncaughtException=function(){
+return %ChangeBreakOnException(Debug.ExceptionBreak.Uncaught,false);
+};
+Debug.isBreakOnUncaughtException=function(){
+return!!%IsBreakOnException(Debug.ExceptionBreak.Uncaught);
+};
+Debug.showBreakPoints=function(a,b,c){
+if(!(%_IsFunction(a)))throw new Error('Parameters have wrong types.');
+var d=b?this.scriptSource(a):this.source(a);
+var e=b?this.sourcePosition(a):0;
+var g=this.breakLocations(a,c);
+if(!g)return d;
+g.sort(function(h,i){return h-i;});
+var j="";
+var k=0;
+var l;
+for(var m=0;m<g.length;m++){
+l=g[m]-e;
+j+=d.slice(k,l);
+j+="[B"+m+"]";
+k=l;
+}
+l=d.length;
+j+=d.substring(k,l);
+return j;
+};
+Debug.scripts=function(){
+return %DebugGetLoadedScripts();
+};
+Debug.debuggerFlags=function(){
+return debugger_flags;
+};
+Debug.MakeMirror=MakeMirror;
+function MakeExecutionState(a){
+return new ExecutionState(a);
+}
+function ExecutionState(a){
+this.break_id=a;
+this.selected_frame=0;
+}
+ExecutionState.prototype.prepareStep=function(opt_action,opt_count,
+opt_callframe){
+var a=Debug.StepAction.StepIn;
+if(!(opt_action===(void 0)))a=%ToNumber(opt_action);
+var b=opt_count?%ToNumber(opt_count):1;
+var c=0;
+if(!(opt_callframe===(void 0))){
+c=opt_callframe.details_.frameId();
+}
+return %PrepareStep(this.break_id,a,b,c);
+};
+ExecutionState.prototype.evaluateGlobal=function(source,disable_break,
+opt_additional_context){
+return MakeMirror(%DebugEvaluateGlobal(this.break_id,source,
+Boolean(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(a){
+if(a==null)a=this.selected_frame;
+if(a<0||a>=this.frameCount()){
+throw new Error('Illegal frame index.');
+}
+return new FrameMirror(this.break_id,a);
+};
+ExecutionState.prototype.setSelectedFrame=function(a){
+var b=%ToNumber(a);
+if(b<0||b>=this.frameCount())throw new Error('Illegal frame index.');
+this.selected_frame=b;
+};
+ExecutionState.prototype.selectedFrame=function(){
+return this.selected_frame;
+};
+ExecutionState.prototype.debugCommandProcessor=function(a){
+return new DebugCommandProcessor(this,a);
+};
+function MakeBreakEvent(a,b){
+return new BreakEvent(a,b);
+}
+function BreakEvent(a,b){
+this.frame_=new FrameMirror(a,0);
+this.break_points_hit_=b;
+}
+BreakEvent.prototype.eventType=function(){
+return Debug.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 a={seq:next_response_seq++,
+type:"event",
+event:"break",
+body:{invocationText:this.frame_.invocationText()}
+};
+var b=this.func().script();
+if(b){
+a.body.sourceLine=this.sourceLine(),
+a.body.sourceColumn=this.sourceColumn(),
+a.body.sourceLineText=this.sourceLineText(),
+a.body.script=MakeScriptObject_(b,false);
+}
+if(this.breakPointsHit()){
+a.body.breakpoints=[];
+for(var c=0;c<this.breakPointsHit().length;c++){
+var d=this.breakPointsHit()[c];
+var e=d.script_break_point();
+var g;
+if(e){
+g=e.number();
+}else{
+g=d.number();
+}
+a.body.breakpoints.push(g);
+}
+}
+return JSON.stringify(ObjectToProtocolObject_(a));
+};
+function MakeExceptionEvent(a,b,c,d){
+return new ExceptionEvent(a,b,c,d);
+}
+function ExceptionEvent(a,b,c,d){
+this.exec_state_=new ExecutionState(a);
+this.exception_=b;
+this.uncaught_=c;
+this.promise_=d;
+}
+ExceptionEvent.prototype.eventType=function(){
+return Debug.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 a=new ProtocolMessage();
+a.event="exception";
+a.body={uncaught:this.uncaught_,
+exception:MakeMirror(this.exception_)
+};
+if(this.exec_state_.frameCount()>0){
+a.body.sourceLine=this.sourceLine();
+a.body.sourceColumn=this.sourceColumn();
+a.body.sourceLineText=this.sourceLineText();
+var b=this.func().script();
+if(b){
+a.body.script=MakeScriptObject_(b,false);
+}
+}else{
+a.body.sourceLine=-1;
+}
+return a.toJSONProtocol();
+};
+function MakeCompileEvent(a,b){
+return new CompileEvent(a,b);
+}
+function CompileEvent(a,b){
+this.script_=MakeMirror(a);
+this.type_=b;
+}
+CompileEvent.prototype.eventType=function(){
+return this.type_;
+};
+CompileEvent.prototype.script=function(){
+return this.script_;
+};
+CompileEvent.prototype.toJSONProtocol=function(){
+var a=new ProtocolMessage();
+a.running=true;
+switch(this.type_){
+case Debug.DebugEvent.BeforeCompile:
+a.event="beforeCompile";
+break;
+case Debug.DebugEvent.AfterCompile:
+a.event="afterCompile";
+break;
+case Debug.DebugEvent.CompileError:
+a.event="compileError";
+break;
+}
+a.body={};
+a.body.script=this.script_;
+return a.toJSONProtocol();
+};
+function MakeScriptObject_(a,b){
+var c={id:a.id(),
+name:a.name(),
+lineOffset:a.lineOffset(),
+columnOffset:a.columnOffset(),
+lineCount:a.lineCount(),
+};
+if(!(a.data()===(void 0))){
+c.data=a.data();
+}
+if(b){
+c.source=a.source();
+}
+return c;
+}
+function MakePromiseEvent(a){
+return new PromiseEvent(a);
+}
+function PromiseEvent(a){
+this.promise_=a.promise;
+this.parentPromise_=a.parentPromise;
+this.status_=a.status;
+this.value_=a.value;
+}
+PromiseEvent.prototype.promise=function(){
+return MakeMirror(this.promise_);
+}
+PromiseEvent.prototype.parentPromise=function(){
+return MakeMirror(this.parentPromise_);
+}
+PromiseEvent.prototype.status=function(){
+return this.status_;
+}
+PromiseEvent.prototype.value=function(){
+return MakeMirror(this.value_);
+}
+function MakeAsyncTaskEvent(a){
+return new AsyncTaskEvent(a);
+}
+function AsyncTaskEvent(a){
+this.type_=a.type;
+this.name_=a.name;
+this.id_=a.id;
+}
+AsyncTaskEvent.prototype.type=function(){
+return this.type_;
+}
+AsyncTaskEvent.prototype.name=function(){
+return this.name_;
+}
+AsyncTaskEvent.prototype.id=function(){
+return this.id_;
+}
+function DebugCommandProcessor(a,b){
+this.exec_state_=a;
+this.running_=b||false;
+}
+DebugCommandProcessor.prototype.processDebugRequest=function(a){
+return this.processDebugJSONRequest(a);
+};
+function ProtocolMessage(a){
+this.seq=next_response_seq++;
+if(a){
+this.type='response';
+this.request_seq=a.seq;
+this.command=a.command;
+}else{
+this.type='event';
+}
+this.success=true;
+this.running=undefined;
+}
+ProtocolMessage.prototype.setOption=function(a,b){
+if(!this.options_){
+this.options_={};
+}
+this.options_[a]=b;
+};
+ProtocolMessage.prototype.failed=function(a,b){
+this.success=false;
+this.message=a;
+if((%_IsObject(b))){
+this.error_details=b;
+}
+};
+ProtocolMessage.prototype.toJSONProtocol=function(){
+var a={};
+a.seq=this.seq;
+if(this.request_seq){
+a.request_seq=this.request_seq;
+}
+a.type=this.type;
+if(this.event){
+a.event=this.event;
+}
+if(this.command){
+a.command=this.command;
+}
+if(this.success){
+a.success=this.success;
+}else{
+a.success=false;
+}
+if(this.body){
+var b;
+var c=MakeMirrorSerializer(true,this.options_);
+if(this.body instanceof Mirror){
+b=c.serializeValue(this.body);
+}else if(this.body instanceof Array){
+b=[];
+for(var d=0;d<this.body.length;d++){
+if(this.body[d]instanceof Mirror){
+b.push(c.serializeValue(this.body[d]));
+}else{
+b.push(ObjectToProtocolObject_(this.body[d],c));
+}
+}
+}else{
+b=ObjectToProtocolObject_(this.body,c);
+}
+a.body=b;
+a.refs=c.serializeReferencedObjects();
+}
+if(this.message){
+a.message=this.message;
+}
+if(this.error_details){
+a.error_details=this.error_details;
+}
+a.running=this.running;
+return JSON.stringify(a);
+};
+DebugCommandProcessor.prototype.createResponse=function(a){
+return new ProtocolMessage(a);
+};
+DebugCommandProcessor.prototype.processDebugJSONRequest=function(
+json_request){
+var a;
+var b;
+try{
+try{
+a=JSON.parse(json_request);
+b=this.createResponse(a);
+if(!a.type){
+throw new Error('Type not specified');
+}
+if(a.type!='request'){
+throw new Error("Illegal type '"+a.type+"' in request");
+}
+if(!a.command){
+throw new Error('Command not specified');
+}
+if(a.arguments){
+var c=a.arguments;
+if(c.inlineRefs||c.compactFormat){
+b.setOption('inlineRefs',true);
+}
+if(!(c.maxStringLength===(void 0))){
+b.setOption('maxStringLength',c.maxStringLength);
+}
+}
+var d=a.command.toLowerCase();
+var e=DebugCommandProcessor.prototype.dispatch_[d];
+if((%_IsFunction(e))){
+%_CallFunction(this,a,b,e);
+}else{
+throw new Error('Unknown command "'+a.command+'" in request');
+}
+}catch(e){
+if(!b){
+b=this.createResponse();
+}
+b.success=false;
+b.message=%ToString(e);
+}
+try{
+if(!(b.running===(void 0))){
+this.running_=b.running;
+}
+b.running=this.running_;
+return b.toJSONProtocol();
+}catch(e){
+return'{"seq":'+b.seq+','+
+'"request_seq":'+a.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(a,b){
+if(a.arguments){
+var c=1;
+var d=Debug.StepAction.StepIn;
+var e=a.arguments.stepaction;
+var g=a.arguments.stepcount;
+if(g){
+c=%ToNumber(g);
+if(c<0){
+throw new Error('Invalid stepcount argument "'+g+'".');
+}
+}
+if(e){
+if(e=='in'){
+d=Debug.StepAction.StepIn;
+}else if(e=='min'){
+d=Debug.StepAction.StepMin;
+}else if(e=='next'){
+d=Debug.StepAction.StepNext;
+}else if(e=='out'){
+d=Debug.StepAction.StepOut;
+}else{
+throw new Error('Invalid stepaction argument "'+e+'".');
+}
+}
+this.exec_state_.prepareStep(d,c);
+}
+b.running=true;
+};
+DebugCommandProcessor.prototype.breakRequest_=function(a,b){
+};
+DebugCommandProcessor.prototype.setBreakPointRequest_=
+function(a,b){
+if(!a.arguments){
+b.failed('Missing arguments');
+return;
+}
+var c=a.arguments.type;
+var d=a.arguments.target;
+var e=a.arguments.line;
+var g=a.arguments.column;
+var h=(a.arguments.enabled===(void 0))?
+true:a.arguments.enabled;
+var i=a.arguments.condition;
+var j=a.arguments.ignoreCount;
+var k=a.arguments.groupId;
+if(!c||(d===(void 0))){
+b.failed('Missing argument "type" or "target"');
+return;
+}
+var l;
+if(c=='function'){
+if(!(typeof(d)==='string')){
+b.failed('Argument "target" is not a string value');
+return;
+}
+var m;
+try{
+m=this.exec_state_.evaluateGlobal(d).value();
+}catch(e){
+b.failed('Error: "'+%ToString(e)+
+'" evaluating "'+d+'"');
+return;
+}
+if(!(%_IsFunction(m))){
+b.failed('"'+d+'" does not evaluate to a function');
+return;
+}
+l=Debug.setBreakPoint(m,e,g,i);
+}else if(c=='handle'){
+var n=parseInt(d,10);
+var o=LookupMirror(n);
+if(!o){
+return b.failed('Object #'+n+'# not found');
+}
+if(!o.isFunction()){
+return b.failed('Object #'+n+'# is not a function');
+}
+l=Debug.setBreakPoint(o.value(),
+e,g,i);
+}else if(c=='script'){
+l=
+Debug.setScriptBreakPointByName(d,e,g,i,
+k);
+}else if(c=='scriptId'){
+l=
+Debug.setScriptBreakPointById(d,e,g,i,k);
+}else if(c=='scriptRegExp'){
+l=
+Debug.setScriptBreakPointByRegExp(d,e,g,i,
+k);
+}else{
+b.failed('Illegal type "'+c+'"');
+return;
+}
+var p=Debug.findBreakPoint(l);
+if(j){
+Debug.changeBreakPointIgnoreCount(l,j);
+}
+if(!h){
+Debug.disableBreakPoint(l);
+}
+b.body={type:c,
+breakpoint:l};
+if(p instanceof ScriptBreakPoint){
+if(p.type()==Debug.ScriptBreakPointType.ScriptId){
+b.body.type='scriptId';
+b.body.script_id=p.script_id();
+}else if(p.type()==Debug.ScriptBreakPointType.ScriptName){
+b.body.type='scriptName';
+b.body.script_name=p.script_name();
+}else if(p.type()==Debug.ScriptBreakPointType.ScriptRegExp){
+b.body.type='scriptRegExp';
+b.body.script_regexp=p.script_regexp_object().source;
+}else{
+throw new Error("Internal error: Unexpected breakpoint type: "+
+p.type());
+}
+b.body.line=p.line();
+b.body.column=p.column();
+b.body.actual_locations=p.actual_locations();
+}else{
+b.body.type='function';
+b.body.actual_locations=[p.actual_location];
+}
+};
+DebugCommandProcessor.prototype.changeBreakPointRequest_=function(
+request,response){
+if(!request.arguments){
+response.failed('Missing arguments');
+return;
+}
+var a=%ToNumber(request.arguments.breakpoint);
+var b=request.arguments.enabled;
+var c=request.arguments.condition;
+var d=request.arguments.ignoreCount;
+if(!a){
+response.failed('Missing argument "breakpoint"');
+return;
+}
+if(!(b===(void 0))){
+if(b){
+Debug.enableBreakPoint(a);
+}else{
+Debug.disableBreakPoint(a);
+}
+}
+if(!(c===(void 0))){
+Debug.changeBreakPointCondition(a,c);
+}
+if(!(d===(void 0))){
+Debug.changeBreakPointIgnoreCount(a,d);
+}
+};
+DebugCommandProcessor.prototype.clearBreakPointGroupRequest_=function(
+request,response){
+if(!request.arguments){
+response.failed('Missing arguments');
+return;
+}
+var a=request.arguments.groupId;
+if(!a){
+response.failed('Missing argument "groupId"');
+return;
+}
+var b=[];
+var c=[];
+for(var d=0;d<script_break_points.length;d++){
+var e=script_break_points[d];
+if(e.groupId()==a){
+b.push(e.number());
+e.clear();
+}else{
+c.push(e);
+}
+}
+script_break_points=c;
+response.body={breakpoints:b};
+};
+DebugCommandProcessor.prototype.clearBreakPointRequest_=function(
+request,response){
+if(!request.arguments){
+response.failed('Missing arguments');
+return;
+}
+var a=%ToNumber(request.arguments.breakpoint);
+if(!a){
+response.failed('Missing argument "breakpoint"');
+return;
+}
+Debug.clearBreakPoint(a);
+response.body={breakpoint:a};
+};
+DebugCommandProcessor.prototype.listBreakpointsRequest_=function(
+request,response){
+var a=[];
+for(var b=0;b<script_break_points.length;b++){
+var c=script_break_points[b];
+var d={
+number:c.number(),
+line:c.line(),
+column:c.column(),
+groupId:c.groupId(),
+hit_count:c.hit_count(),
+active:c.active(),
+condition:c.condition(),
+ignoreCount:c.ignoreCount(),
+actual_locations:c.actual_locations()
+};
+if(c.type()==Debug.ScriptBreakPointType.ScriptId){
+d.type='scriptId';
+d.script_id=c.script_id();
+}else if(c.type()==Debug.ScriptBreakPointType.ScriptName){
+d.type='scriptName';
+d.script_name=c.script_name();
+}else if(c.type()==Debug.ScriptBreakPointType.ScriptRegExp){
+d.type='scriptRegExp';
+d.script_regexp=c.script_regexp_object().source;
+}else{
+throw new Error("Internal error: Unexpected breakpoint type: "+
+c.type());
+}
+a.push(d);
+}
+response.body={
+breakpoints:a,
+breakOnExceptions:Debug.isBreakOnException(),
+breakOnUncaughtExceptions:Debug.isBreakOnUncaughtException()
+};
+};
+DebugCommandProcessor.prototype.disconnectRequest_=
+function(a,b){
+Debug.disableAllBreakPoints();
+this.continueRequest_(a,b);
+};
+DebugCommandProcessor.prototype.setExceptionBreakRequest_=
+function(a,b){
+if(!a.arguments){
+b.failed('Missing arguments');
+return;
+}
+var c=a.arguments.type;
+if(!c){
+b.failed('Missing argument "type"');
+return;
+}
+var d;
+if(c=='all'){
+d=!Debug.isBreakOnException();
+}else if(c=='uncaught'){
+d=!Debug.isBreakOnUncaughtException();
+}
+if(!(a.arguments.enabled===(void 0))){
+d=a.arguments.enabled;
+if((d!=true)&&(d!=false)){
+b.failed('Illegal value for "enabled":"'+d+'"');
+}
+}
+if(c=='all'){
+%ChangeBreakOnException(Debug.ExceptionBreak.Caught,d);
+}else if(c=='uncaught'){
+%ChangeBreakOnException(Debug.ExceptionBreak.Uncaught,d);
+}else{
+b.failed('Unknown "type":"'+c+'"');
+}
+b.body={'type':c,'enabled':d};
+};
+DebugCommandProcessor.prototype.backtraceRequest_=function(
+request,response){
+var a=this.exec_state_.frameCount();
+if(a==0){
+response.body={
+totalFrames:a
+};
+return;
+}
+var b=0;
+var c=kDefaultBacktraceLength;
+if(request.arguments){
+if(request.arguments.fromFrame){
+b=request.arguments.fromFrame;
+}
+if(request.arguments.toFrame){
+c=request.arguments.toFrame;
+}
+if(request.arguments.bottom){
+var d=a-b;
+b=a-c;
+c=d;
+}
+if(b<0||c<0){
+return response.failed('Invalid frame number');
+}
+}
+c=Math.min(a,c);
+if(c<=b){
+var e='Invalid frame range';
+return response.failed(e);
+}
+var g=[];
+for(var h=b;h<c;h++){
+g.push(this.exec_state_.frame(h));
+}
+response.body={
+fromFrame:b,
+toFrame:c,
+totalFrames:a,
+frames:g
+};
+};
+DebugCommandProcessor.prototype.frameRequest_=function(a,b){
+if(this.exec_state_.frameCount()==0){
+return b.failed('No frames');
+}
+if(a.arguments){
+var c=a.arguments.number;
+if(c<0||this.exec_state_.frameCount()<=c){
+return b.failed('Invalid frame number');
+}
+this.exec_state_.setSelectedFrame(a.arguments.number);
+}
+b.body=this.exec_state_.frame();
+};
+DebugCommandProcessor.prototype.resolveFrameFromScopeDescription_=
+function(a){
+if(a&&!(a.frameNumber===(void 0))){
+var b=a.frameNumber;
+if(b<0||this.exec_state_.frameCount()<=b){
+throw new Error('Invalid frame number');
+}
+return this.exec_state_.frame(b);
+}else{
+return this.exec_state_.frame();
+}
+};
+DebugCommandProcessor.prototype.resolveScopeHolder_=
+function(a){
+if(a&&"functionHandle"in a){
+if(!(typeof(a.functionHandle)==='number')){
+throw new Error('Function handle must be a number');
+}
+var b=LookupMirror(a.functionHandle);
+if(!b){
+throw new Error('Failed to find function object by handle');
+}
+if(!b.isFunction()){
+throw new Error('Value of non-function type is found by handle');
+}
+return b;
+}else{
+if(this.exec_state_.frameCount()==0){
+throw new Error('No scopes');
+}
+var c=this.resolveFrameFromScopeDescription_(a);
+return c;
+}
+}
+DebugCommandProcessor.prototype.scopesRequest_=function(a,b){
+var c=this.resolveScopeHolder_(a.arguments);
+var d=c.scopeCount();
+var e=[];
+for(var g=0;g<d;g++){
+e.push(c.scope(g));
+}
+b.body={
+fromScope:0,
+toScope:d,
+totalScopes:d,
+scopes:e
+};
+};
+DebugCommandProcessor.prototype.scopeRequest_=function(a,b){
+var c=this.resolveScopeHolder_(a.arguments);
+var d=0;
+if(a.arguments&&!(a.arguments.number===(void 0))){
+d=%ToNumber(a.arguments.number);
+if(d<0||c.scopeCount()<=d){
+return b.failed('Invalid scope number');
+}
+}
+b.body=c.scope(d);
+};
+DebugCommandProcessor.resolveValue_=function(a){
+if("handle"in a){
+var b=LookupMirror(a.handle);
+if(!b){
+throw new Error("Failed to resolve value by handle, ' #"+
+a.handle+"# not found");
+}
+return b.value();
+}else if("stringDescription"in a){
+if(a.type==BOOLEAN_TYPE){
+return Boolean(a.stringDescription);
+}else if(a.type==NUMBER_TYPE){
+return Number(a.stringDescription);
+}if(a.type==STRING_TYPE){
+return String(a.stringDescription);
+}else{
+throw new Error("Unknown type");
+}
+}else if("value"in a){
+return a.value;
+}else if(a.type==UNDEFINED_TYPE){
+return(void 0);
+}else if(a.type==NULL_TYPE){
+return null;
+}else{
+throw new Error("Failed to parse value description");
+}
+};
+DebugCommandProcessor.prototype.setVariableValueRequest_=
+function(a,b){
+if(!a.arguments){
+b.failed('Missing arguments');
+return;
+}
+if((a.arguments.name===(void 0))){
+b.failed('Missing variable name');
+}
+var c=a.arguments.name;
+var d=a.arguments.scope;
+var e=this.resolveScopeHolder_(d);
+if((d.number===(void 0))){
+b.failed('Missing scope number');
+}
+var g=%ToNumber(d.number);
+var h=e.scope(g);
+var i=
+DebugCommandProcessor.resolveValue_(a.arguments.newValue);
+h.setVariableValue(c,i);
+var j=MakeMirror(i);
+b.body={
+newValue:j
+};
+};
+DebugCommandProcessor.prototype.evaluateRequest_=function(a,b){
+if(!a.arguments){
+return b.failed('Missing arguments');
+}
+var c=a.arguments.expression;
+var d=a.arguments.frame;
+var e=a.arguments.global;
+var g=a.arguments.disable_break;
+var h=a.arguments.additional_context;
+try{
+c=String(c);
+}catch(e){
+return b.failed('Failed to convert expression argument to string');
+}
+if(!(d===(void 0))&&e){
+return b.failed('Arguments "frame" and "global" are exclusive');
+}
+var i;
+if(h){
+i={};
+for(var j=0;j<h.length;j++){
+var k=h[j];
+if(!(typeof(k.name)==='string')){
+return b.failed("Context element #"+j+
+" doesn't contain name:string property");
+}
+var l=DebugCommandProcessor.resolveValue_(k);
+i[k.name]=l;
+}
+}
+if(e){
+b.body=this.exec_state_.evaluateGlobal(
+c,Boolean(g),i);
+return;
+}
+if((g===(void 0))){
+g=true;
+}
+if(this.exec_state_.frameCount()==0){
+return b.failed('No frames');
+}
+if(!(d===(void 0))){
+var m=%ToNumber(d);
+if(m<0||m>=this.exec_state_.frameCount()){
+return b.failed('Invalid frame "'+d+'"');
+}
+b.body=this.exec_state_.frame(m).evaluate(
+c,Boolean(g),i);
+return;
+}else{
+b.body=this.exec_state_.frame().evaluate(
+c,Boolean(g),i);
+return;
+}
+};
+DebugCommandProcessor.prototype.lookupRequest_=function(a,b){
+if(!a.arguments){
+return b.failed('Missing arguments');
+}
+var c=a.arguments.handles;
+if((c===(void 0))){
+return b.failed('Argument "handles" missing');
+}
+if(!(a.arguments.includeSource===(void 0))){
+var d=%ToBoolean(a.arguments.includeSource);
+b.setOption('includeSource',d);
+}
+var e={};
+for(var g=0;g<c.length;g++){
+var h=c[g];
+var i=LookupMirror(h);
+if(!i){
+return b.failed('Object #'+h+'# not found');
+}
+e[h]=i;
+}
+b.body=e;
+};
+DebugCommandProcessor.prototype.referencesRequest_=
+function(a,b){
+if(!a.arguments){
+return b.failed('Missing arguments');
+}
+var c=a.arguments.type;
+var d=a.arguments.handle;
+if((c===(void 0))){
+return b.failed('Argument "type" missing');
+}
+if((d===(void 0))){
+return b.failed('Argument "handle" missing');
+}
+if(c!='referencedBy'&&c!='constructedBy'){
+return b.failed('Invalid type "'+c+'"');
+}
+var e=LookupMirror(d);
+if(e){
+if(c=='referencedBy'){
+b.body=e.referencedBy();
+}else{
+b.body=e.constructedBy();
+}
+}else{
+return b.failed('Object #'+d+'# not found');
+}
+};
+DebugCommandProcessor.prototype.sourceRequest_=function(a,b){
+if(this.exec_state_.frameCount()==0){
+return b.failed('No source');
+}
+var c;
+var d;
+var e=this.exec_state_.frame();
+if(a.arguments){
+c=a.arguments.fromLine;
+d=a.arguments.toLine;
+if(!(a.arguments.frame===(void 0))){
+var g=%ToNumber(a.arguments.frame);
+if(g<0||g>=this.exec_state_.frameCount()){
+return b.failed('Invalid frame "'+e+'"');
+}
+e=this.exec_state_.frame(g);
+}
+}
+var h=e.func().script();
+if(!h){
+return b.failed('No source');
+}
+var i=h.sourceSlice(c,d);
+if(!i){
+return b.failed('Invalid line interval');
+}
+b.body={};
+b.body.source=i.sourceText();
+b.body.fromLine=i.from_line;
+b.body.toLine=i.to_line;
+b.body.fromPosition=i.from_position;
+b.body.toPosition=i.to_position;
+b.body.totalLines=h.lineCount();
+};
+DebugCommandProcessor.prototype.scriptsRequest_=function(a,b){
+var c=ScriptTypeFlag(Debug.ScriptType.Normal);
+var d=false;
+var e=null;
+if(a.arguments){
+if(!(a.arguments.types===(void 0))){
+c=%ToNumber(a.arguments.types);
+if(isNaN(c)||c<0){
+return b.failed('Invalid types "'+
+a.arguments.types+'"');
+}
+}
+if(!(a.arguments.includeSource===(void 0))){
+d=%ToBoolean(a.arguments.includeSource);
+b.setOption('includeSource',d);
+}
+if((%_IsArray(a.arguments.ids))){
+e={};
+var g=a.arguments.ids;
+for(var h=0;h<g.length;h++){
+e[g[h]]=true;
+}
+}
+var i=null;
+var j=null;
+if(!(a.arguments.filter===(void 0))){
+var k=%ToNumber(a.arguments.filter);
+if(!isNaN(k)){
+j=k;
+}
+i=a.arguments.filter;
+}
+}
+var l=%DebugGetLoadedScripts();
+b.body=[];
+for(var h=0;h<l.length;h++){
+if(e&&!e[l[h].id]){
+continue;
+}
+if(i||j){
+var m=l[h];
+var n=false;
+if(j&&!n){
+if(m.id&&m.id===j){
+n=true;
+}
+}
+if(i&&!n){
+if(m.name&&m.name.indexOf(i)>=0){
+n=true;
+}
+}
+if(!n)continue;
+}
+if(c&ScriptTypeFlag(l[h].type)){
+b.body.push(MakeMirror(l[h]));
+}
+}
+};
+DebugCommandProcessor.prototype.threadsRequest_=function(a,b){
+var c=this.exec_state_.threadCount();
+var d=[];
+for(var e=0;e<c;e++){
+var g=%GetThreadDetails(this.exec_state_.break_id,e);
+var h={current:g[0],
+id:g[1]
+};
+d.push(h);
+}
+b.body={
+totalThreads:c,
+threads:d
+};
+};
+DebugCommandProcessor.prototype.suspendRequest_=function(a,b){
+b.running=false;
+};
+DebugCommandProcessor.prototype.versionRequest_=function(a,b){
+b.body={
+V8Version:%GetV8Version()
+};
+};
+DebugCommandProcessor.prototype.changeLiveRequest_=function(
+request,response){
+if(!request.arguments){
+return response.failed('Missing arguments');
+}
+var a=request.arguments.script_id;
+var b=!!request.arguments.preview_only;
+var c=%DebugGetLoadedScripts();
+var d=null;
+for(var e=0;e<c.length;e++){
+if(c[e].id==a){
+d=c[e];
+}
+}
+if(!d){
+response.failed('Script not found');
+return;
+}
+var g=new Array();
+if(!(typeof(request.arguments.new_source)==='string')){
+throw"new_source argument expected";
+}
+var h=request.arguments.new_source;
+var i;
+try{
+i=Debug.LiveEdit.SetScriptSource(d,
+h,b,g);
+}catch(e){
+if(e instanceof Debug.LiveEdit.Failure&&"details"in e){
+response.failed(e.message,e.details);
+return;
+}
+throw e;
+}
+response.body={change_log:g,result:i};
+if(!b&&!this.running_&&i.stack_modified){
+response.body.stepin_recommended=true;
+}
+};
+DebugCommandProcessor.prototype.restartFrameRequest_=function(
+request,response){
+if(!request.arguments){
+return response.failed('Missing arguments');
+}
+var a=request.arguments.frame;
+if(this.exec_state_.frameCount()==0){
+return response.failed('No frames');
+}
+var b;
+if(!(a===(void 0))){
+var c=%ToNumber(a);
+if(c<0||c>=this.exec_state_.frameCount()){
+return response.failed('Invalid frame "'+a+'"');
+}
+b=this.exec_state_.frame(c);
+}else{
+b=this.exec_state_.frame();
+}
+var d=Debug.LiveEdit.RestartFrame(b);
+response.body={result:d};
+};
+DebugCommandProcessor.prototype.debuggerFlagsRequest_=function(request,
+response){
+if(!request.arguments){
+response.failed('Missing arguments');
+return;
+}
+var a=request.arguments.flags;
+response.body={flags:[]};
+if(!(a===(void 0))){
+for(var b=0;b<a.length;b++){
+var c=a[b].name;
+var d=debugger_flags[c];
+if(!d){
+continue;
+}
+if('value'in a[b]){
+d.setValue(a[b].value);
+}
+response.body.flags.push({name:c,value:d.getValue()});
+}
+}else{
+for(var c in debugger_flags){
+var e=debugger_flags[c].getValue();
+response.body.flags.push({name:c,value:e});
+}
+}
+};
+DebugCommandProcessor.prototype.v8FlagsRequest_=function(a,b){
+var c=a.arguments.flags;
+if(!c)c='';
+%SetFlags(c);
+};
+DebugCommandProcessor.prototype.gcRequest_=function(a,b){
+var c=a.arguments.type;
+if(!c)c='all';
+var d=%GetHeapUsage();
+%CollectGarbage(c);
+var e=%GetHeapUsage();
+b.body={"before":d,"after":e};
+};
+DebugCommandProcessor.prototype.dispatch_=(function(){
+var a=DebugCommandProcessor.prototype;
+return{
+"continue":a.continueRequest_,
+"break":a.breakRequest_,
+"setbreakpoint":a.setBreakPointRequest_,
+"changebreakpoint":a.changeBreakPointRequest_,
+"clearbreakpoint":a.clearBreakPointRequest_,
+"clearbreakpointgroup":a.clearBreakPointGroupRequest_,
+"disconnect":a.disconnectRequest_,
+"setexceptionbreak":a.setExceptionBreakRequest_,
+"listbreakpoints":a.listBreakpointsRequest_,
+"backtrace":a.backtraceRequest_,
+"frame":a.frameRequest_,
+"scopes":a.scopesRequest_,
+"scope":a.scopeRequest_,
+"setvariablevalue":a.setVariableValueRequest_,
+"evaluate":a.evaluateRequest_,
+"lookup":a.lookupRequest_,
+"references":a.referencesRequest_,
+"source":a.sourceRequest_,
+"scripts":a.scriptsRequest_,
+"threads":a.threadsRequest_,
+"suspend":a.suspendRequest_,
+"version":a.versionRequest_,
+"changelive":a.changeLiveRequest_,
+"restartframe":a.restartFrameRequest_,
+"flags":a.debuggerFlagsRequest_,
+"v8flag":a.v8FlagsRequest_,
+"gc":a.gcRequest_,
+};
+})();
+DebugCommandProcessor.prototype.isRunning=function(){
+return this.running_;
+};
+DebugCommandProcessor.prototype.systemBreak=function(a,b){
+return %SystemBreak();
+};
+function ObjectToProtocolObject_(a,b){
+var c={};
+for(var d in a){
+if(typeof d=='string'){
+var e=ValueToProtocolValue_(a[d],
+b);
+if(!(e===(void 0))){
+c[d]=e;
+}
+}
+}
+return c;
+}
+function ArrayToProtocolArray_(a,b){
+var c=[];
+for(var d=0;d<a.length;d++){
+c.push(ValueToProtocolValue_(a[d],b));
+}
+return c;
+}
+function ValueToProtocolValue_(a,b){
+var c;
+switch(typeof a){
+case'object':
+if(a instanceof Mirror){
+c=b.serializeValue(a);
+}else if((%_IsArray(a))){
+c=ArrayToProtocolArray_(a,b);
+}else{
+c=ObjectToProtocolObject_(a,b);
+}
+break;
+case'boolean':
+case'string':
+case'number':
+c=a;
+break;
+default:
+c=null;
+}
+return c;
+}
+
+\18mirrorz¥\ 2
+"use strict";
+var next_handle_=0;
+var next_transient_handle_=-1;
+var mirror_cache_=[];
+var mirror_cache_enabled_=true;
+function ToggleMirrorCache(a){
+mirror_cache_enabled_=a;
+next_handle_=0;
+mirror_cache_=[];
+}
+function ObjectIsPromise(a){
+try{
+return(%_IsSpecObject(a))&&
+!(%DebugGetProperty(a,builtins.$promiseStatus)===(void 0));
+}catch(e){
+return false;
+}
+}
+function MakeMirror(a,b){
+var c;
+if(!b&&mirror_cache_enabled_){
+for(var d in mirror_cache_){
+c=mirror_cache_[d];
+if(c.value()===a){
+return c;
+}
+if(c.isNumber()&&isNaN(c.value())&&
+typeof a=='number'&&isNaN(a)){
+return c;
+}
+}
+}
+if((a===(void 0))){
+c=new UndefinedMirror();
+}else if((a===null)){
+c=new NullMirror();
+}else if((typeof(a)==='boolean')){
+c=new BooleanMirror(a);
+}else if((typeof(a)==='number')){
+c=new NumberMirror(a);
+}else if((typeof(a)==='string')){
+c=new StringMirror(a);
+}else if((typeof(a)==='symbol')){
+c=new SymbolMirror(a);
+}else if((%_IsArray(a))){
+c=new ArrayMirror(a);
+}else if((%_ClassOf(a)==='Date')){
+c=new DateMirror(a);
+}else if((%_IsFunction(a))){
+c=new FunctionMirror(a);
+}else if((%_IsRegExp(a))){
+c=new RegExpMirror(a);
+}else if((%_ClassOf(a)==='Error')){
+c=new ErrorMirror(a);
+}else if((%_ClassOf(a)==='Script')){
+c=new ScriptMirror(a);
+}else if((%_ClassOf(a)==='Map')||(%_ClassOf(a)==='WeakMap')){
+c=new MapMirror(a);
+}else if((%_ClassOf(a)==='Set')||(%_ClassOf(a)==='WeakSet')){
+c=new SetMirror(a);
+}else if((%_ClassOf(a)==='Map Iterator')||(%_ClassOf(a)==='Set Iterator')){
+c=new IteratorMirror(a);
+}else if(ObjectIsPromise(a)){
+c=new PromiseMirror(a);
+}else if((%_ClassOf(a)==='Generator')){
+c=new GeneratorMirror(a);
+}else{
+c=new ObjectMirror(a,OBJECT_TYPE,b);
+}
+if(mirror_cache_enabled_)mirror_cache_[c.handle()]=c;
+return c;
+}
+function LookupMirror(a){
+if(!mirror_cache_enabled_)throw new Error("Mirror cache is disabled");
+return mirror_cache_[a];
+}
+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 UNDEFINED_TYPE='undefined';
+var NULL_TYPE='null';
+var BOOLEAN_TYPE='boolean';
+var NUMBER_TYPE='number';
+var STRING_TYPE='string';
+var SYMBOL_TYPE='symbol';
+var OBJECT_TYPE='object';
+var FUNCTION_TYPE='function';
+var REGEXP_TYPE='regexp';
+var ERROR_TYPE='error';
+var PROPERTY_TYPE='property';
+var INTERNAL_PROPERTY_TYPE='internalProperty';
+var FRAME_TYPE='frame';
+var SCRIPT_TYPE='script';
+var CONTEXT_TYPE='context';
+var SCOPE_TYPE='scope';
+var PROMISE_TYPE='promise';
+var MAP_TYPE='map';
+var SET_TYPE='set';
+var ITERATOR_TYPE='iterator';
+var GENERATOR_TYPE='generator';
+var kMaxProtocolStringLength=80;
+var PropertyKind={};
+PropertyKind.Named=1;
+PropertyKind.Indexed=2;
+var PropertyType={};
+PropertyType.Data=0;
+PropertyType.DataConstant=2;
+PropertyType.AccessorConstant=3;
+var PropertyAttribute={};
+PropertyAttribute.None=0;
+PropertyAttribute.ReadOnly=1;
+PropertyAttribute.DontEnum=2;
+PropertyAttribute.DontDelete=4;
+var ScopeType={Global:0,
+Local:1,
+With:2,
+Closure:3,
+Catch:4,
+Block:5,
+Script:6};
+function Mirror(a){
+this.type_=a;
+}
+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(mirror_cache_enabled_)this.handle_=next_handle_++;
+};
+Mirror.prototype.allocateTransientHandle_=function(){
+this.handle_=next_transient_handle_--;
+};
+Mirror.prototype.toText=function(){
+return"#<"+this.constructor.name+">";
+};
+function ValueMirror(a,b,c){
+%_CallFunction(this,a,Mirror);
+this.value_=b;
+if(!c){
+this.allocateHandle_();
+}else{
+this.allocateTransientHandle_();
+}
+}
+inherits(ValueMirror,Mirror);
+Mirror.prototype.handle=function(){
+return this.handle_;
+};
+ValueMirror.prototype.isPrimitive=function(){
+var a=this.type();
+return a==='undefined'||
+a==='null'||
+a==='boolean'||
+a==='number'||
+a==='string'||
+a==='symbol';
+};
+ValueMirror.prototype.value=function(){
+return this.value_;
+};
+function UndefinedMirror(){
+%_CallFunction(this,UNDEFINED_TYPE,(void 0),ValueMirror);
+}
+inherits(UndefinedMirror,ValueMirror);
+UndefinedMirror.prototype.toText=function(){
+return'undefined';
+};
+function NullMirror(){
+%_CallFunction(this,NULL_TYPE,null,ValueMirror);
+}
+inherits(NullMirror,ValueMirror);
+NullMirror.prototype.toText=function(){
+return'null';
+};
+function BooleanMirror(a){
+%_CallFunction(this,BOOLEAN_TYPE,a,ValueMirror);
+}
+inherits(BooleanMirror,ValueMirror);
+BooleanMirror.prototype.toText=function(){
+return this.value_?'true':'false';
+};
+function NumberMirror(a){
+%_CallFunction(this,NUMBER_TYPE,a,ValueMirror);
+}
+inherits(NumberMirror,ValueMirror);
+NumberMirror.prototype.toText=function(){
+return %_NumberToString(this.value_);
+};
+function StringMirror(a){
+%_CallFunction(this,STRING_TYPE,a,ValueMirror);
+}
+inherits(StringMirror,ValueMirror);
+StringMirror.prototype.length=function(){
+return this.value_.length;
+};
+StringMirror.prototype.getTruncatedValue=function(a){
+if(a!=-1&&this.length()>a){
+return this.value_.substring(0,a)+
+'... (length: '+this.length()+')';
+}
+return this.value_;
+};
+StringMirror.prototype.toText=function(){
+return this.getTruncatedValue(kMaxProtocolStringLength);
+};
+function SymbolMirror(a){
+%_CallFunction(this,SYMBOL_TYPE,a,ValueMirror);
+}
+inherits(SymbolMirror,ValueMirror);
+SymbolMirror.prototype.description=function(){
+return %SymbolDescription(%_ValueOf(this.value_));
+}
+SymbolMirror.prototype.toText=function(){
+return %_CallFunction(this.value_,builtins.$symbolToString);
+}
+function ObjectMirror(a,b,c){
+%_CallFunction(this,b||OBJECT_TYPE,a,c,ValueMirror);
+}
+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 a=%GetInterceptorInfo(this.value_);
+return(a&2)!=0;
+};
+ObjectMirror.prototype.hasIndexedInterceptor=function(){
+var a=%GetInterceptorInfo(this.value_);
+return(a&1)!=0;
+};
+function TryGetPropertyNames(a){
+try{
+return %GetOwnPropertyNames(a,32);
+}catch(e){
+return[];
+}
+}
+ObjectMirror.prototype.propertyNames=function(a,b){
+a=a||PropertyKind.Named|PropertyKind.Indexed;
+var c;
+var d;
+var e=0;
+if(a&PropertyKind.Named){
+c=TryGetPropertyNames(this.value_);
+e+=c.length;
+if(this.hasNamedInterceptor()&&(a&PropertyKind.Named)){
+var g=
+%GetNamedInterceptorPropertyNames(this.value_);
+if(g){
+c=c.concat(g);
+e+=g.length;
+}
+}
+}
+if(a&PropertyKind.Indexed){
+d=%GetOwnElementNames(this.value_);
+e+=d.length;
+if(this.hasIndexedInterceptor()&&(a&PropertyKind.Indexed)){
+var h=
+%GetIndexedInterceptorElementNames(this.value_);
+if(h){
+d=d.concat(h);
+e+=h.length;
+}
+}
+}
+b=Math.min(b||e,e);
+var i=new Array(b);
+var j=0;
+if(a&PropertyKind.Named){
+for(var k=0;j<b&&k<c.length;k++){
+i[j++]=c[k];
+}
+}
+if(a&PropertyKind.Indexed){
+for(var k=0;j<b&&k<d.length;k++){
+i[j++]=d[k];
+}
+}
+return i;
+};
+ObjectMirror.prototype.properties=function(a,b){
+var c=this.propertyNames(a,b);
+var d=new Array(c.length);
+for(var e=0;e<c.length;e++){
+d[e]=this.property(c[e]);
+}
+return d;
+};
+ObjectMirror.prototype.internalProperties=function(){
+return ObjectMirror.GetInternalProperties(this.value_);
+}
+ObjectMirror.prototype.property=function(a){
+var b=%DebugGetPropertyDetails(this.value_,%ToName(a));
+if(b){
+return new PropertyMirror(this,a,b);
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.lookupProperty=function(a){
+var b=this.properties();
+for(var c=0;c<b.length;c++){
+var d=b[c];
+if(d.propertyType()!=PropertyType.AccessorConstant){
+if(%_ObjectEquals(d.value_,a.value_)){
+return d;
+}
+}
+}
+return GetUndefinedMirror();
+};
+ObjectMirror.prototype.referencedBy=function(a){
+var b=%DebugReferencedBy(this.value_,
+Mirror.prototype,a||0);
+for(var c=0;c<b.length;c++){
+b[c]=MakeMirror(b[c]);
+}
+return b;
+};
+ObjectMirror.prototype.toText=function(){
+var a;
+var b=this.constructorFunction();
+if(!b.isFunction()){
+a=this.className();
+}else{
+a=b.name();
+if(!a){
+a=this.className();
+}
+}
+return'#<'+a+'>';
+};
+ObjectMirror.GetInternalProperties=function(a){
+if((%_ClassOf(a)==='String')||(%_ClassOf(a)==='Number')||
+(%_ClassOf(a)==='Boolean')){
+var b=%_ValueOf(a);
+return[new InternalPropertyMirror("[[PrimitiveValue]]",b)];
+}else if((%_IsFunction(a))){
+var c=%BoundFunctionGetBindings(a);
+var d=[];
+if(c&&(%_IsArray(c))){
+d.push(new InternalPropertyMirror("[[TargetFunction]]",
+c[0]));
+d.push(new InternalPropertyMirror("[[BoundThis]]",c[1]));
+var e=[];
+for(var g=2;g<c.length;g++){
+e.push(c[g]);
+}
+d.push(new InternalPropertyMirror("[[BoundArgs]]",e));
+}
+return d;
+}else if((%_ClassOf(a)==='Map Iterator')||(%_ClassOf(a)==='Set Iterator')){
+var h=(%_ClassOf(a)==='Map Iterator')?%MapIteratorDetails(a)
+:%SetIteratorDetails(a);
+var i;
+switch(h[2]){
+case 1:i="keys";break;
+case 2:i="values";break;
+case 3:i="entries";break;
+}
+var d=[
+new InternalPropertyMirror("[[IteratorHasMore]]",h[0]),
+new InternalPropertyMirror("[[IteratorIndex]]",h[1])
+];
+if(i){
+d.push(new InternalPropertyMirror("[[IteratorKind]]",i));
+}
+return d;
+}else if((%_ClassOf(a)==='Generator')){
+return[
+new InternalPropertyMirror("[[GeneratorStatus]]",
+GeneratorGetStatus_(a)),
+new InternalPropertyMirror("[[GeneratorFunction]]",
+%GeneratorGetFunction(a)),
+new InternalPropertyMirror("[[GeneratorReceiver]]",
+%GeneratorGetReceiver(a))
+];
+}else if(ObjectIsPromise(a)){
+return[
+new InternalPropertyMirror("[[PromiseStatus]]",PromiseGetStatus_(a)),
+new InternalPropertyMirror("[[PromiseValue]]",PromiseGetValue_(a))
+];
+}
+return[];
+}
+function FunctionMirror(a){
+%_CallFunction(this,a,FUNCTION_TYPE,ObjectMirror);
+this.resolved_=true;
+}
+inherits(FunctionMirror,ObjectMirror);
+FunctionMirror.prototype.resolved=function(){
+return this.resolved_;
+};
+FunctionMirror.prototype.name=function(){
+return %FunctionGetName(this.value_);
+};
+FunctionMirror.prototype.inferredName=function(){
+return %FunctionGetInferredName(this.value_);
+};
+FunctionMirror.prototype.source=function(){
+if(this.resolved()){
+return builtins.FunctionSourceString(this.value_);
+}
+};
+FunctionMirror.prototype.script=function(){
+if(this.resolved()){
+if(this.script_){
+return this.script_;
+}
+var a=%FunctionGetScript(this.value_);
+if(a){
+return this.script_=MakeMirror(a);
+}
+}
+};
+FunctionMirror.prototype.sourcePosition_=function(){
+if(this.resolved()){
+return %FunctionGetScriptSourcePosition(this.value_);
+}
+};
+FunctionMirror.prototype.sourceLocation=function(){
+if(this.resolved()){
+var a=this.script();
+if(a){
+return a.locationFromPosition(this.sourcePosition_(),true);
+}
+}
+};
+FunctionMirror.prototype.constructedBy=function(a){
+if(this.resolved()){
+var b=%DebugConstructedBy(this.value_,a||0);
+for(var c=0;c<b.length;c++){
+b[c]=MakeMirror(b[c]);
+}
+return b;
+}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(a){
+if(this.resolved()){
+return new ScopeMirror((void 0),this,a);
+}
+};
+FunctionMirror.prototype.toText=function(){
+return this.source();
+};
+function UnresolvedFunctionMirror(a){
+%_CallFunction(this,FUNCTION_TYPE,a,ValueMirror);
+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 undefined;
+};
+UnresolvedFunctionMirror.prototype.propertyNames=function(a,b){
+return[];
+};
+function ArrayMirror(a){
+%_CallFunction(this,a,ObjectMirror);
+}
+inherits(ArrayMirror,ObjectMirror);
+ArrayMirror.prototype.length=function(){
+return this.value_.length;
+};
+ArrayMirror.prototype.indexedPropertiesFromRange=function(opt_from_index,
+opt_to_index){
+var a=opt_from_index||0;
+var b=opt_to_index||this.length()-1;
+if(a>b)return new Array();
+var c=new Array(b-a+1);
+for(var d=a;d<=b;d++){
+var e=%DebugGetPropertyDetails(this.value_,%ToString(d));
+var g;
+if(e){
+g=new PropertyMirror(this,d,e);
+}else{
+g=GetUndefinedMirror();
+}
+c[d-a]=g;
+}
+return c;
+};
+function DateMirror(a){
+%_CallFunction(this,a,ObjectMirror);
+}
+inherits(DateMirror,ObjectMirror);
+DateMirror.prototype.toText=function(){
+var a=JSON.stringify(this.value_);
+return a.substring(1,a.length-1);
+};
+function RegExpMirror(a){
+%_CallFunction(this,a,REGEXP_TYPE,ObjectMirror);
+}
+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(a){
+%_CallFunction(this,a,ERROR_TYPE,ObjectMirror);
+}
+inherits(ErrorMirror,ObjectMirror);
+ErrorMirror.prototype.message=function(){
+return this.value_.message;
+};
+ErrorMirror.prototype.toText=function(){
+var a;
+try{
+a=%_CallFunction(this.value_,builtins.ErrorToString);
+}catch(e){
+a='#<Error>';
+}
+return a;
+};
+function PromiseMirror(a){
+%_CallFunction(this,a,PROMISE_TYPE,ObjectMirror);
+}
+inherits(PromiseMirror,ObjectMirror);
+function PromiseGetStatus_(a){
+var b=%DebugGetProperty(a,builtins.$promiseStatus);
+if(b==0)return"pending";
+if(b==1)return"resolved";
+return"rejected";
+}
+function PromiseGetValue_(a){
+return %DebugGetProperty(a,builtins.$promiseValue);
+}
+PromiseMirror.prototype.status=function(){
+return PromiseGetStatus_(this.value_);
+};
+PromiseMirror.prototype.promiseValue=function(){
+return MakeMirror(PromiseGetValue_(this.value_));
+};
+function MapMirror(a){
+%_CallFunction(this,a,MAP_TYPE,ObjectMirror);
+}
+inherits(MapMirror,ObjectMirror);
+MapMirror.prototype.entries=function(a){
+var b=[];
+if((%_ClassOf(this.value_)==='WeakMap')){
+var c=%GetWeakMapEntries(this.value_,a||0);
+for(var d=0;d<c.length;d+=2){
+b.push({
+key:c[d],
+value:c[d+1]
+});
+}
+return b;
+}
+var e=%_CallFunction(this.value_,builtins.$mapEntries);
+var g;
+while((!a||b.length<a)&&
+!(g=e.next()).done){
+b.push({
+key:g.value[0],
+value:g.value[1]
+});
+}
+return b;
+};
+function SetMirror(a){
+%_CallFunction(this,a,SET_TYPE,ObjectMirror);
+}
+inherits(SetMirror,ObjectMirror);
+function IteratorGetValues_(a,b,c){
+var d=[];
+var e;
+while((!c||d.length<c)&&
+!(e=%_CallFunction(a,b)).done){
+d.push(e.value);
+}
+return d;
+}
+SetMirror.prototype.values=function(a){
+if((%_ClassOf(this.value_)==='WeakSet')){
+return %GetWeakSetValues(this.value_,a||0);
+}
+var b=%_CallFunction(this.value_,builtins.$setValues);
+return IteratorGetValues_(b,builtins.$setIteratorNext,a);
+};
+function IteratorMirror(a){
+%_CallFunction(this,a,ITERATOR_TYPE,ObjectMirror);
+}
+inherits(IteratorMirror,ObjectMirror);
+IteratorMirror.prototype.preview=function(a){
+if((%_ClassOf(this.value_)==='Map Iterator')){
+return IteratorGetValues_(%MapIteratorClone(this.value_),
+builtins.$mapIteratorNext,
+a);
+}else if((%_ClassOf(this.value_)==='Set Iterator')){
+return IteratorGetValues_(%SetIteratorClone(this.value_),
+builtins.$setIteratorNext,
+a);
+}
+};
+function GeneratorMirror(a){
+%_CallFunction(this,a,GENERATOR_TYPE,ObjectMirror);
+}
+inherits(GeneratorMirror,ObjectMirror);
+function GeneratorGetStatus_(a){
+var b=%GeneratorGetContinuation(a);
+if(b<0)return"running";
+if(b==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 a=this.sourcePosition_();
+if(!(a===(void 0))){
+var b=this.func().script();
+if(b){
+return b.locationFromPosition(a,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(a,b,c){
+%_CallFunction(this,PROPERTY_TYPE,Mirror);
+this.mirror_=a;
+this.name_=b;
+this.value_=c[0];
+this.details_=c[1];
+this.is_interceptor_=c[2];
+if(c.length>3){
+this.exception_=c[3];
+this.getter_=c[4];
+this.setter_=c[5];
+}
+}
+inherits(PropertyMirror,Mirror);
+PropertyMirror.prototype.isReadOnly=function(){
+return(this.attributes()&PropertyAttribute.ReadOnly)!=0;
+};
+PropertyMirror.prototype.isEnum=function(){
+return(this.attributes()&PropertyAttribute.DontEnum)==0;
+};
+PropertyMirror.prototype.canDelete=function(){
+return(this.attributes()&PropertyAttribute.DontDelete)==0;
+};
+PropertyMirror.prototype.name=function(){
+return this.name_;
+};
+PropertyMirror.prototype.isIndexed=function(){
+for(var a=0;a<this.name_.length;a++){
+if(this.name_[a]<'0'||'9'<this.name_[a]){
+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()==PropertyType.AccessorConstant)&&
+!this.hasGetter()&&!this.hasSetter());
+};
+function InternalPropertyMirror(a,b){
+%_CallFunction(this,INTERNAL_PROPERTY_TYPE,Mirror);
+this.name_=a;
+this.value_=b;
+}
+inherits(InternalPropertyMirror,Mirror);
+InternalPropertyMirror.prototype.name=function(){
+return this.name_;
+};
+InternalPropertyMirror.prototype.value=function(){
+return MakeMirror(this.value_,false);
+};
+var kFrameDetailsFrameIdIndex=0;
+var kFrameDetailsReceiverIndex=1;
+var kFrameDetailsFunctionIndex=2;
+var kFrameDetailsArgumentCountIndex=3;
+var kFrameDetailsLocalCountIndex=4;
+var kFrameDetailsSourcePositionIndex=5;
+var kFrameDetailsConstructCallIndex=6;
+var kFrameDetailsAtReturnIndex=7;
+var kFrameDetailsFlagsIndex=8;
+var kFrameDetailsFirstDynamicIndex=9;
+var kFrameDetailsNameIndex=0;
+var kFrameDetailsValueIndex=1;
+var kFrameDetailsNameValueSize=2;
+var kFrameDetailsFlagDebuggerFrameMask=1<<0;
+var kFrameDetailsFlagOptimizedFrameMask=1<<1;
+var kFrameDetailsFlagInlinedFrameIndexMask=7<<2;
+function FrameDetails(a,b){
+this.break_id_=a;
+this.details_=%GetFrameDetails(a,b);
+}
+FrameDetails.prototype.frameId=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsFrameIdIndex];
+};
+FrameDetails.prototype.receiver=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsReceiverIndex];
+};
+FrameDetails.prototype.func=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsFunctionIndex];
+};
+FrameDetails.prototype.isConstructCall=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsConstructCallIndex];
+};
+FrameDetails.prototype.isAtReturn=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsAtReturnIndex];
+};
+FrameDetails.prototype.isDebuggerFrame=function(){
+%CheckExecutionState(this.break_id_);
+var a=kFrameDetailsFlagDebuggerFrameMask;
+return(this.details_[kFrameDetailsFlagsIndex]&a)==a;
+};
+FrameDetails.prototype.isOptimizedFrame=function(){
+%CheckExecutionState(this.break_id_);
+var a=kFrameDetailsFlagOptimizedFrameMask;
+return(this.details_[kFrameDetailsFlagsIndex]&a)==a;
+};
+FrameDetails.prototype.isInlinedFrame=function(){
+return this.inlinedFrameIndex()>0;
+};
+FrameDetails.prototype.inlinedFrameIndex=function(){
+%CheckExecutionState(this.break_id_);
+var a=kFrameDetailsFlagInlinedFrameIndexMask;
+return(this.details_[kFrameDetailsFlagsIndex]&a)>>2;
+};
+FrameDetails.prototype.argumentCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsArgumentCountIndex];
+};
+FrameDetails.prototype.argumentName=function(a){
+%CheckExecutionState(this.break_id_);
+if(a>=0&&a<this.argumentCount()){
+return this.details_[kFrameDetailsFirstDynamicIndex+
+a*kFrameDetailsNameValueSize+
+kFrameDetailsNameIndex];
+}
+};
+FrameDetails.prototype.argumentValue=function(a){
+%CheckExecutionState(this.break_id_);
+if(a>=0&&a<this.argumentCount()){
+return this.details_[kFrameDetailsFirstDynamicIndex+
+a*kFrameDetailsNameValueSize+
+kFrameDetailsValueIndex];
+}
+};
+FrameDetails.prototype.localCount=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsLocalCountIndex];
+};
+FrameDetails.prototype.sourcePosition=function(){
+%CheckExecutionState(this.break_id_);
+return this.details_[kFrameDetailsSourcePositionIndex];
+};
+FrameDetails.prototype.localName=function(a){
+%CheckExecutionState(this.break_id_);
+if(a>=0&&a<this.localCount()){
+var b=kFrameDetailsFirstDynamicIndex+
+this.argumentCount()*kFrameDetailsNameValueSize;
+return this.details_[b+
+a*kFrameDetailsNameValueSize+
+kFrameDetailsNameIndex];
+}
+};
+FrameDetails.prototype.localValue=function(a){
+%CheckExecutionState(this.break_id_);
+if(a>=0&&a<this.localCount()){
+var b=kFrameDetailsFirstDynamicIndex+
+this.argumentCount()*kFrameDetailsNameValueSize;
+return this.details_[b+
+a*kFrameDetailsNameValueSize+
+kFrameDetailsValueIndex];
+}
+};
+FrameDetails.prototype.returnValue=function(){
+%CheckExecutionState(this.break_id_);
+var a=
+kFrameDetailsFirstDynamicIndex+
+(this.argumentCount()+this.localCount())*kFrameDetailsNameValueSize;
+if(this.details_[kFrameDetailsAtReturnIndex]){
+return this.details_[a];
+}
+};
+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(a,b){
+%_CallFunction(this,FRAME_TYPE,Mirror);
+this.break_id_=a;
+this.index_=b;
+this.details_=new FrameDetails(a,b);
+}
+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 a=this.details_.func();
+if((%_IsFunction(a))){
+return this.func_=MakeMirror(a);
+}else{
+return new UnresolvedFunctionMirror(a);
+}
+};
+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(a){
+return this.details_.argumentName(a);
+};
+FrameMirror.prototype.argumentValue=function(a){
+return MakeMirror(this.details_.argumentValue(a));
+};
+FrameMirror.prototype.localCount=function(){
+return this.details_.localCount();
+};
+FrameMirror.prototype.localName=function(a){
+return this.details_.localName(a);
+};
+FrameMirror.prototype.localValue=function(a){
+return MakeMirror(this.details_.localValue(a));
+};
+FrameMirror.prototype.returnValue=function(){
+return MakeMirror(this.details_.returnValue());
+};
+FrameMirror.prototype.sourcePosition=function(){
+return this.details_.sourcePosition();
+};
+FrameMirror.prototype.sourceLocation=function(){
+var a=this.func();
+if(a.resolved()){
+var b=a.script();
+if(b){
+return b.locationFromPosition(this.sourcePosition(),true);
+}
+}
+};
+FrameMirror.prototype.sourceLine=function(){
+var a=this.sourceLocation();
+if(a){
+return a.line;
+}
+};
+FrameMirror.prototype.sourceColumn=function(){
+var a=this.sourceLocation();
+if(a){
+return a.column;
+}
+};
+FrameMirror.prototype.sourceLineText=function(){
+var a=this.sourceLocation();
+if(a){
+return a.sourceText();
+}
+};
+FrameMirror.prototype.scopeCount=function(){
+return this.details_.scopeCount();
+};
+FrameMirror.prototype.scope=function(a){
+return new ScopeMirror(this,(void 0),a);
+};
+FrameMirror.prototype.allScopes=function(a){
+var b=%GetAllScopesDetails(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+!!a);
+var c=[];
+for(var d=0;d<b.length;++d){
+c.push(new ScopeMirror(this,(void 0),d,b[d]));
+}
+return c;
+};
+FrameMirror.prototype.stepInPositions=function(){
+var a=this.func().script();
+var b=this.func().sourcePosition_();
+var c=this.details_.stepInPositionsImpl();
+var d=[];
+if(c){
+for(var e=0;e<c.length;e++){
+var g={};
+var h=a.locationFromPosition(b+c[e],
+true);
+serializeLocationFields(h,g);
+var i={
+position:g
+};
+d.push(i);
+}
+}
+return d;
+};
+FrameMirror.prototype.evaluate=function(source,disable_break,
+opt_context_object){
+return MakeMirror(%DebugEvaluate(this.break_id_,
+this.details_.frameId(),
+this.details_.inlinedFrameIndex(),
+source,
+Boolean(disable_break),
+opt_context_object));
+};
+FrameMirror.prototype.invocationText=function(){
+var a='';
+var b=this.func();
+var c=this.receiver();
+if(this.isConstructCall()){
+a+='new ';
+a+=b.name()?b.name():'[anonymous]';
+}else if(this.isDebuggerFrame()){
+a+='[debugger]';
+}else{
+var d=
+!c.className||(c.className()!='global');
+if(d){
+a+=c.toText();
+}
+var e=GetUndefinedMirror();
+if(c.isObject()){
+for(var g=c;
+!g.isNull()&&e.isUndefined();
+g=g.protoObject()){
+e=g.lookupProperty(b);
+}
+}
+if(!e.isUndefined()){
+if(!e.isIndexed()){
+if(d){
+a+='.';
+}
+a+=e.name();
+}else{
+a+='[';
+a+=e.name();
+a+=']';
+}
+if(b.name()&&b.name()!=e.name()){
+a+='(aka '+b.name()+')';
+}
+}else{
+if(d){
+a+='.';
+}
+a+=b.name()?b.name():'[anonymous]';
+}
+}
+if(!this.isDebuggerFrame()){
+a+='(';
+for(var h=0;h<this.argumentCount();h++){
+if(h!=0)a+=', ';
+if(this.argumentName(h)){
+a+=this.argumentName(h);
+a+='=';
+}
+a+=this.argumentValue(h).toText();
+}
+a+=')';
+}
+if(this.isAtReturn()){
+a+=' returning ';
+a+=this.returnValue().toText();
+}
+return a;
+};
+FrameMirror.prototype.sourceAndPositionText=function(){
+var a='';
+var b=this.func();
+if(b.resolved()){
+var c=b.script();
+if(c){
+if(c.name()){
+a+=c.name();
+}else{
+a+='[unnamed]';
+}
+if(!this.isDebuggerFrame()){
+var d=this.sourceLocation();
+a+=' line ';
+a+=!(d===(void 0))?(d.line+1):'?';
+a+=' column ';
+a+=!(d===(void 0))?(d.column+1):'?';
+if(!(this.sourcePosition()===(void 0))){
+a+=' (position '+(this.sourcePosition()+1)+')';
+}
+}
+}else{
+a+='[no source]';
+}
+}else{
+a+='[unresolved]';
+}
+return a;
+};
+FrameMirror.prototype.localsText=function(){
+var a='';
+var b=this.localCount();
+if(b>0){
+for(var c=0;c<b;++c){
+a+=' var ';
+a+=this.localName(c);
+a+=' = ';
+a+=this.localValue(c).toText();
+if(c<b-1)a+='\n';
+}
+}
+return a;
+};
+FrameMirror.prototype.restart=function(){
+var a=%LiveEditRestartFrame(this.break_id_,this.index_);
+if((a===(void 0))){
+a="Failed to find requested frame";
+}
+return a;
+};
+FrameMirror.prototype.toText=function(a){
+var b='';
+b+='#'+(this.index()<=9?'0':'')+this.index();
+b+=' ';
+b+=this.invocationText();
+b+=' ';
+b+=this.sourceAndPositionText();
+if(a){
+b+='\n';
+b+=this.localsText();
+}
+return b;
+};
+var kScopeDetailsTypeIndex=0;
+var kScopeDetailsObjectIndex=1;
+function ScopeDetails(a,b,c,d){
+if(a){
+this.break_id_=a.break_id_;
+this.details_=d||
+%GetScopeDetails(a.break_id_,
+a.details_.frameId(),
+a.details_.inlinedFrameIndex(),
+c);
+this.frame_id_=a.details_.frameId();
+this.inlined_frame_id_=a.details_.inlinedFrameIndex();
+}else{
+this.details_=d||%GetFunctionScopeDetails(b.value(),c);
+this.fun_value_=b.value();
+this.break_id_=undefined;
+}
+this.index_=c;
+}
+ScopeDetails.prototype.type=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[kScopeDetailsTypeIndex];
+};
+ScopeDetails.prototype.object=function(){
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+}
+return this.details_[kScopeDetailsObjectIndex];
+};
+ScopeDetails.prototype.setVariableValueImpl=function(a,b){
+var c;
+if(!(this.break_id_===(void 0))){
+%CheckExecutionState(this.break_id_);
+c=%SetScopeVariableValue(this.break_id_,this.frame_id_,
+this.inlined_frame_id_,this.index_,a,b);
+}else{
+c=%SetScopeVariableValue(this.fun_value_,null,null,this.index_,
+a,b);
+}
+if(!c){
+throw new Error("Failed to set variable value");
+}
+};
+function ScopeMirror(a,b,c,d){
+%_CallFunction(this,SCOPE_TYPE,Mirror);
+if(a){
+this.frame_index_=a.index_;
+}else{
+this.frame_index_=undefined;
+}
+this.scope_index_=c;
+this.details_=new ScopeDetails(a,b,c,d);
+}
+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 a=this.scopeType()==ScopeType.Local||
+this.scopeType()==ScopeType.Closure||
+this.scopeType()==ScopeType.Script;
+return MakeMirror(this.details_.object(),a);
+};
+ScopeMirror.prototype.setVariableValue=function(a,b){
+this.details_.setVariableValueImpl(a,b);
+};
+function ScriptMirror(a){
+%_CallFunction(this,SCRIPT_TYPE,Mirror);
+this.script_=a;
+this.context_=new ContextMirror(a.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(a){
+%DebugSetScriptSource(this.script_,a);
+};
+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(a,b){
+return this.script_.sourceSlice(a,b);
+};
+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 a=this.evalFromScript();
+if(!a.isUndefined()){
+var b=this.script_.eval_from_script_position;
+return a.locationFromPosition(b,true);
+}
+};
+ScriptMirror.prototype.toText=function(){
+var a='';
+a+=this.name();
+a+=' (lines: ';
+if(this.lineOffset()>0){
+a+=this.lineOffset();
+a+='-';
+a+=this.lineOffset()+this.lineCount()-1;
+}else{
+a+=this.lineCount();
+}
+a+=')';
+return a;
+};
+function ContextMirror(a){
+%_CallFunction(this,CONTEXT_TYPE,Mirror);
+this.data_=a;
+this.allocateHandle_();
+}
+inherits(ContextMirror,Mirror);
+ContextMirror.prototype.data=function(){
+return this.data_;
+};
+function MakeMirrorSerializer(a,b){
+return new JSONProtocolSerializer(a,b);
+}
+function JSONProtocolSerializer(a,b){
+this.details_=a;
+this.options_=b;
+this.mirrors_=[];
+}
+JSONProtocolSerializer.prototype.serializeReference=function(a){
+return this.serialize_(a,true,true);
+};
+JSONProtocolSerializer.prototype.serializeValue=function(a){
+var b=this.serialize_(a,false,true);
+return b;
+};
+JSONProtocolSerializer.prototype.serializeReferencedObjects=function(){
+var a=[];
+var b=this.mirrors_.length;
+for(var c=0;c<b;c++){
+a.push(this.serialize_(this.mirrors_[c],false,false));
+}
+return a;
+};
+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 kMaxProtocolStringLength;
+}
+return this.options_.maxStringLength;
+};
+JSONProtocolSerializer.prototype.add_=function(a){
+for(var b=0;b<this.mirrors_.length;b++){
+if(this.mirrors_[b]===a){
+return;
+}
+}
+this.mirrors_.push(a);
+};
+JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_=
+function(a){
+var b={};
+b.ref=a.handle();
+b.type=a.type();
+switch(a.type()){
+case UNDEFINED_TYPE:
+case NULL_TYPE:
+case BOOLEAN_TYPE:
+case NUMBER_TYPE:
+b.value=a.value();
+break;
+case STRING_TYPE:
+b.value=a.getTruncatedValue(this.maxStringLength_());
+break;
+case SYMBOL_TYPE:
+b.description=a.description();
+break;
+case FUNCTION_TYPE:
+b.name=a.name();
+b.inferredName=a.inferredName();
+if(a.script()){
+b.scriptId=a.script().id();
+}
+break;
+case ERROR_TYPE:
+case REGEXP_TYPE:
+b.value=a.toText();
+break;
+case OBJECT_TYPE:
+b.className=a.className();
+break;
+}
+return b;
+};
+JSONProtocolSerializer.prototype.serialize_=function(mirror,reference,
+details){
+if(reference&&
+(mirror.isValue()||mirror.isScript()||mirror.isContext())){
+if(this.inlineRefs_()&&mirror.isValue()){
+return this.serializeReferenceWithDisplayData_(mirror);
+}else{
+this.add_(mirror);
+return{'ref':mirror.handle()};
+}
+}
+var a={};
+if(mirror.isValue()||mirror.isScript()||mirror.isContext()){
+a.handle=mirror.handle();
+}
+a.type=mirror.type();
+switch(mirror.type()){
+case UNDEFINED_TYPE:
+case NULL_TYPE:
+break;
+case BOOLEAN_TYPE:
+a.value=mirror.value();
+break;
+case NUMBER_TYPE:
+a.value=NumberToJSON_(mirror.value());
+break;
+case STRING_TYPE:
+if(this.maxStringLength_()!=-1&&
+mirror.length()>this.maxStringLength_()){
+var b=mirror.getTruncatedValue(this.maxStringLength_());
+a.value=b;
+a.fromIndex=0;
+a.toIndex=this.maxStringLength_();
+}else{
+a.value=mirror.value();
+}
+a.length=mirror.length();
+break;
+case SYMBOL_TYPE:
+a.description=mirror.description();
+break;
+case OBJECT_TYPE:
+case FUNCTION_TYPE:
+case ERROR_TYPE:
+case REGEXP_TYPE:
+case PROMISE_TYPE:
+case GENERATOR_TYPE:
+this.serializeObject_(mirror,a,details);
+break;
+case PROPERTY_TYPE:
+case INTERNAL_PROPERTY_TYPE:
+throw new Error('PropertyMirror cannot be serialized independently');
+break;
+case FRAME_TYPE:
+this.serializeFrame_(mirror,a);
+break;
+case SCOPE_TYPE:
+this.serializeScope_(mirror,a);
+break;
+case SCRIPT_TYPE:
+if(mirror.name()){
+a.name=mirror.name();
+}
+a.id=mirror.id();
+a.lineOffset=mirror.lineOffset();
+a.columnOffset=mirror.columnOffset();
+a.lineCount=mirror.lineCount();
+if(mirror.data()){
+a.data=mirror.data();
+}
+if(this.includeSource_()){
+a.source=mirror.source();
+}else{
+var c=mirror.source().substring(0,80);
+a.sourceStart=c;
+}
+a.sourceLength=mirror.source().length;
+a.scriptType=mirror.scriptType();
+a.compilationType=mirror.compilationType();
+if(mirror.compilationType()==1&&
+mirror.evalFromScript()){
+a.evalFromScript=
+this.serializeReference(mirror.evalFromScript());
+var d=mirror.evalFromLocation();
+if(d){
+a.evalFromLocation={line:d.line,
+column:d.column};
+}
+if(mirror.evalFromFunctionName()){
+a.evalFromFunctionName=mirror.evalFromFunctionName();
+}
+}
+if(mirror.context()){
+a.context=this.serializeReference(mirror.context());
+}
+break;
+case CONTEXT_TYPE:
+a.data=mirror.data();
+break;
+}
+a.text=mirror.toText();
+return a;
+};
+JSONProtocolSerializer.prototype.serializeObject_=function(mirror,content,
+details){
+content.className=mirror.className();
+content.constructorFunction=
+this.serializeReference(mirror.constructorFunction());
+content.protoObject=this.serializeReference(mirror.protoObject());
+content.prototypeObject=this.serializeReference(mirror.prototypeObject());
+if(mirror.hasNamedInterceptor()){
+content.namedInterceptor=true;
+}
+if(mirror.hasIndexedInterceptor()){
+content.indexedInterceptor=true;
+}
+if(mirror.isFunction()){
+content.name=mirror.name();
+if(!(mirror.inferredName()===(void 0))){
+content.inferredName=mirror.inferredName();
+}
+content.resolved=mirror.resolved();
+if(mirror.resolved()){
+content.source=mirror.source();
+}
+if(mirror.script()){
+content.script=this.serializeReference(mirror.script());
+content.scriptId=mirror.script().id();
+serializeLocationFields(mirror.sourceLocation(),content);
+}
+content.scopes=[];
+for(var a=0;a<mirror.scopeCount();a++){
+var b=mirror.scope(a);
+content.scopes.push({
+type:b.scopeType(),
+index:a
+});
+}
+}
+if(mirror.isGenerator()){
+content.status=mirror.status();
+content.func=this.serializeReference(mirror.func())
+content.receiver=this.serializeReference(mirror.receiver())
+serializeLocationFields(mirror.sourceLocation(),content);
+}
+if(mirror.isDate()){
+content.value=mirror.value();
+}
+if(mirror.isPromise()){
+content.status=mirror.status();
+content.promiseValue=this.serializeReference(mirror.promiseValue());
+}
+var c=mirror.propertyNames(PropertyKind.Named);
+var d=mirror.propertyNames(PropertyKind.Indexed);
+var e=new Array(c.length+d.length);
+for(var a=0;a<c.length;a++){
+var g=mirror.property(c[a]);
+e[a]=this.serializeProperty_(g);
+if(details){
+this.add_(g.value());
+}
+}
+for(var a=0;a<d.length;a++){
+var g=mirror.property(d[a]);
+e[c.length+a]=this.serializeProperty_(g);
+if(details){
+this.add_(g.value());
+}
+}
+content.properties=e;
+var h=mirror.internalProperties();
+if(h.length>0){
+var i=[];
+for(var a=0;a<h.length;a++){
+i.push(this.serializeInternalProperty_(h[a]));
+}
+content.internalProperties=i;
+}
+};
+function serializeLocationFields(a,b){
+if(!a){
+return;
+}
+b.position=a.position;
+var c=a.line;
+if(!(c===(void 0))){
+b.line=c;
+}
+var d=a.column;
+if(!(d===(void 0))){
+b.column=d;
+}
+}
+JSONProtocolSerializer.prototype.serializeProperty_=function(a){
+var b={};
+b.name=a.name();
+var c=a.value();
+if(this.inlineRefs_()&&c.isValue()){
+b.value=this.serializeReferenceWithDisplayData_(c);
+}else{
+if(a.attributes()!=PropertyAttribute.None){
+b.attributes=a.attributes();
+}
+b.propertyType=a.propertyType();
+b.ref=c.handle();
+}
+return b;
+};
+JSONProtocolSerializer.prototype.serializeInternalProperty_=
+function(a){
+var b={};
+b.name=a.name();
+var c=a.value();
+if(this.inlineRefs_()&&c.isValue()){
+b.value=this.serializeReferenceWithDisplayData_(c);
+}else{
+b.ref=c.handle();
+}
+return b;
+};
+JSONProtocolSerializer.prototype.serializeFrame_=function(a,b){
+b.index=a.index();
+b.receiver=this.serializeReference(a.receiver());
+var c=a.func();
+b.func=this.serializeReference(c);
+var d=c.script();
+if(d){
+b.script=this.serializeReference(d);
+}
+b.constructCall=a.isConstructCall();
+b.atReturn=a.isAtReturn();
+if(a.isAtReturn()){
+b.returnValue=this.serializeReference(a.returnValue());
+}
+b.debuggerFrame=a.isDebuggerFrame();
+var e=new Array(a.argumentCount());
+for(var g=0;g<a.argumentCount();g++){
+var h={};
+var i=a.argumentName(g);
+if(i){
+h.name=i;
+}
+h.value=this.serializeReference(a.argumentValue(g));
+e[g]=h;
+}
+b.arguments=e;
+var e=new Array(a.localCount());
+for(var g=0;g<a.localCount();g++){
+var j={};
+j.name=a.localName(g);
+j.value=this.serializeReference(a.localValue(g));
+e[g]=j;
+}
+b.locals=e;
+serializeLocationFields(a.sourceLocation(),b);
+var k=a.sourceLineText();
+if(!(k===(void 0))){
+b.sourceLineText=k;
+}
+b.scopes=[];
+for(var g=0;g<a.scopeCount();g++){
+var l=a.scope(g);
+b.scopes.push({
+type:l.scopeType(),
+index:g
+});
+}
+};
+JSONProtocolSerializer.prototype.serializeScope_=function(a,b){
+b.index=a.scopeIndex();
+b.frameIndex=a.frameIndex();
+b.type=a.scopeType();
+b.object=this.inlineRefs_()?
+this.serializeValue(a.scopeObject()):
+this.serializeReference(a.scopeObject());
+};
+function NumberToJSON_(a){
+if(isNaN(a)){
+return'NaN';
+}
+if(!(%_IsSmi(%IS_VAR(a))||((a==a)&&(a!=1/0)&&(a!=-1/0)))){
+if(a>0){
+return'Infinity';
+}else{
+return'-Infinity';
+}
+}
+return a;
+}
+
+ liveeditÁø
+"use strict";
+Debug.LiveEdit=new function(){
+var a;
+var b="stack_update_needs_step_in";
+function ApplyPatchMultiChunk(script,diff_array,new_source,preview_only,
+change_log){
+var c=script.source;
+var d=GatherCompileInfo(c,script);
+var e=BuildCodeInfoTree(d);
+var g=new PosTranslator(diff_array);
+MarkChangedFunctions(e,g.GetChunks());
+FindLiveSharedInfos(e,script);
+var h;
+try{
+h=GatherCompileInfo(new_source,script);
+}catch(e){
+var i=
+new Failure("Failed to compile new version of script: "+e);
+if(e instanceof SyntaxError){
+var j={
+type:"liveedit_compile_error",
+syntaxErrorMessage:e.message
+};
+CopyErrorPositionToDetails(e,j);
+i.details=j;
+}
+throw i;
+}
+var k=BuildCodeInfoTree(h);
+FindCorrespondingFunctions(e,k);
+var l=new Array();
+var m=new Array();
+var n=new Array();
+var o=new Array();
+function HarvestTodo(p){
+function CollectDamaged(q){
+m.push(q);
+for(var r=0;r<q.children.length;r++){
+CollectDamaged(q.children[r]);
+}
+}
+function CollectNew(t){
+for(var r=0;r<t.length;r++){
+n.push(t[r]);
+CollectNew(t[r].children);
+}
+}
+if(p.status==a.DAMAGED){
+CollectDamaged(p);
+return;
+}
+if(p.status==a.UNCHANGED){
+o.push(p);
+}else if(p.status==a.SOURCE_CHANGED){
+o.push(p);
+}else if(p.status==a.CHANGED){
+l.push(p);
+CollectNew(p.unmatched_new_nodes);
+}
+for(var r=0;r<p.children.length;r++){
+HarvestTodo(p.children[r]);
+}
+}
+var u={
+change_tree:DescribeChangeTree(e),
+textual_diff:{
+old_len:c.length,
+new_len:new_source.length,
+chunks:diff_array
+},
+updated:false
+};
+if(preview_only){
+return u;
+}
+HarvestTodo(e);
+var v=new Array();
+for(var r=0;r<l.length;r++){
+var w=
+l[r].live_shared_function_infos;
+if(w){
+for(var x=0;x<w.length;x++){
+v.push(w[x]);
+}
+}
+}
+var y=
+CheckStackActivations(v,change_log);
+u.stack_modified=y!=0;
+u[b]=
+u.stack_modified;
+var z=TemporaryRemoveBreakPoints(script,change_log);
+var A;
+if(m.length==0){
+%LiveEditReplaceScript(script,new_source,null);
+A=(void 0);
+}else{
+var B=CreateNameForOldScript(script);
+A=%LiveEditReplaceScript(script,new_source,
+B);
+var C=new Array();
+change_log.push({linked_to_old_script:C});
+for(var r=0;r<m.length;r++){
+LinkToOldScript(m[r],A,
+C);
+}
+u.created_script_name=B;
+}
+for(var r=0;r<n.length;r++){
+%LiveEditFunctionSetScript(
+n[r].info.shared_function_info,script);
+}
+for(var r=0;r<l.length;r++){
+PatchFunctionCode(l[r],change_log);
+}
+var D=new Array();
+change_log.push({position_patched:D});
+for(var r=0;r<o.length;r++){
+PatchPositions(o[r],diff_array,
+D);
+if(o[r].live_shared_function_infos){
+o[r].live_shared_function_infos.
+forEach(function(E){
+%LiveEditFunctionSourceUpdated(E.raw_array);
+});
+}
+}
+z(g,A);
+u.updated=true;
+return u;
+}
+this.ApplyPatchMultiChunk=ApplyPatchMultiChunk;
+function GatherCompileInfo(F,G){
+var H=%LiveEditGatherCompileInfo(G,F);
+var I=new Array();
+var J=new Array();
+for(var r=0;r<H.length;r++){
+var E=new FunctionCompileInfo(H[r]);
+%LiveEditFunctionSetScript(E.shared_function_info,(void 0));
+I.push(E);
+J.push(r);
+}
+for(var r=0;r<I.length;r++){
+var K=r;
+for(var x=r+1;x<I.length;x++){
+if(I[K].start_position>I[x].start_position){
+K=x;
+}
+}
+if(K!=r){
+var L=I[K];
+var M=J[K];
+I[K]=I[r];
+J[K]=J[r];
+I[r]=L;
+J[r]=M;
+}
+}
+var N=0;
+function ResetIndexes(O,P){
+var Q=-1;
+while(N<I.length&&
+I[N].outer_index==P){
+var R=N;
+I[R].outer_index=O;
+if(Q!=-1){
+I[Q].next_sibling_index=R;
+}
+Q=R;
+N++;
+ResetIndexes(R,J[R]);
+}
+if(Q!=-1){
+I[Q].next_sibling_index=-1;
+}
+}
+ResetIndexes(-1,-1);
+Assert(N==I.length);
+return I;
+}
+function PatchFunctionCode(p,S){
+var T=p.corresponding_node.info;
+if(p.live_shared_function_infos){
+p.live_shared_function_infos.forEach(function(U){
+%LiveEditReplaceFunctionCode(T.raw_array,
+U.raw_array);
+for(var r=0;r<p.children.length;r++){
+if(p.children[r].corresponding_node){
+var V=
+p.children[r].corresponding_node.info.
+shared_function_info;
+if(p.children[r].live_shared_function_infos){
+p.children[r].live_shared_function_infos.
+forEach(function(W){
+%LiveEditReplaceRefToNestedFunction(
+U.info,
+V,
+W.info);
+});
+}
+}
+}
+});
+S.push({function_patched:T.function_name});
+}else{
+S.push({function_patched:T.function_name,
+function_info_not_found:true});
+}
+}
+function LinkToOldScript(X,A,Y){
+if(X.live_shared_function_infos){
+X.live_shared_function_infos.
+forEach(function(E){
+%LiveEditFunctionSetScript(E.info,A);
+});
+Y.push({name:X.info.function_name});
+}else{
+Y.push(
+{name:X.info.function_name,not_found:true});
+}
+}
+function TemporaryRemoveBreakPoints(Z,S){
+var aa=GetScriptBreakPoints(Z);
+var ab=[];
+S.push({break_points_update:ab});
+var ac=[];
+for(var r=0;r<aa.length;r++){
+var ad=aa[r];
+ad.clear();
+var ae=Debug.findScriptSourcePosition(Z,
+ad.line(),ad.column());
+var af={
+position:ae,
+line:ad.line(),
+column:ad.column()
+};
+ac.push(af);
+}
+return function(g,ag){
+for(var r=0;r<aa.length;r++){
+var ad=aa[r];
+if(ag){
+var ah=ad.cloneForOtherScript(ag);
+ah.set(ag);
+ab.push({
+type:"copied_to_old",
+id:ad.number(),
+new_id:ah.number(),
+positions:ac[r]
+});
+}
+var ai=g.Translate(
+ac[r].position,
+PosTranslator.ShiftWithTopInsideChunkHandler);
+var aj=
+Z.locationFromPosition(ai,false);
+ad.update_positions(aj.line,aj.column);
+var ak={
+position:ai,
+line:aj.line,
+column:aj.column
+};
+ad.set(Z);
+ab.push({type:"position_changed",
+id:ad.number(),
+old_positions:ac[r],
+new_positions:ak
+});
+}
+};
+}
+function Assert(al,am){
+if(!al){
+if(am){
+throw"Assert "+am;
+}else{
+throw"Assert";
+}
+}
+}
+function DiffChunk(an,ao,ap,aq){
+this.pos1=an;
+this.pos2=ao;
+this.len1=ap;
+this.len2=aq;
+}
+function PosTranslator(ar){
+var as=new Array();
+var at=0;
+for(var r=0;r<ar.length;r+=3){
+var au=ar[r];
+var av=au+at;
+var aw=ar[r+1];
+var ax=ar[r+2];
+as.push(new DiffChunk(au,av,aw-au,
+ax-av));
+at=ax-aw;
+}
+this.chunks=as;
+}
+PosTranslator.prototype.GetChunks=function(){
+return this.chunks;
+};
+PosTranslator.prototype.Translate=function(ay,az){
+var aA=this.chunks;
+if(aA.length==0||ay<aA[0].pos1){
+return ay;
+}
+var aB=0;
+var aC=aA.length-1;
+while(aB<aC){
+var aD=Math.floor((aB+aC)/2);
+if(ay<aA[aD+1].pos1){
+aC=aD;
+}else{
+aB=aD+1;
+}
+}
+var aE=aA[aB];
+if(ay>=aE.pos1+aE.len1){
+return ay+aE.pos2+aE.len2-aE.pos1-aE.len1;
+}
+if(!az){
+az=PosTranslator.DefaultInsideChunkHandler;
+}
+return az(ay,aE);
+};
+PosTranslator.DefaultInsideChunkHandler=function(ay,aF){
+Assert(false,"Cannot translate position in changed area");
+};
+PosTranslator.ShiftWithTopInsideChunkHandler=
+function(ay,aF){
+return ay-aF.pos1+aF.pos2;
+};
+var a={
+UNCHANGED:"unchanged",
+SOURCE_CHANGED:"source changed",
+CHANGED:"changed",
+DAMAGED:"damaged"
+};
+function CodeInfoTreeNode(aG,aH,aI){
+this.info=aG;
+this.children=aH;
+this.array_index=aI;
+this.parent=(void 0);
+this.status=a.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(aJ){
+var aK=0;
+function BuildNode(){
+var aL=aK;
+aK++;
+var aM=new Array();
+while(aK<aJ.length&&
+aJ[aK].outer_index==aL){
+aM.push(BuildNode());
+}
+var q=new CodeInfoTreeNode(aJ[aL],aM,
+aL);
+for(var r=0;r<aM.length;r++){
+aM[r].parent=q;
+}
+return q;
+}
+var aN=BuildNode();
+Assert(aK==aJ.length);
+return aN;
+}
+function MarkChangedFunctions(aO,as){
+var aP=new function(){
+var aQ=0;
+var aR=0;
+this.current=function(){return as[aQ];};
+this.next=function(){
+var aE=as[aQ];
+aR=aE.pos2+aE.len2-(aE.pos1+aE.len1);
+aQ++;
+};
+this.done=function(){return aQ>=as.length;};
+this.TranslatePos=function(ay){return ay+aR;};
+};
+function ProcessInternals(aS){
+aS.new_start_pos=aP.TranslatePos(
+aS.info.start_position);
+var aT=0;
+var aU=false;
+var aV=false;
+while(!aP.done()&&
+aP.current().pos1<aS.info.end_position){
+if(aT<aS.children.length){
+var aW=aS.children[aT];
+if(aW.info.end_position<=aP.current().pos1){
+ProcessUnchangedChild(aW);
+aT++;
+continue;
+}else if(aW.info.start_position>=
+aP.current().pos1+aP.current().len1){
+aU=true;
+aP.next();
+continue;
+}else if(aW.info.start_position<=aP.current().pos1&&
+aW.info.end_position>=aP.current().pos1+
+aP.current().len1){
+ProcessInternals(aW);
+aV=aV||
+(aW.status!=a.UNCHANGED);
+aU=aU||
+(aW.status==a.DAMAGED);
+aT++;
+continue;
+}else{
+aU=true;
+aW.status=a.DAMAGED;
+aW.status_explanation=
+"Text diff overlaps with function boundary";
+aT++;
+continue;
+}
+}else{
+if(aP.current().pos1+aP.current().len1<=
+aS.info.end_position){
+aS.status=a.CHANGED;
+aP.next();
+continue;
+}else{
+aS.status=a.DAMAGED;
+aS.status_explanation=
+"Text diff overlaps with function boundary";
+return;
+}
+}
+Assert("Unreachable",false);
+}
+while(aT<aS.children.length){
+var aW=aS.children[aT];
+ProcessUnchangedChild(aW);
+aT++;
+}
+if(aU){
+aS.status=a.CHANGED;
+}else if(aV){
+aS.status=a.SOURCE_CHANGED;
+}
+aS.new_end_pos=
+aP.TranslatePos(aS.info.end_position);
+}
+function ProcessUnchangedChild(q){
+q.new_start_pos=aP.TranslatePos(q.info.start_position);
+q.new_end_pos=aP.TranslatePos(q.info.end_position);
+}
+ProcessInternals(aO);
+}
+function FindCorrespondingFunctions(aX,aY){
+function ProcessNode(p,aZ){
+var ba=
+IsFunctionContextLocalsChanged(p.info,aZ.info);
+if(ba){
+p.status=a.CHANGED;
+}
+var bb=p.children;
+var bc=aZ.children;
+var bd=[];
+var be=[];
+var bf=0;
+var bg=0;
+while(bf<bb.length){
+if(bb[bf].status==a.DAMAGED){
+bf++;
+}else if(bg<bc.length){
+if(bc[bg].info.start_position<
+bb[bf].new_start_pos){
+bd.push(bc[bg]);
+be.push(bc[bg]);
+bg++;
+}else if(bc[bg].info.start_position==
+bb[bf].new_start_pos){
+if(bc[bg].info.end_position==
+bb[bf].new_end_pos){
+bb[bf].corresponding_node=
+bc[bg];
+bb[bf].textual_corresponding_node=
+bc[bg];
+if(ba){
+bb[bf].status=a.DAMAGED;
+bb[bf].status_explanation=
+"Enclosing function is now incompatible. "+
+ba;
+bb[bf].corresponding_node=(void 0);
+}else if(bb[bf].status!=
+a.UNCHANGED){
+ProcessNode(bb[bf],
+bc[bg]);
+if(bb[bf].status==a.DAMAGED){
+bd.push(
+bb[bf].corresponding_node);
+bb[bf].corresponding_node=(void 0);
+p.status=a.CHANGED;
+}
+}
+}else{
+bb[bf].status=a.DAMAGED;
+bb[bf].status_explanation=
+"No corresponding function in new script found";
+p.status=a.CHANGED;
+bd.push(bc[bg]);
+be.push(bc[bg]);
+}
+bg++;
+bf++;
+}else{
+bb[bf].status=a.DAMAGED;
+bb[bf].status_explanation=
+"No corresponding function in new script found";
+p.status=a.CHANGED;
+bf++;
+}
+}else{
+bb[bf].status=a.DAMAGED;
+bb[bf].status_explanation=
+"No corresponding function in new script found";
+p.status=a.CHANGED;
+bf++;
+}
+}
+while(bg<bc.length){
+bd.push(bc[bg]);
+be.push(bc[bg]);
+bg++;
+}
+if(p.status==a.CHANGED){
+if(p.info.param_num!=aZ.info.param_num){
+p.status=a.DAMAGED;
+p.status_explanation="Changed parameter number: "+
+p.info.param_num+" and "+aZ.info.param_num;
+}
+}
+p.unmatched_new_nodes=bd;
+p.textually_unmatched_new_nodes=
+be;
+}
+ProcessNode(aX,aY);
+aX.corresponding_node=aY;
+aX.textual_corresponding_node=aY;
+Assert(aX.status!=a.DAMAGED,
+"Script became damaged");
+}
+function FindLiveSharedInfos(aX,G){
+var bh=%LiveEditFindSharedFunctionInfosForScript(G);
+var bi=new Array();
+for(var r=0;r<bh.length;r++){
+bi.push(new SharedInfoWrapper(bh[r]));
+}
+function FindFunctionInfos(I){
+var bj=[];
+for(var r=0;r<bi.length;r++){
+var bk=bi[r];
+if(bk.start_position==I.start_position&&
+bk.end_position==I.end_position){
+bj.push(bk);
+}
+}
+if(bj.length>0){
+return bj;
+}
+}
+function TraverseTree(q){
+q.live_shared_function_infos=FindFunctionInfos(q.info);
+for(var r=0;r<q.children.length;r++){
+TraverseTree(q.children[r]);
+}
+}
+TraverseTree(aX);
+}
+function FunctionCompileInfo(bl){
+this.function_name=bl[0];
+this.start_position=bl[1];
+this.end_position=bl[2];
+this.param_num=bl[3];
+this.code=bl[4];
+this.code_scope_info=bl[5];
+this.scope_info=bl[6];
+this.outer_index=bl[7];
+this.shared_function_info=bl[8];
+this.next_sibling_index=null;
+this.raw_array=bl;
+}
+function SharedInfoWrapper(bl){
+this.function_name=bl[0];
+this.start_position=bl[1];
+this.end_position=bl[2];
+this.info=bl[3];
+this.raw_array=bl;
+}
+function PatchPositions(X,ar,Y){
+if(X.live_shared_function_infos){
+X.live_shared_function_infos.forEach(function(E){
+%LiveEditPatchFunctionPositions(E.raw_array,
+ar);
+});
+Y.push({name:X.info.function_name});
+}else{
+Y.push(
+{name:X.info.function_name,info_not_found:true});
+}
+}
+function CreateNameForOldScript(G){
+return G.name+" (old)";
+}
+function IsFunctionContextLocalsChanged(bm,bn){
+var bo=bm.scope_info;
+var bp=bn.scope_info;
+var bq;
+var br;
+if(bo){
+bq=bo.toString();
+}else{
+bq="";
+}
+if(bp){
+br=bp.toString();
+}else{
+br="";
+}
+if(bq!=br){
+return"Variable map changed: ["+bq+
+"] => ["+br+"]";
+}
+return;
+}
+var bs;
+function CheckStackActivations(bt,S){
+var bu=new Array();
+for(var r=0;r<bt.length;r++){
+bu[r]=bt[r].info;
+}
+var bv=%LiveEditCheckAndDropActivations(bu,true);
+if(bv[bu.length]){
+throw new Failure(bv[bu.length]);
+}
+var bw=new Array();
+var bx=new Array();
+for(var r=0;r<bu.length;r++){
+var by=bt[r];
+if(bv[r]==bs.REPLACED_ON_ACTIVE_STACK){
+bx.push({name:by.function_name});
+}else if(bv[r]!=bs.AVAILABLE_FOR_PATCH){
+var bz={
+name:by.function_name,
+start_pos:by.start_position,
+end_pos:by.end_position,
+replace_problem:
+bs.SymbolName(bv[r])
+};
+bw.push(bz);
+}
+}
+if(bx.length>0){
+S.push({dropped_from_stack:bx});
+}
+if(bw.length>0){
+S.push({functions_on_stack:bw});
+throw new Failure("Blocked by functions on stack");
+}
+return bx.length;
+}
+var bs={
+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
+};
+bs.SymbolName=function(bA){
+var bB=bs;
+for(var bC in bB){
+if(bB[bC]==bA){
+return bC;
+}
+}
+};
+function Failure(am){
+this.message=am;
+}
+this.Failure=Failure;
+Failure.prototype.toString=function(){
+return"LiveEdit Failure: "+this.message;
+};
+function CopyErrorPositionToDetails(bD,j){
+function createPositionStruct(G,bE){
+if(bE==-1)return;
+var bF=G.locationFromPosition(bE,true);
+if(bF==null)return;
+return{
+line:bF.line+1,
+column:bF.column+1,
+position:bE
+};
+}
+if(!("scriptObject"in bD)||!("startPosition"in bD)){
+return;
+}
+var G=bD.scriptObject;
+var bG={
+start:createPositionStruct(G,bD.startPosition),
+end:createPositionStruct(G,bD.endPosition)
+};
+j.position=bG;
+}
+function GetPcFromSourcePos(bH,bI){
+return %GetFunctionCodePositionFromSource(bH,bI);
+}
+this.GetPcFromSourcePos=GetPcFromSourcePos;
+function SetScriptSource(G,bJ,bK,S){
+var c=G.source;
+var bL=CompareStrings(c,bJ);
+return ApplyPatchMultiChunk(G,bL,bJ,bK,
+S);
+}
+this.SetScriptSource=SetScriptSource;
+function CompareStrings(bM,bN){
+return %LiveEditCompareStrings(bM,bN);
+}
+function ApplySingleChunkPatch(G,change_pos,change_len,new_str,
+S){
+var c=G.source;
+var bJ=c.substring(0,change_pos)+
+new_str+c.substring(change_pos+change_len);
+return ApplyPatchMultiChunk(G,
+[change_pos,change_pos+change_len,change_pos+new_str.length],
+bJ,false,S);
+}
+function DescribeChangeTree(aX){
+function ProcessOldNode(q){
+var bO=[];
+for(var r=0;r<q.children.length;r++){
+var aW=q.children[r];
+if(aW.status!=a.UNCHANGED){
+bO.push(ProcessOldNode(aW));
+}
+}
+var bP=[];
+if(q.textually_unmatched_new_nodes){
+for(var r=0;r<q.textually_unmatched_new_nodes.length;r++){
+var aW=q.textually_unmatched_new_nodes[r];
+bP.push(ProcessNewNode(aW));
+}
+}
+var bQ={
+name:q.info.function_name,
+positions:DescribePositions(q),
+status:q.status,
+children:bO,
+new_children:bP
+};
+if(q.status_explanation){
+bQ.status_explanation=q.status_explanation;
+}
+if(q.textual_corresponding_node){
+bQ.new_positions=DescribePositions(q.textual_corresponding_node);
+}
+return bQ;
+}
+function ProcessNewNode(q){
+var bO=[];
+if(false){
+for(var r=0;r<q.children.length;r++){
+bO.push(ProcessNewNode(q.children[r]));
+}
+}
+var bQ={
+name:q.info.function_name,
+positions:DescribePositions(q),
+children:bO,
+};
+return bQ;
+}
+function DescribePositions(q){
+return{
+start_position:q.info.start_position,
+end_position:q.info.end_position
+};
+}
+return ProcessOldNode(aX);
+}
+function RestartFrame(bR){
+var bv=bR.restart();
+if((typeof(bv)==='string')){
+throw new Failure("Failed to restart frame: "+bv);
+}
+var bv={};
+bv[b]=true;
+return bv;
+}
+this.RestartFrame=RestartFrame;
+this.TestApi={
+PosTranslator:PosTranslator,
+CompareStrings:CompareStrings,
+ApplySingleChunkPatch:ApplySingleChunkPatch
+};
+};
+
+`\1cruntimeyÄ
+var $Object=global.Object;
+var $Array=global.Array;
+var $String=global.String;
+var $Number=global.Number;
+var $Function=global.Function;
+var $Boolean=global.Boolean;
+var $NaN=%GetRootNaN();
+function EQUALS(a){
+if((typeof(this)==='string')&&(typeof(a)==='string'))return %StringEquals(this,a);
+var b=this;
+while(true){
+if((typeof(b)==='number')){
+while(true){
+if((typeof(a)==='number'))return %NumberEquals(b,a);
+if((a==null))return 1;
+if((typeof(a)==='symbol'))return 1;
+if(!(%_IsSpecObject(a))){
+return %NumberEquals(b,%ToNumber(a));
+}
+a=%ToPrimitive(a,0);
+}
+}else if((typeof(b)==='string')){
+while(true){
+if((typeof(a)==='string'))return %StringEquals(b,a);
+if((typeof(a)==='symbol'))return 1;
+if((typeof(a)==='number'))return %NumberEquals(%ToNumber(b),a);
+if((typeof(a)==='boolean'))return %NumberEquals(%ToNumber(b),%ToNumber(a));
+if((a==null))return 1;
+a=%ToPrimitive(a,0);
+}
+}else if((typeof(b)==='symbol')){
+if((typeof(a)==='symbol'))return %_ObjectEquals(b,a)?0:1;
+return 1;
+}else if((typeof(b)==='boolean')){
+if((typeof(a)==='boolean'))return %_ObjectEquals(b,a)?0:1;
+if((a==null))return 1;
+if((typeof(a)==='number'))return %NumberEquals(%ToNumber(b),a);
+if((typeof(a)==='string'))return %NumberEquals(%ToNumber(b),%ToNumber(a));
+if((typeof(a)==='symbol'))return 1;
+b=%ToNumber(b);
+a=%ToPrimitive(a,0);
+}else if((b==null)){
+return(a==null)?0:1;
+}else{
+if((%_IsSpecObject(a))){
+return %_ObjectEquals(b,a)?0:1;
+}
+if((a==null))return 1;
+if((typeof(a)==='symbol'))return 1;
+if((typeof(a)==='boolean'))a=%ToNumber(a);
+b=%ToPrimitive(b,0);
+}
+}
+}
+function STRICT_EQUALS(a){
+if((typeof(this)==='string')){
+if(!(typeof(a)==='string'))return 1;
+return %StringEquals(this,a);
+}
+if((typeof(this)==='number')){
+if(!(typeof(a)==='number'))return 1;
+return %NumberEquals(this,a);
+}
+return %_ObjectEquals(this,a)?0:1;
+}
+function COMPARE(a,b){
+var c;
+var d;
+if((typeof(this)==='string')){
+if((typeof(a)==='string'))return %_StringCompare(this,a);
+if((a===(void 0)))return b;
+c=this;
+}else if((typeof(this)==='number')){
+if((typeof(a)==='number'))return %NumberCompare(this,a,b);
+if((a===(void 0)))return b;
+c=this;
+}else if((this===(void 0))){
+if(!(a===(void 0))){
+%ToPrimitive(a,1);
+}
+return b;
+}else if((a===(void 0))){
+%ToPrimitive(this,1);
+return b;
+}else{
+c=%ToPrimitive(this,1);
+}
+d=%ToPrimitive(a,1);
+if((typeof(c)==='string')&&(typeof(d)==='string')){
+return %_StringCompare(c,d);
+}else{
+var e=%ToNumber(c);
+var g=%ToNumber(d);
+if((!%_IsSmi(%IS_VAR(e))&&!(e==e))||(!%_IsSmi(%IS_VAR(g))&&!(g==g)))return b;
+return %NumberCompare(e,g,b);
+}
+}
+function ADD(a){
+if((typeof(this)==='number')&&(typeof(a)==='number'))return %NumberAdd(this,a);
+if((typeof(this)==='string')&&(typeof(a)==='string'))return %_StringAdd(this,a);
+var b=%ToPrimitive(this,0);
+var c=%ToPrimitive(a,0);
+if((typeof(b)==='string')){
+return %_StringAdd(b,%ToString(c));
+}else if((typeof(c)==='string')){
+return %_StringAdd(%NonStringToString(b),c);
+}else{
+return %NumberAdd(%ToNumber(b),%ToNumber(c));
+}
+}
+function STRING_ADD_LEFT(a){
+if(!(typeof(a)==='string')){
+if((%_ClassOf(a)==='String')&&%_IsStringWrapperSafeForDefaultValueOf(a)){
+a=%_ValueOf(a);
+}else{
+a=(typeof(a)==='number')
+?%_NumberToString(a)
+:%ToString(%ToPrimitive(a,0));
+}
+}
+return %_StringAdd(this,a);
+}
+function STRING_ADD_RIGHT(a){
+var b=this;
+if(!(typeof(b)==='string')){
+if((%_ClassOf(b)==='String')&&%_IsStringWrapperSafeForDefaultValueOf(b)){
+b=%_ValueOf(b);
+}else{
+b=(typeof(b)==='number')
+?%_NumberToString(b)
+:%ToString(%ToPrimitive(b,0));
+}
+}
+return %_StringAdd(b,a);
+}
+function SUB(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberSub(b,a);
+}
+function MUL(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberMul(b,a);
+}
+function DIV(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberDiv(b,a);
+}
+function MOD(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberMod(b,a);
+}
+function BIT_OR(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberOr(b,a);
+}
+function BIT_AND(a){
+var b;
+if((typeof(this)==='number')){
+b=this;
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+}else{
+b=%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+if((!%_IsSmi(%IS_VAR(b))&&!(b==b)))return 0;
+}
+return %NumberAnd(b,a);
+}
+function BIT_XOR(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberXor(b,a);
+}
+function SHL(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberShl(b,a);
+}
+function SAR(a){
+var b;
+if((typeof(this)==='number')){
+b=this;
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+}else{
+b=%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+if((!%_IsSmi(%IS_VAR(b))&&!(b==b)))return 0;
+}
+return %NumberSar(b,a);
+}
+function SHR(a){
+var b=(typeof(this)==='number')?this:%NonNumberToNumber(this);
+if(!(typeof(a)==='number'))a=%NonNumberToNumber(a);
+return %NumberShr(b,a);
+}
+function DELETE(a,b){
+return %DeleteProperty(%ToObject(this),%ToName(a),b);
+}
+function IN(a){
+if(!(%_IsSpecObject(a))){
+throw %MakeTypeError(11,this,a);
+}
+if(%_IsNonNegativeSmi(this)){
+if((%_IsArray(a))&&%_HasFastPackedElements(a)){
+return this<a.length;
+}
+return %HasElement(a,this);
+}
+return %HasProperty(a,%ToName(this));
+}
+function INSTANCE_OF(a){
+var b=this;
+if(!(%_ClassOf(a)==='Function')){
+throw %MakeTypeError(9,a);
+}
+if(!(%_IsSpecObject(b))){
+return 1;
+}
+var c=%BoundFunctionGetBindings(a);
+if(c){
+a=c[0];
+}
+var d=a.prototype;
+if(!(%_IsSpecObject(d))){
+throw %MakeTypeError(10,d);
+}
+return %IsInPrototypeChain(d,b)?0:1;
+}
+function FILTER_KEY(a){
+var b=%ToName(a);
+if(%HasProperty(this,b))return b;
+return 0;
+}
+function CALL_NON_FUNCTION(){
+var a=%GetFunctionDelegate(this);
+if(!(%_IsFunction(a))){
+var b=%RenderCallSite();
+if(b=="")b=typeof this;
+throw %MakeTypeError(2,b);
+}
+return %Apply(a,this,arguments,0,%_ArgumentsLength());
+}
+function CALL_NON_FUNCTION_AS_CONSTRUCTOR(){
+var a=%GetConstructorDelegate(this);
+if(!(%_IsFunction(a))){
+var b=%RenderCallSite();
+if(b=="")b=typeof this;
+throw %MakeTypeError(2,b);
+}
+return %Apply(a,this,arguments,0,%_ArgumentsLength());
+}
+function CALL_FUNCTION_PROXY(){
+var a=%_ArgumentsLength()-1;
+var b=%_Arguments(a);
+var c=%GetCallTrap(b);
+return %Apply(c,this,arguments,0,a);
+}
+function CALL_FUNCTION_PROXY_AS_CONSTRUCTOR(){
+var a=this;
+var b=%GetConstructTrap(a);
+return %Apply(b,this,arguments,0,%_ArgumentsLength());
+}
+function APPLY_PREPARE(a){
+var b;
+if((%_IsArray(a))){
+b=a.length;
+if(%_IsSmi(b)&&b>=0&&b<0x800000&&
+(%_ClassOf(this)==='Function')){
+return b;
+}
+}
+b=(a==null)?0:%ToUint32(a.length);
+if(b>0x800000)throw %MakeRangeError(39);
+if(!(%_ClassOf(this)==='Function')){
+throw %MakeTypeError(1,%ToString(this),typeof this);
+}
+if(a!=null&&!(%_IsSpecObject(a))){
+throw %MakeTypeError(36,"Function.prototype.apply");
+}
+return b;
+}
+function REFLECT_APPLY_PREPARE(a){
+var b;
+if((%_IsArray(a))){
+b=a.length;
+if(%_IsSmi(b)&&b>=0&&b<0x800000&&
+(%_ClassOf(this)==='Function')){
+return b;
+}
+}
+if(!(%_ClassOf(this)==='Function')){
+throw %MakeTypeError(2,%ToString(this));
+}
+if(!(%_IsSpecObject(a))){
+throw %MakeTypeError(36,"Reflect.apply");
+}
+b=%ToLength(a.length);
+if(b>0x800000)throw %MakeRangeError(39);
+return b;
+}
+function REFLECT_CONSTRUCT_PREPARE(a,b){
+var c;
+var d=(%_ClassOf(this)==='Function')&&%IsConstructor(this);
+var e=(%_ClassOf(b)==='Function')&&%IsConstructor(b);
+if((%_IsArray(a))){
+c=a.length;
+if(%_IsSmi(c)&&c>=0&&c<0x800000&&
+d&&e){
+return c;
+}
+}
+if(!d){
+if(!(%_ClassOf(this)==='Function')){
+throw %MakeTypeError(2,%ToString(this));
+}else{
+throw %MakeTypeError(13,%ToString(this));
+}
+}
+if(!e){
+if(!(%_ClassOf(b)==='Function')){
+throw %MakeTypeError(2,%ToString(b));
+}else{
+throw %MakeTypeError(13,%ToString(b));
+}
+}
+if(!(%_IsSpecObject(a))){
+throw %MakeTypeError(36,"Reflect.construct");
+}
+c=%ToLength(a.length);
+if(c>0x800000)throw %MakeRangeError(39);
+return c;
+}
+function STACK_OVERFLOW(a){
+throw %MakeRangeError(39);
+}
+function TO_OBJECT(){
+return %ToObject(this);
+}
+function TO_NUMBER(){
+return %ToNumber(this);
+}
+function TO_STRING(){
+return %ToString(this);
+}
+function TO_NAME(){
+return %ToName(this);
+}
+function ToPrimitive(a,b){
+if((typeof(a)==='string'))return a;
+if(!(%_IsSpecObject(a)))return a;
+if((%_ClassOf(a)==='Symbol'))throw MakeTypeError(30);
+if(b==0)b=((%_ClassOf(a)==='Date'))?2:1;
+return(b==1)?%DefaultNumber(a):%DefaultString(a);
+}
+function ToBoolean(a){
+if((typeof(a)==='boolean'))return a;
+if((typeof(a)==='string'))return a.length!=0;
+if(a==null)return false;
+if((typeof(a)==='number'))return!((a==0)||(!%_IsSmi(%IS_VAR(a))&&!(a==a)));
+return true;
+}
+function ToNumber(a){
+if((typeof(a)==='number'))return a;
+if((typeof(a)==='string')){
+return %_HasCachedArrayIndex(a)?%_GetCachedArrayIndex(a)
+:%StringToNumber(a);
+}
+if((typeof(a)==='boolean'))return a?1:0;
+if((a===(void 0)))return $NaN;
+if((typeof(a)==='symbol'))throw MakeTypeError(31);
+return((a===null))?0:ToNumber(%DefaultNumber(a));
+}
+function NonNumberToNumber(a){
+if((typeof(a)==='string')){
+return %_HasCachedArrayIndex(a)?%_GetCachedArrayIndex(a)
+:%StringToNumber(a);
+}
+if((typeof(a)==='boolean'))return a?1:0;
+if((a===(void 0)))return $NaN;
+if((typeof(a)==='symbol'))throw MakeTypeError(31);
+return((a===null))?0:ToNumber(%DefaultNumber(a));
+}
+function ToString(a){
+if((typeof(a)==='string'))return a;
+if((typeof(a)==='number'))return %_NumberToString(a);
+if((typeof(a)==='boolean'))return a?'true':'false';
+if((a===(void 0)))return'undefined';
+if((typeof(a)==='symbol'))throw %MakeTypeError(32);
+return((a===null))?'null':%ToString(%DefaultString(a));
+}
+function NonStringToString(a){
+if((typeof(a)==='number'))return %_NumberToString(a);
+if((typeof(a)==='boolean'))return a?'true':'false';
+if((a===(void 0)))return'undefined';
+if((typeof(a)==='symbol'))throw %MakeTypeError(32);
+return((a===null))?'null':%ToString(%DefaultString(a));
+}
+function ToName(a){
+return(typeof(a)==='symbol')?a:%ToString(a);
+}
+function ToObject(a){
+if((typeof(a)==='string'))return new $String(a);
+if((typeof(a)==='number'))return new $Number(a);
+if((typeof(a)==='boolean'))return new $Boolean(a);
+if((typeof(a)==='symbol'))return %NewSymbolWrapper(a);
+if((a==null)&&!(%_IsUndetectableObject(a))){
+throw %MakeTypeError(33);
+}
+return a;
+}
+function ToInteger(a){
+if(%_IsSmi(a))return a;
+return %NumberToInteger(ToNumber(a));
+}
+function ToLength(a){
+a=ToInteger(a);
+if(a<0)return 0;
+return a<$Number.MAX_SAFE_INTEGER?a:$Number.MAX_SAFE_INTEGER;
+}
+function ToUint32(a){
+if(%_IsSmi(a)&&a>=0)return a;
+return %NumberToJSUint32(ToNumber(a));
+}
+function ToInt32(a){
+if(%_IsSmi(a))return a;
+return %NumberToJSInt32(ToNumber(a));
+}
+function SameValue(a,b){
+if(typeof a!=typeof b)return false;
+if((typeof(a)==='number')){
+if((!%_IsSmi(%IS_VAR(a))&&!(a==a))&&(!%_IsSmi(%IS_VAR(b))&&!(b==b)))return true;
+if(a===0&&b===0&&%_IsMinusZero(a)!=%_IsMinusZero(b)){
+return false;
+}
+}
+return a===b;
+}
+function SameValueZero(a,b){
+if(typeof a!=typeof b)return false;
+if((typeof(a)==='number')){
+if((!%_IsSmi(%IS_VAR(a))&&!(a==a))&&(!%_IsSmi(%IS_VAR(b))&&!(b==b)))return true;
+}
+return a===b;
+}
+function IsPrimitive(a){
+return!(%_IsSpecObject(a));
+}
+function IsConcatSpreadable(a){
+if(!(%_IsSpecObject(a)))return false;
+var b=a[symbolIsConcatSpreadable];
+if((b===(void 0)))return(%_IsArray(a));
+return ToBoolean(b);
+}
+function DefaultNumber(a){
+if(!(%_ClassOf(a)==='Symbol')){
+var b=a.valueOf;
+if((%_ClassOf(b)==='Function')){
+var c=%_CallFunction(a,b);
+if(%IsPrimitive(c))return c;
+}
+var d=a.toString;
+if((%_ClassOf(d)==='Function')){
+var e=%_CallFunction(a,d);
+if(%IsPrimitive(e))return e;
+}
+}
+throw %MakeTypeError(4);
+}
+function DefaultString(a){
+if(!(%_ClassOf(a)==='Symbol')){
+var b=a.toString;
+if((%_ClassOf(b)==='Function')){
+var c=%_CallFunction(a,b);
+if(%IsPrimitive(c))return c;
+}
+var d=a.valueOf;
+if((%_ClassOf(d)==='Function')){
+var e=%_CallFunction(a,d);
+if(%IsPrimitive(e))return e;
+}
+}
+throw %MakeTypeError(4);
+}
+function ToPositiveInteger(a,b){
+var c=(%_IsSmi(%IS_VAR(a))?a:%NumberToIntegerMapMinusZero(ToNumber(a)));
+if(c<0)throw MakeRangeError(b);
+return c;
+}
+%FunctionSetPrototype($Array,new $Array(0));
+function STRING_LENGTH_STUB(a){
+var b=this;
+return %_StringGetLength(%_JSValueGetValue(b));
+}
+
+$v8nativesbè\ 1
+var $isNaN=GlobalIsNaN;
+var $isFinite=GlobalIsFinite;
+function InstallFunctions(a,b,c){
+if(c.length>=8){
+%OptimizeObjectForAddingMultipleProperties(a,c.length>>1);
+}
+for(var d=0;d<c.length;d+=2){
+var e=c[d];
+var g=c[d+1];
+%FunctionSetName(g,e);
+%FunctionRemovePrototype(g);
+%AddNamedProperty(a,e,g,b);
+%SetNativeFlag(g);
+}
+%ToFastProperties(a);
+}
+function OverrideFunction(a,b,c){
+ObjectDefineProperty(a,b,{value:c,
+writeable:true,
+configurable:true,
+enumerable:false});
+%FunctionSetName(c,b);
+%FunctionRemovePrototype(c);
+%SetNativeFlag(c);
+}
+function InstallGetter(a,b,c,d){
+if(typeof d=="undefined"){
+d=2;
+}
+%FunctionSetName(c,b);
+%FunctionRemovePrototype(c);
+%DefineAccessorPropertyUnchecked(a,b,c,null,d);
+%SetNativeFlag(c);
+}
+function InstallGetterSetter(a,b,c,d){
+%FunctionSetName(c,b);
+%FunctionSetName(d,b);
+%FunctionRemovePrototype(c);
+%FunctionRemovePrototype(d);
+%DefineAccessorPropertyUnchecked(a,b,c,d,2);
+%SetNativeFlag(c);
+%SetNativeFlag(d);
+}
+function InstallConstants(a,b){
+if(b.length>=4){
+%OptimizeObjectForAddingMultipleProperties(a,b.length>>1);
+}
+var c=2|4|1;
+for(var d=0;d<b.length;d+=2){
+var e=b[d];
+var g=b[d+1];
+%AddNamedProperty(a,e,g,c);
+}
+%ToFastProperties(a);
+}
+function SetUpLockedPrototype(a,b,c){
+%CheckIsBootstrapping();
+var d=a.prototype;
+var e=(c.length>>1)+(b?b.length:0);
+if(e>=4){
+%OptimizeObjectForAddingMultipleProperties(d,e);
+}
+if(b){
+for(var g=0;g<b.length;g++){
+%AddNamedProperty(d,b[g],
+(void 0),2|4);
+}
+}
+for(var g=0;g<c.length;g+=2){
+var h=c[g];
+var i=c[g+1];
+%AddNamedProperty(d,h,i,2|4|1);
+%SetNativeFlag(i);
+}
+%InternalSetPrototype(d,null);
+%ToFastProperties(d);
+}
+function GlobalIsNaN(a){
+if(!(typeof(a)==='number'))a=NonNumberToNumber(a);
+return(!%_IsSmi(%IS_VAR(a))&&!(a==a));
+}
+function GlobalIsFinite(a){
+if(!(typeof(a)==='number'))a=NonNumberToNumber(a);
+return(%_IsSmi(%IS_VAR(a))||((a==a)&&(a!=1/0)&&(a!=-1/0)));
+}
+function GlobalParseInt(a,b){
+if((b===(void 0))||b===10||b===0){
+if(%_IsSmi(a))return a;
+if((typeof(a)==='number')&&
+((0.01<a&&a<1e9)||
+(-1e9<a&&a<-0.01))){
+return a|0;
+}
+a=((typeof(%IS_VAR(a))==='string')?a:NonStringToString(a));
+b=b|0;
+}else{
+a=((typeof(%IS_VAR(a))==='string')?a:NonStringToString(a));
+b=(%_IsSmi(%IS_VAR(b))?b:(b>>0));
+if(!(b==0||(2<=b&&b<=36))){
+return $NaN;
+}
+}
+if(%_HasCachedArrayIndex(a)&&
+(b==0||b==10)){
+return %_GetCachedArrayIndex(a);
+}
+return %StringParseInt(a,b);
+}
+function GlobalParseFloat(a){
+a=((typeof(%IS_VAR(a))==='string')?a:NonStringToString(a));
+if(%_HasCachedArrayIndex(a))return %_GetCachedArrayIndex(a);
+return %StringParseFloat(a);
+}
+function GlobalEval(a){
+if(!(typeof(a)==='string'))return a;
+var b=%GlobalProxy(global);
+var c=%CompileString(a,false);
+if(!(%_IsFunction(c)))return c;
+return %_CallFunction(b,c);
+}
+function SetUpGlobal(){
+%CheckIsBootstrapping();
+var a=2|4|1;
+%AddNamedProperty(global,"NaN",$NaN,a);
+%AddNamedProperty(global,"Infinity",(1/0),a);
+%AddNamedProperty(global,"undefined",(void 0),a);
+InstallFunctions(global,2,[
+"isNaN",GlobalIsNaN,
+"isFinite",GlobalIsFinite,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat,
+"eval",GlobalEval
+]);
+}
+SetUpGlobal();
+function NoSideEffectsObjectToString(){
+if((this===(void 0))&&!(%_IsUndetectableObject(this)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+return"[object "+%_ClassOf(((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this)))+"]";
+}
+function ObjectToString(){
+if((this===(void 0))&&!(%_IsUndetectableObject(this)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+var a=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var b=%_ClassOf(a);
+var c;
+if(harmony_tostring){
+var c=a[symbolToStringTag];
+if(!(typeof(c)==='string')){
+c=b;
+}
+}else{
+c=b;
+}
+return`[object ${c}]`;
+}
+function ObjectToLocaleString(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Object.prototype.toLocaleString"]);
+return this.toString();
+}
+function ObjectValueOf(){
+return((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+}
+function ObjectHasOwnProperty(a){
+if(%_IsJSProxy(this)){
+if((typeof(a)==='symbol'))return false;
+var b=%GetHandler(this);
+return CallTrap1(b,"hasOwn",$proxyDerivedHasOwnTrap,ToName(a));
+}
+return %HasOwnProperty(((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this)),ToName(a));
+}
+function ObjectIsPrototypeOf(a){
+if(!(%_IsSpecObject(a)))return false;
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Object.prototype.isPrototypeOf"]);
+return %IsInPrototypeChain(this,a);
+}
+function ObjectPropertyIsEnumerable(a){
+var b=ToName(a);
+if(%_IsJSProxy(this)){
+if((typeof(a)==='symbol'))return false;
+var c=GetOwnPropertyJS(this,b);
+return(c===(void 0))?false:c.isEnumerable();
+}
+return %IsPropertyEnumerable(((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this)),b);
+}
+function ObjectDefineGetter(a,b){
+var c=this;
+if(c==null&&!(%_IsUndetectableObject(c))){
+c=%GlobalProxy(global);
+}
+if(!(%_ClassOf(b)==='Function')){
+throw MakeTypeError(16);
+}
+var d=new PropertyDescriptor();
+d.setGet(b);
+d.setEnumerable(true);
+d.setConfigurable(true);
+DefineOwnProperty(((%_IsSpecObject(%IS_VAR(c)))?c:ToObject(c)),ToName(a),d,false);
+}
+function ObjectLookupGetter(a){
+var b=this;
+if(b==null&&!(%_IsUndetectableObject(b))){
+b=%GlobalProxy(global);
+}
+return %LookupAccessor(((%_IsSpecObject(%IS_VAR(b)))?b:ToObject(b)),ToName(a),0);
+}
+function ObjectDefineSetter(a,b){
+var c=this;
+if(c==null&&!(%_IsUndetectableObject(c))){
+c=%GlobalProxy(global);
+}
+if(!(%_ClassOf(b)==='Function')){
+throw MakeTypeError(18);
+}
+var d=new PropertyDescriptor();
+d.setSet(b);
+d.setEnumerable(true);
+d.setConfigurable(true);
+DefineOwnProperty(((%_IsSpecObject(%IS_VAR(c)))?c:ToObject(c)),ToName(a),d,false);
+}
+function ObjectLookupSetter(a){
+var b=this;
+if(b==null&&!(%_IsUndetectableObject(b))){
+b=%GlobalProxy(global);
+}
+return %LookupAccessor(((%_IsSpecObject(%IS_VAR(b)))?b:ToObject(b)),ToName(a),1);
+}
+function ObjectKeys(a){
+a=((%_IsSpecObject(%IS_VAR(a)))?a:ToObject(a));
+if(%_IsJSProxy(a)){
+var b=%GetHandler(a);
+var c=CallTrap0(b,"keys",$proxyDerivedKeysTrap);
+return ToNameArray(c,"keys",false);
+}
+return %OwnKeys(a);
+}
+function IsAccessorDescriptor(a){
+if((a===(void 0)))return false;
+return a.hasGetter()||a.hasSetter();
+}
+function IsDataDescriptor(a){
+if((a===(void 0)))return false;
+return a.hasValue()||a.hasWritable();
+}
+function IsGenericDescriptor(a){
+if((a===(void 0)))return false;
+return!(IsAccessorDescriptor(a)||IsDataDescriptor(a));
+}
+function IsInconsistentDescriptor(a){
+return IsAccessorDescriptor(a)&&IsDataDescriptor(a);
+}
+function FromPropertyDescriptor(a){
+if((a===(void 0)))return a;
+if(IsDataDescriptor(a)){
+return{value:a.getValue(),
+writable:a.isWritable(),
+enumerable:a.isEnumerable(),
+configurable:a.isConfigurable()};
+}
+return{get:a.getGet(),
+set:a.getSet(),
+enumerable:a.isEnumerable(),
+configurable:a.isConfigurable()};
+}
+function FromGenericPropertyDescriptor(a){
+if((a===(void 0)))return a;
+var b=new $Object();
+if(a.hasValue()){
+%AddNamedProperty(b,"value",a.getValue(),0);
+}
+if(a.hasWritable()){
+%AddNamedProperty(b,"writable",a.isWritable(),0);
+}
+if(a.hasGetter()){
+%AddNamedProperty(b,"get",a.getGet(),0);
+}
+if(a.hasSetter()){
+%AddNamedProperty(b,"set",a.getSet(),0);
+}
+if(a.hasEnumerable()){
+%AddNamedProperty(b,"enumerable",a.isEnumerable(),0);
+}
+if(a.hasConfigurable()){
+%AddNamedProperty(b,"configurable",a.isConfigurable(),0);
+}
+return b;
+}
+function ToPropertyDescriptor(a){
+if(!(%_IsSpecObject(a)))throw MakeTypeError(20,a);
+var b=new PropertyDescriptor();
+if("enumerable"in a){
+b.setEnumerable(ToBoolean(a.enumerable));
+}
+if("configurable"in a){
+b.setConfigurable(ToBoolean(a.configurable));
+}
+if("value"in a){
+b.setValue(a.value);
+}
+if("writable"in a){
+b.setWritable(ToBoolean(a.writable));
+}
+if("get"in a){
+var c=a.get;
+if(!(c===(void 0))&&!(%_ClassOf(c)==='Function')){
+throw MakeTypeError(17,c);
+}
+b.setGet(c);
+}
+if("set"in a){
+var d=a.set;
+if(!(d===(void 0))&&!(%_ClassOf(d)==='Function')){
+throw MakeTypeError(19,d);
+}
+b.setSet(d);
+}
+if(IsInconsistentDescriptor(b)){
+throw MakeTypeError(34,a);
+}
+return b;
+}
+function ToCompletePropertyDescriptor(a){
+var b=ToPropertyDescriptor(a);
+if(IsGenericDescriptor(b)||IsDataDescriptor(b)){
+if(!b.hasValue())b.setValue((void 0));
+if(!b.hasWritable())b.setWritable(false);
+}else{
+if(!b.hasGetter())b.setGet((void 0));
+if(!b.hasSetter())b.setSet((void 0));
+}
+if(!b.hasEnumerable())b.setEnumerable(false);
+if(!b.hasConfigurable())b.setConfigurable(false);
+return b;
+}
+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;
+}
+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(a){
+this.value_=a;
+this.hasValue_=true;
+},
+"getValue",function PropertyDescriptor_GetValue(){
+return this.value_;
+},
+"hasValue",function PropertyDescriptor_HasValue(){
+return this.hasValue_;
+},
+"setEnumerable",function PropertyDescriptor_SetEnumerable(a){
+this.enumerable_=a;
+this.hasEnumerable_=true;
+},
+"isEnumerable",function PropertyDescriptor_IsEnumerable(){
+return this.enumerable_;
+},
+"hasEnumerable",function PropertyDescriptor_HasEnumerable(){
+return this.hasEnumerable_;
+},
+"setWritable",function PropertyDescriptor_SetWritable(a){
+this.writable_=a;
+this.hasWritable_=true;
+},
+"isWritable",function PropertyDescriptor_IsWritable(){
+return this.writable_;
+},
+"hasWritable",function PropertyDescriptor_HasWritable(){
+return this.hasWritable_;
+},
+"setConfigurable",
+function PropertyDescriptor_SetConfigurable(a){
+this.configurable_=a;
+this.hasConfigurable_=true;
+},
+"hasConfigurable",function PropertyDescriptor_HasConfigurable(){
+return this.hasConfigurable_;
+},
+"isConfigurable",function PropertyDescriptor_IsConfigurable(){
+return this.configurable_;
+},
+"setGet",function PropertyDescriptor_SetGetter(a){
+this.get_=a;
+this.hasGetter_=true;
+},
+"getGet",function PropertyDescriptor_GetGetter(){
+return this.get_;
+},
+"hasGetter",function PropertyDescriptor_HasGetter(){
+return this.hasGetter_;
+},
+"setSet",function PropertyDescriptor_SetSetter(a){
+this.set_=a;
+this.hasSetter_=true;
+},
+"getSet",function PropertyDescriptor_GetSetter(){
+return this.set_;
+},
+"hasSetter",function PropertyDescriptor_HasSetter(){
+return this.hasSetter_;
+}
+]);
+function ConvertDescriptorArrayToDescriptor(a){
+if((a===(void 0))){
+return(void 0);
+}
+var b=new PropertyDescriptor();
+if(a[0]){
+b.setGet(a[2]);
+b.setSet(a[3]);
+}else{
+b.setValue(a[1]);
+b.setWritable(a[4]);
+}
+b.setEnumerable(a[5]);
+b.setConfigurable(a[6]);
+return b;
+}
+function GetTrap(a,b,c){
+var d=a[b];
+if((d===(void 0))){
+if((c===(void 0))){
+throw MakeTypeError(24,a,b);
+}
+d=c;
+}else if(!(%_ClassOf(d)==='Function')){
+throw MakeTypeError(25,a,b);
+}
+return d;
+}
+function CallTrap0(a,b,c){
+return %_CallFunction(a,GetTrap(a,b,c));
+}
+function CallTrap1(a,b,c,d){
+return %_CallFunction(a,d,GetTrap(a,b,c));
+}
+function CallTrap2(a,b,c,d,e){
+return %_CallFunction(a,d,e,GetTrap(a,b,c));
+}
+function GetOwnPropertyJS(a,b){
+var c=ToName(b);
+if(%_IsJSProxy(a)){
+if((typeof(b)==='symbol'))return(void 0);
+var d=%GetHandler(a);
+var e=CallTrap1(
+d,"getOwnPropertyDescriptor",(void 0),c);
+if((e===(void 0)))return e;
+var g=ToCompletePropertyDescriptor(e);
+if(!g.isConfigurable()){
+throw MakeTypeError(28,
+d,c,"getOwnPropertyDescriptor");
+}
+return g;
+}
+var h=%GetOwnProperty(((%_IsSpecObject(%IS_VAR(a)))?a:ToObject(a)),c);
+return ConvertDescriptorArrayToDescriptor(h);
+}
+function Delete(a,b,c){
+var d=GetOwnPropertyJS(a,b);
+if((d===(void 0)))return true;
+if(d.isConfigurable()){
+%DeleteProperty(a,b,0);
+return true;
+}else if(c){
+throw MakeTypeError(5,b);
+}else{
+return;
+}
+}
+function GetMethod(a,b){
+var c=a[b];
+if((c==null))return(void 0);
+if((%_ClassOf(c)==='Function'))return c;
+throw MakeTypeError(2,typeof c);
+}
+function DefineProxyProperty(a,b,c,d){
+if((typeof(b)==='symbol'))return false;
+var e=%GetHandler(a);
+var g=CallTrap2(e,"defineProperty",(void 0),b,c);
+if(!ToBoolean(g)){
+if(d){
+throw MakeTypeError(23,
+e,"false","defineProperty");
+}else{
+return false;
+}
+}
+return true;
+}
+function DefineObjectProperty(a,b,c,d){
+var e=%GetOwnProperty(a,ToName(b));
+var g=ConvertDescriptorArrayToDescriptor(e);
+var h=%IsExtensible(a);
+if((g===(void 0))&&!h){
+if(d){
+throw MakeTypeError(5,b);
+}else{
+return false;
+}
+}
+if(!(g===(void 0))){
+if((IsGenericDescriptor(c)||
+IsDataDescriptor(c)==IsDataDescriptor(g))&&
+(!c.hasEnumerable()||
+SameValue(c.isEnumerable(),g.isEnumerable()))&&
+(!c.hasConfigurable()||
+SameValue(c.isConfigurable(),g.isConfigurable()))&&
+(!c.hasWritable()||
+SameValue(c.isWritable(),g.isWritable()))&&
+(!c.hasValue()||
+SameValue(c.getValue(),g.getValue()))&&
+(!c.hasGetter()||
+SameValue(c.getGet(),g.getGet()))&&
+(!c.hasSetter()||
+SameValue(c.getSet(),g.getSet()))){
+return true;
+}
+if(!g.isConfigurable()){
+if(c.isConfigurable()||
+(c.hasEnumerable()&&
+c.isEnumerable()!=g.isEnumerable())){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+if(!IsGenericDescriptor(c)){
+if(IsDataDescriptor(g)!=IsDataDescriptor(c)){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+if(IsDataDescriptor(g)&&IsDataDescriptor(c)){
+if(!g.isWritable()&&c.isWritable()){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+if(!g.isWritable()&&c.hasValue()&&
+!SameValue(c.getValue(),g.getValue())){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+}
+if(IsAccessorDescriptor(c)&&IsAccessorDescriptor(g)){
+if(c.hasSetter()&&!SameValue(c.getSet(),g.getSet())){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+if(c.hasGetter()&&!SameValue(c.getGet(),g.getGet())){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+}
+}
+}
+}
+var i=0;
+if(c.hasEnumerable()){
+i|=c.isEnumerable()?0:2;
+}else if(!(g===(void 0))){
+i|=g.isEnumerable()?0:2;
+}else{
+i|=2;
+}
+if(c.hasConfigurable()){
+i|=c.isConfigurable()?0:4;
+}else if(!(g===(void 0))){
+i|=g.isConfigurable()?0:4;
+}else
+i|=4;
+if(IsDataDescriptor(c)||
+(IsGenericDescriptor(c)&&
+((g===(void 0))||IsDataDescriptor(g)))){
+if(c.hasWritable()){
+i|=c.isWritable()?0:1;
+}else if(!(g===(void 0))){
+i|=g.isWritable()?0:1;
+}else{
+i|=1;
+}
+var j=(void 0);
+if(c.hasValue()){
+j=c.getValue();
+}else if(!(g===(void 0))&&IsDataDescriptor(g)){
+j=g.getValue();
+}
+%DefineDataPropertyUnchecked(a,b,j,i);
+}else{
+var k=null;
+if(c.hasGetter()){
+k=c.getGet();
+}else if(IsAccessorDescriptor(g)&&g.hasGetter()){
+k=g.getGet();
+}
+var l=null;
+if(c.hasSetter()){
+l=c.getSet();
+}else if(IsAccessorDescriptor(g)&&g.hasSetter()){
+l=g.getSet();
+}
+%DefineAccessorPropertyUnchecked(a,b,k,l,i);
+}
+return true;
+}
+function DefineArrayProperty(a,b,c,d){
+if(b==="length"){
+var e=a.length;
+var g=e;
+if(!c.hasValue()){
+return DefineObjectProperty(a,"length",c,d);
+}
+var h=ToUint32(c.getValue());
+if(h!=ToNumber(c.getValue())){
+throw MakeRangeError(37);
+}
+var i=GetOwnPropertyJS(a,"length");
+if(h!=e&&!i.isWritable()){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+var j=false;
+var k=%IsObserved(a)&&h!==g;
+var l;
+if(k){
+$observeBeginPerformSplice(a);
+l=[];
+if(h<g)
+l.length=g-h;
+}
+while(h<e--){
+var m=ToString(e);
+if(k){
+var n=GetOwnPropertyJS(a,m);
+if(n&&n.hasValue())
+l[e-h]=n.getValue();
+}
+if(!Delete(a,m,false)){
+h=e+1;
+j=true;
+break;
+}
+}
+j=!DefineObjectProperty(a,"length",c,d)||j;
+if(k){
+$observeEndPerformSplice(a);
+$observeEnqueueSpliceRecord(a,
+h<g?h:g,
+l,
+h>g?h-g:0);
+}
+if(j){
+if(d){
+throw MakeTypeError(29,b);
+}else{
+return false;
+}
+}
+return true;
+}
+if(!(typeof(b)==='symbol')){
+var m=ToUint32(b);
+var k=false;
+if(ToString(m)==b&&m!=4294967295){
+var e=a.length;
+if(m>=e&&%IsObserved(a)){
+k=true;
+$observeBeginPerformSplice(a);
+}
+var i=GetOwnPropertyJS(a,"length");
+if((m>=e&&!i.isWritable())||
+!DefineObjectProperty(a,b,c,true)){
+if(k)
+$observeEndPerformSplice(a);
+if(d){
+throw MakeTypeError(5,b);
+}else{
+return false;
+}
+}
+if(m>=e){
+a.length=m+1;
+}
+if(k){
+$observeEndPerformSplice(a);
+$observeEnqueueSpliceRecord(a,e,[],m+1-e);
+}
+return true;
+}
+}
+return DefineObjectProperty(a,b,c,d);
+}
+function DefineOwnProperty(a,b,c,d){
+if(%_IsJSProxy(a)){
+if((typeof(b)==='symbol'))return false;
+var e=FromGenericPropertyDescriptor(c);
+return DefineProxyProperty(a,b,e,d);
+}else if((%_IsArray(a))){
+return DefineArrayProperty(a,b,c,d);
+}else{
+return DefineObjectProperty(a,b,c,d);
+}
+}
+function ObjectGetPrototypeOf(a){
+return %_GetPrototype(((%_IsSpecObject(%IS_VAR(a)))?a:ToObject(a)));
+}
+function ObjectSetPrototypeOf(a,b){
+if((a==null)&&!(%_IsUndetectableObject(a)))throw MakeTypeError('called_on_null_or_undefined',["Object.setPrototypeOf"]);
+if(b!==null&&!(%_IsSpecObject(b))){
+throw MakeTypeError(22,b);
+}
+if((%_IsSpecObject(a))){
+%SetPrototype(a,b);
+}
+return a;
+}
+function ObjectGetOwnPropertyDescriptor(a,b){
+var c=GetOwnPropertyJS(((%_IsSpecObject(%IS_VAR(a)))?a:ToObject(a)),b);
+return FromPropertyDescriptor(c);
+}
+function ToNameArray(a,b,c){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(26,b,a);
+}
+var d=ToUint32(a.length);
+var e=new $Array(d);
+var g=0;
+var h={__proto__:null};
+for(var i=0;i<d;i++){
+var j=ToName(a[i]);
+if((typeof(j)==='symbol')&&!c)continue;
+if(%HasOwnProperty(h,j)){
+throw MakeTypeError(27,b,j);
+}
+e[i]=j;
+++g;
+h[j]=0;
+}
+e.length=g;
+return e;
+}
+function ObjectGetOwnPropertyKeys(a,b){
+var c=new InternalArray();
+b|=32;
+var d=%GetInterceptorInfo(a);
+if((b&8)===0){
+var e=%GetOwnElementNames(a);
+for(var g=0;g<e.length;++g){
+e[g]=%_NumberToString(e[g]);
+}
+c.push(e);
+if((d&1)!=0){
+var h=%GetIndexedInterceptorElementNames(a);
+if(!(h===(void 0))){
+c.push(h);
+}
+}
+}
+c.push(%GetOwnPropertyNames(a,b));
+if((d&2)!=0){
+var i=
+%GetNamedInterceptorPropertyNames(a);
+if(!(i===(void 0))){
+c.push(i);
+}
+}
+var j=
+%Apply(InternalArray.prototype.concat,
+c[0],c,1,c.length-1);
+if(d!=0){
+var k={__proto__:null};
+var l=0;
+for(var g=0;g<j.length;++g){
+var m=j[g];
+if((typeof(m)==='symbol')){
+if((b&16)||(%SymbolIsPrivate(m))){
+continue;
+}
+}else{
+if(b&8)continue;
+m=ToString(m);
+}
+if(k[m])continue;
+k[m]=true;
+j[l++]=m;
+}
+j.length=l;
+}
+return j;
+}
+function ObjectGetOwnPropertyNames(a){
+a=((%_IsSpecObject(%IS_VAR(a)))?a:ToObject(a));
+if(%_IsJSProxy(a)){
+var b=%GetHandler(a);
+var c=CallTrap0(b,"getOwnPropertyNames",(void 0));
+return ToNameArray(c,"getOwnPropertyNames",false);
+}
+return ObjectGetOwnPropertyKeys(a,16);
+}
+function ObjectCreate(a,b){
+if(!(%_IsSpecObject(a))&&a!==null){
+throw MakeTypeError(22,a);
+}
+var c={};
+%InternalSetPrototype(c,a);
+if(!(b===(void 0)))ObjectDefineProperties(c,b);
+return c;
+}
+function ObjectDefineProperty(a,b,c){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.defineProperty");
+}
+var d=ToName(b);
+if(%_IsJSProxy(a)){
+var e={__proto__:null};
+for(var g in c){
+e[g]=c[g];
+}
+DefineProxyProperty(a,d,e,true);
+}else{
+var h=ToPropertyDescriptor(c);
+DefineOwnProperty(a,d,h,true);
+}
+return a;
+}
+function GetOwnEnumerablePropertyNames(a){
+var b=new InternalArray();
+for(var c in a){
+if(%HasOwnProperty(a,c)){
+b.push(c);
+}
+}
+var d=8|32;
+var e=%GetOwnPropertyNames(a,d);
+for(var g=0;g<e.length;++g){
+var h=e[g];
+if((typeof(h)==='symbol')){
+var i=ObjectGetOwnPropertyDescriptor(a,h);
+if(i.enumerable)b.push(h);
+}
+}
+return b;
+}
+function ObjectDefineProperties(a,b){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.defineProperties");
+}
+var c=((%_IsSpecObject(%IS_VAR(b)))?b:ToObject(b));
+var d=GetOwnEnumerablePropertyNames(c);
+var e=new InternalArray();
+for(var g=0;g<d.length;g++){
+e.push(ToPropertyDescriptor(c[d[g]]));
+}
+for(var g=0;g<d.length;g++){
+DefineOwnProperty(a,d[g],e[g],true);
+}
+return a;
+}
+function ProxyFix(a){
+var b=%GetHandler(a);
+var c=CallTrap0(b,"fix",(void 0));
+if((c===(void 0))){
+throw MakeTypeError(23,b,"undefined","fix");
+}
+if(%IsJSFunctionProxy(a)){
+var d=%GetCallTrap(a);
+var e=%GetConstructTrap(a);
+var g=$proxyDelegateCallAndConstruct(d,e);
+%Fix(a);
+%SetCode(a,g);
+var h=new $Object();
+$Object.defineProperty(h,"constructor",
+{value:a,writable:true,enumerable:false,configurable:true});
+%FunctionSetPrototype(a,h);
+a.length=0;
+}else{
+%Fix(a);
+}
+ObjectDefineProperties(a,c);
+}
+function ObjectSealJS(a){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.seal");
+}
+var b=%_IsJSProxy(a);
+if(b||%HasSloppyArgumentsElements(a)||%IsObserved(a)){
+if(b){
+ProxyFix(a);
+}
+var c=ObjectGetOwnPropertyNames(a);
+for(var d=0;d<c.length;d++){
+var e=c[d];
+var g=GetOwnPropertyJS(a,e);
+if(g.isConfigurable()){
+g.setConfigurable(false);
+DefineOwnProperty(a,e,g,true);
+}
+}
+%PreventExtensions(a);
+}else{
+%ObjectSeal(a);
+}
+return a;
+}
+function ObjectFreezeJS(a){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.freeze");
+}
+var b=%_IsJSProxy(a);
+if(b||%HasSloppyArgumentsElements(a)||%IsObserved(a)){
+if(b){
+ProxyFix(a);
+}
+var c=ObjectGetOwnPropertyNames(a);
+for(var d=0;d<c.length;d++){
+var e=c[d];
+var g=GetOwnPropertyJS(a,e);
+if(g.isWritable()||g.isConfigurable()){
+if(IsDataDescriptor(g))g.setWritable(false);
+g.setConfigurable(false);
+DefineOwnProperty(a,e,g,true);
+}
+}
+%PreventExtensions(a);
+}else{
+%ObjectFreeze(a);
+}
+return a;
+}
+function ObjectPreventExtension(a){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.preventExtension");
+}
+if(%_IsJSProxy(a)){
+ProxyFix(a);
+}
+%PreventExtensions(a);
+return a;
+}
+function ObjectIsSealed(a){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.isSealed");
+}
+if(%_IsJSProxy(a)){
+return false;
+}
+if(%IsExtensible(a)){
+return false;
+}
+var b=ObjectGetOwnPropertyNames(a);
+for(var c=0;c<b.length;c++){
+var d=b[c];
+var e=GetOwnPropertyJS(a,d);
+if(e.isConfigurable()){
+return false;
+}
+}
+return true;
+}
+function ObjectIsFrozen(a){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.isFrozen");
+}
+if(%_IsJSProxy(a)){
+return false;
+}
+if(%IsExtensible(a)){
+return false;
+}
+var b=ObjectGetOwnPropertyNames(a);
+for(var c=0;c<b.length;c++){
+var d=b[c];
+var e=GetOwnPropertyJS(a,d);
+if(IsDataDescriptor(e)&&e.isWritable())return false;
+if(e.isConfigurable())return false;
+}
+return true;
+}
+function ObjectIsExtensible(a){
+if(!(%_IsSpecObject(a))){
+throw MakeTypeError(3,"Object.isExtensible");
+}
+if(%_IsJSProxy(a)){
+return true;
+}
+return %IsExtensible(a);
+}
+function ObjectIs(a,b){
+return SameValue(a,b);
+}
+function ObjectGetProto(){
+return %_GetPrototype(((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this)));
+}
+function ObjectSetProto(a){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Object.prototype.__proto__"]);
+if(((%_IsSpecObject(a))||(a===null))&&(%_IsSpecObject(this))){
+%SetPrototype(this,a);
+}
+}
+function ObjectConstructor(a){
+if(%_IsConstructCall()){
+if(a==null)return this;
+return((%_IsSpecObject(%IS_VAR(a)))?a:ToObject(a));
+}else{
+if(a==null)return{};
+return((%_IsSpecObject(%IS_VAR(a)))?a:ToObject(a));
+}
+}
+function SetUpObject(){
+%CheckIsBootstrapping();
+%SetNativeFlag($Object);
+%SetCode($Object,ObjectConstructor);
+%AddNamedProperty($Object.prototype,"constructor",$Object,2);
+InstallFunctions($Object.prototype,2,[
+"toString",ObjectToString,
+"toLocaleString",ObjectToLocaleString,
+"valueOf",ObjectValueOf,
+"hasOwnProperty",ObjectHasOwnProperty,
+"isPrototypeOf",ObjectIsPrototypeOf,
+"propertyIsEnumerable",ObjectPropertyIsEnumerable,
+"__defineGetter__",ObjectDefineGetter,
+"__lookupGetter__",ObjectLookupGetter,
+"__defineSetter__",ObjectDefineSetter,
+"__lookupSetter__",ObjectLookupSetter
+]);
+InstallGetterSetter($Object.prototype,"__proto__",
+ObjectGetProto,ObjectSetProto);
+InstallFunctions($Object,2,[
+"keys",ObjectKeys,
+"create",ObjectCreate,
+"defineProperty",ObjectDefineProperty,
+"defineProperties",ObjectDefineProperties,
+"freeze",ObjectFreezeJS,
+"getPrototypeOf",ObjectGetPrototypeOf,
+"setPrototypeOf",ObjectSetPrototypeOf,
+"getOwnPropertyDescriptor",ObjectGetOwnPropertyDescriptor,
+"getOwnPropertyNames",ObjectGetOwnPropertyNames,
+"is",ObjectIs,
+"isExtensible",ObjectIsExtensible,
+"isFrozen",ObjectIsFrozen,
+"isSealed",ObjectIsSealed,
+"preventExtensions",ObjectPreventExtension,
+"seal",ObjectSealJS
+]);
+}
+SetUpObject();
+function BooleanConstructor(a){
+if(%_IsConstructCall()){
+%_SetValueOf(this,ToBoolean(a));
+}else{
+return ToBoolean(a);
+}
+}
+function BooleanToString(){
+var a=this;
+if(!(typeof(a)==='boolean')){
+if(!(%_ClassOf(a)==='Boolean')){
+throw MakeTypeError(14,'Boolean.prototype.toString');
+}
+a=%_ValueOf(a);
+}
+return a?'true':'false';
+}
+function BooleanValueOf(){
+if(!(typeof(this)==='boolean')&&!(%_ClassOf(this)==='Boolean')){
+throw MakeTypeError(14,'Boolean.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function SetUpBoolean(){
+%CheckIsBootstrapping();
+%SetCode($Boolean,BooleanConstructor);
+%FunctionSetPrototype($Boolean,new $Boolean(false));
+%AddNamedProperty($Boolean.prototype,"constructor",$Boolean,2);
+InstallFunctions($Boolean.prototype,2,[
+"toString",BooleanToString,
+"valueOf",BooleanValueOf
+]);
+}
+SetUpBoolean();
+function NumberConstructor(a){
+var b=%_ArgumentsLength()==0?0:ToNumber(a);
+if(%_IsConstructCall()){
+%_SetValueOf(this,b);
+}else{
+return b;
+}
+}
+function NumberToStringJS(a){
+var b=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw MakeTypeError(14,'Number.prototype.toString');
+}
+b=%_ValueOf(this);
+}
+if((a===(void 0))||a===10){
+return %_NumberToString(b);
+}
+a=(%_IsSmi(%IS_VAR(a))?a:%NumberToInteger(ToNumber(a)));
+if(a<2||a>36){
+throw new $RangeError('toString() radix argument must be between 2 and 36');
+}
+return %NumberToRadixString(b,a);
+}
+function NumberToLocaleString(){
+return %_CallFunction(this,NumberToStringJS);
+}
+function NumberValueOf(){
+if(!(typeof(this)==='number')&&!(%_ClassOf(this)==='Number')){
+throw MakeTypeError(14,'Number.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function NumberToFixedJS(a){
+var b=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw MakeTypeError(8,
+"Number.prototype.toFixed",this);
+}
+b=%_ValueOf(this);
+}
+var c=(%_IsSmi(%IS_VAR(a))?a:%NumberToInteger(ToNumber(a)));
+if(c<0||c>20){
+throw MakeRangeError(38,"toFixed() digits");
+}
+if((!%_IsSmi(%IS_VAR(b))&&!(b==b)))return"NaN";
+if(b==(1/0))return"Infinity";
+if(b==-(1/0))return"-Infinity";
+return %NumberToFixed(b,c);
+}
+function NumberToExponentialJS(a){
+var b=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw MakeTypeError(8,
+"Number.prototype.toExponential",this);
+}
+b=%_ValueOf(this);
+}
+var c=(a===(void 0))?(void 0):(%_IsSmi(%IS_VAR(a))?a:%NumberToInteger(ToNumber(a)));
+if((!%_IsSmi(%IS_VAR(b))&&!(b==b)))return"NaN";
+if(b==(1/0))return"Infinity";
+if(b==-(1/0))return"-Infinity";
+if((c===(void 0))){
+c=-1;
+}else if(c<0||c>20){
+throw MakeRangeError(38,"toExponential()");
+}
+return %NumberToExponential(b,c);
+}
+function NumberToPrecisionJS(a){
+var b=this;
+if(!(typeof(this)==='number')){
+if(!(%_ClassOf(this)==='Number')){
+throw MakeTypeError(8,
+"Number.prototype.toPrecision",this);
+}
+b=%_ValueOf(this);
+}
+if((a===(void 0)))return ToString(%_ValueOf(this));
+var c=(%_IsSmi(%IS_VAR(a))?a:%NumberToInteger(ToNumber(a)));
+if((!%_IsSmi(%IS_VAR(b))&&!(b==b)))return"NaN";
+if(b==(1/0))return"Infinity";
+if(b==-(1/0))return"-Infinity";
+if(c<1||c>21){
+throw MakeRangeError(40);
+}
+return %NumberToPrecision(b,c);
+}
+function NumberIsFinite(a){
+return(typeof(a)==='number')&&(%_IsSmi(%IS_VAR(a))||((a==a)&&(a!=1/0)&&(a!=-1/0)));
+}
+function NumberIsInteger(a){
+return NumberIsFinite(a)&&(%_IsSmi(%IS_VAR(a))?a:%NumberToInteger(ToNumber(a)))==a;
+}
+function NumberIsNaN(a){
+return(typeof(a)==='number')&&(!%_IsSmi(%IS_VAR(a))&&!(a==a));
+}
+function NumberIsSafeInteger(a){
+if(NumberIsFinite(a)){
+var b=(%_IsSmi(%IS_VAR(a))?a:%NumberToInteger(ToNumber(a)));
+if(b==a)return $abs(b)<=$Number.MAX_SAFE_INTEGER;
+}
+return false;
+}
+function SetUpNumber(){
+%CheckIsBootstrapping();
+%SetCode($Number,NumberConstructor);
+%FunctionSetPrototype($Number,new $Number(0));
+%OptimizeObjectForAddingMultipleProperties($Number.prototype,8);
+%AddNamedProperty($Number.prototype,"constructor",$Number,2);
+InstallConstants($Number,[
+"MAX_VALUE",1.7976931348623157e+308,
+"MIN_VALUE",5e-324,
+"NaN",$NaN,
+"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)
+]);
+InstallFunctions($Number.prototype,2,[
+"toString",NumberToStringJS,
+"toLocaleString",NumberToLocaleString,
+"valueOf",NumberValueOf,
+"toFixed",NumberToFixedJS,
+"toExponential",NumberToExponentialJS,
+"toPrecision",NumberToPrecisionJS
+]);
+InstallFunctions($Number,2,[
+"isFinite",NumberIsFinite,
+"isInteger",NumberIsInteger,
+"isNaN",NumberIsNaN,
+"isSafeInteger",NumberIsSafeInteger,
+"parseInt",GlobalParseInt,
+"parseFloat",GlobalParseFloat
+]);
+%SetInlineBuiltinFlag(NumberIsNaN);
+}
+SetUpNumber();
+function FunctionSourceString(a){
+while(%IsJSFunctionProxy(a)){
+a=%GetCallTrap(a);
+}
+if(!(%_IsFunction(a))){
+throw MakeTypeError(14,'Function.prototype.toString');
+}
+var b=%ClassGetSourceCode(a);
+if((typeof(b)==='string')){
+return b;
+}
+var c=%FunctionGetSourceCode(a);
+if(!(typeof(c)==='string')||%FunctionIsBuiltin(a)){
+var d=%FunctionGetName(a);
+if(d){
+return'function '+d+'() { [native code] }';
+}else{
+return'function () { [native code] }';
+}
+}
+if(%FunctionIsArrow(a)){
+return c;
+}
+var d=%FunctionNameShouldPrintAsAnonymous(a)
+?'anonymous'
+:%FunctionGetName(a);
+var e=%FunctionIsGenerator(a);
+var g=%FunctionIsConciseMethod(a)
+?(e?'*':'')
+:(e?'function* ':'function ');
+return g+d+c;
+}
+function FunctionToString(){
+return FunctionSourceString(this);
+}
+function FunctionBind(a){
+if(!(%_ClassOf(this)==='Function'))throw MakeTypeError(7);
+var b=function(){
+"use strict";
+if(%_IsConstructCall()){
+return %NewObjectFromBound(b);
+}
+var c=%BoundFunctionGetBindings(b);
+var d=%_ArgumentsLength();
+if(d==0){
+return %Apply(c[0],c[1],c,2,c.length-2);
+}
+if(c.length===2){
+return %Apply(c[0],c[1],arguments,0,d);
+}
+var e=c.length-2;
+var g=new InternalArray(e+d);
+for(var h=0;h<e;h++){
+g[h]=c[h+2];
+}
+for(var i=0;i<d;i++){
+g[h++]=%_Arguments(i);
+}
+return %Apply(c[0],c[1],g,0,e+d);
+};
+var j=0;
+var k=this.length;
+if((typeof k==="number")&&
+((k>>>0)===k)){
+var d=%_ArgumentsLength();
+if(d>0)d--;
+j=k-d;
+if(j<0)j=0;
+}
+var l=%FunctionBindArguments(b,this,
+a,j);
+return l;
+}
+function NewFunctionString(a,b){
+var c=a.length;
+var d='';
+if(c>1){
+d=ToString(a[0]);
+for(var e=1;e<c-1;e++){
+d+=','+ToString(a[e]);
+}
+if(%_CallFunction(d,')',$stringIndexOf)!=-1){
+throw MakeSyntaxError(41);
+}
+d+='\n/'+'**/';
+}
+var g=(c>0)?ToString(a[c-1]):'';
+return'('+b+'('+d+') {\n'+g+'\n})';
+}
+function FunctionConstructor(a){
+var b=NewFunctionString(arguments,'function');
+var c=%GlobalProxy(global);
+var d=%_CallFunction(c,%CompileString(b,true));
+%FunctionMarkNameShouldPrintAsAnonymous(d);
+return d;
+}
+function SetUpFunction(){
+%CheckIsBootstrapping();
+%SetCode($Function,FunctionConstructor);
+%AddNamedProperty($Function.prototype,"constructor",$Function,2);
+InstallFunctions($Function.prototype,2,[
+"bind",FunctionBind,
+"toString",FunctionToString
+]);
+}
+SetUpFunction();
+function GetIterator(a,b){
+if((b===(void 0))){
+b=a[symbolIterator];
+}
+if(!(%_ClassOf(b)==='Function')){
+throw MakeTypeError(15,a);
+}
+var c=%_CallFunction(a,b);
+if(!(%_IsSpecObject(c))){
+throw MakeTypeError(12,c);
+}
+return c;
+}
+
+\18symbol\19
+var $symbolToString;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Object;
+var b=global.Symbol;
+function SymbolConstructor(c){
+if(%_IsConstructCall())throw MakeTypeError(13,"Symbol");
+return %CreateSymbol((c===(void 0))?c:ToString(c));
+}
+function SymbolToString(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw MakeTypeError(8,
+"Symbol.prototype.toString",this);
+}
+var d=%SymbolDescription(%_ValueOf(this));
+return"Symbol("+((d===(void 0))?"":d)+")";
+}
+function SymbolValueOf(){
+if(!((typeof(this)==='symbol')||(%_ClassOf(this)==='Symbol'))){
+throw MakeTypeError(8,
+"Symbol.prototype.valueOf",this);
+}
+return %_ValueOf(this);
+}
+function SymbolFor(e){
+e=((typeof(%IS_VAR(e))==='string')?e:NonStringToString(e));
+var g=%SymbolRegistry();
+if((g.for[e]===(void 0))){
+var h=%CreateSymbol(e);
+g.for[e]=h;
+g.keyFor[h]=e;
+}
+return g.for[e];
+}
+function SymbolKeyFor(h){
+if(!(typeof(h)==='symbol'))throw MakeTypeError("not_a_symbol",[h]);
+return %SymbolRegistry().keyFor[h];
+}
+function ObjectGetOwnPropertySymbols(i){
+i=ToObject(i);
+return ObjectGetOwnPropertyKeys(i,8);
+}
+%SetCode(b,SymbolConstructor);
+%FunctionSetPrototype(b,new a());
+InstallConstants(b,[
+"iterator",symbolIterator,
+"unscopables",symbolUnscopables
+]);
+InstallFunctions(b,2,[
+"for",SymbolFor,
+"keyFor",SymbolKeyFor
+]);
+%AddNamedProperty(
+b.prototype,"constructor",b,2);
+%AddNamedProperty(
+b.prototype,symbolToStringTag,"Symbol",2|1);
+InstallFunctions(b.prototype,2,[
+"toString",SymbolToString,
+"valueOf",SymbolValueOf
+]);
+InstallFunctions(a,2,[
+"getOwnPropertySymbols",ObjectGetOwnPropertySymbols
+]);
+$symbolToString=SymbolToString;
+})();
+
+\14array¾\85\ 1
+var $arrayConcat;
+var $arrayJoin;
+var $arrayPush;
+var $arrayPop;
+var $arrayShift;
+var $arraySlice;
+var $arraySplice;
+var $arrayUnshift;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Array;
+var b=new InternalArray();
+function GetSortedArrayKeys(c,d){
+var e=new InternalArray();
+if((typeof(d)==='number')){
+var g=d;
+for(var h=0;h<g;++h){
+var i=c[h];
+if(!(i===(void 0))||h in c){
+e.push(h);
+}
+}
+}else{
+var j=d.length;
+for(var k=0;k<j;++k){
+var l=d[k];
+if(!(l===(void 0))){
+var i=c[l];
+if(!(i===(void 0))||l in c){
+e.push(l);
+}
+}
+}
+%_CallFunction(e,function(m,n){return m-n;},ArraySort);
+}
+return e;
+}
+function SparseJoinWithSeparatorJS(c,o,q,r){
+var e=GetSortedArrayKeys(c,%GetArrayKeys(c,o));
+var t=0;
+var u=new InternalArray(e.length*2);
+var w=-1;
+for(var h=0;h<e.length;h++){
+var l=e[h];
+if(l!=w){
+var i=c[l];
+if(!(typeof(i)==='string'))i=q(i);
+u[h*2]=l;
+u[h*2+1]=i;
+w=l;
+}
+}
+return %SparseJoinWithSeparator(u,o,r);
+}
+function SparseJoin(c,o,q){
+var e=GetSortedArrayKeys(c,%GetArrayKeys(c,o));
+var z=-1;
+var A=e.length;
+var u=new InternalArray(A);
+var B=0;
+for(var h=0;h<A;h++){
+var l=e[h];
+if(l!=z){
+var i=c[l];
+if(!(typeof(i)==='string'))i=q(i);
+u[B++]=i;
+z=l;
+}
+}
+return %StringBuilderConcat(u,B,'');
+}
+function UseSparseVariant(c,j,C,D){
+if(!C||j<1000||%IsObserved(c)||
+%HasComplexElements(c)){
+return false;
+}
+if(!%_IsSmi(j)){
+return true;
+}
+var E=j>>2;
+var G=%EstimateNumberOfElements(c);
+return(G<E)&&
+(D>G*4);
+}
+function Join(c,j,r,q){
+if(j==0)return'';
+var C=(%_IsArray(c));
+if(C){
+if(!%PushIfAbsent(b,c))return'';
+}
+try{
+if(UseSparseVariant(c,j,C,j)){
+%NormalizeElements(c);
+if(r.length==0){
+return SparseJoin(c,j,q);
+}else{
+return SparseJoinWithSeparatorJS(c,j,q,r);
+}
+}
+if(j==1){
+var i=c[0];
+if((typeof(i)==='string'))return i;
+return q(i);
+}
+var u=new InternalArray(j);
+if(r.length==0){
+var B=0;
+for(var h=0;h<j;h++){
+var i=c[h];
+if(!(typeof(i)==='string'))i=q(i);
+u[B++]=i;
+}
+u.length=B;
+var H=%_FastOneByteArrayJoin(u,'');
+if(!(H===(void 0)))return H;
+return %StringBuilderConcat(u,B,'');
+}
+if(!(typeof(c[0])==='number')){
+for(var h=0;h<j;h++){
+var i=c[h];
+if(!(typeof(i)==='string'))i=q(i);
+u[h]=i;
+}
+}else{
+for(var h=0;h<j;h++){
+var i=c[h];
+if((typeof(i)==='number')){
+i=%_NumberToString(i);
+}else if(!(typeof(i)==='string')){
+i=q(i);
+}
+u[h]=i;
+}
+}
+var H=%_FastOneByteArrayJoin(u,r);
+if(!(H===(void 0)))return H;
+return %StringBuilderJoin(u,j,r);
+}finally{
+if(C)b.length=b.length-1;
+}
+}
+function ConvertToString(I){
+if((typeof(I)==='number'))return %_NumberToString(I);
+if((typeof(I)==='boolean'))return I?'true':'false';
+return((I==null))?'':%ToString(%DefaultString(I));
+}
+function ConvertToLocaleString(i){
+if((i==null)){
+return'';
+}else{
+var J=ToObject(i);
+return %ToString(J.toLocaleString());
+}
+}
+function SparseSlice(c,K,L,o,M){
+var d=%GetArrayKeys(c,K+L);
+if((typeof(d)==='number')){
+var g=d;
+for(var h=K;h<g;++h){
+var N=c[h];
+if(!(N===(void 0))||h in c){
+%AddElement(M,h-K,N,0);
+}
+}
+}else{
+var j=d.length;
+for(var k=0;k<j;++k){
+var l=d[k];
+if(!(l===(void 0))){
+if(l>=K){
+var N=c[l];
+if(!(N===(void 0))||l in c){
+%AddElement(M,l-K,N,0);
+}
+}
+}
+}
+}
+}
+function SparseMove(c,K,L,o,P){
+if(P===L)return;
+var Q=new InternalArray(
+$min(o-L+P,0xffffffff));
+var R;
+var d=%GetArrayKeys(c,o);
+if((typeof(d)==='number')){
+var g=d;
+for(var h=0;h<K&&h<g;++h){
+var N=c[h];
+if(!(N===(void 0))||h in c){
+Q[h]=N;
+}
+}
+for(var h=K+L;h<g;++h){
+var N=c[h];
+if(!(N===(void 0))||h in c){
+Q[h-L+P]=N;
+}
+}
+}else{
+var j=d.length;
+for(var k=0;k<j;++k){
+var l=d[k];
+if(!(l===(void 0))){
+if(l<K){
+var N=c[l];
+if(!(N===(void 0))||l in c){
+Q[l]=N;
+}
+}else if(l>=K+L){
+var N=c[l];
+if(!(N===(void 0))||l in c){
+var S=l-L+P;
+Q[S]=N;
+if(S>0xffffffff){
+R=R||new InternalArray();
+R.push(S);
+}
+}
+}
+}
+}
+}
+%MoveArrayContents(Q,c);
+if(!(R===(void 0))){
+var j=R.length;
+for(var h=0;h<j;++h){
+var l=R[h];
+c[l]=Q[l];
+}
+}
+}
+function SimpleSlice(c,K,L,o,M){
+var C=(%_IsArray(c));
+for(var h=0;h<L;h++){
+var T=K+h;
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(T<c.length):(T in c))){
+var N=c[T];
+%AddElement(M,h,N,0);
+}
+}
+}
+function SimpleMove(c,K,L,o,P){
+var C=(%_IsArray(c));
+if(P!==L){
+if(P>L){
+for(var h=o-L;h>K;h--){
+var U=h+L-1;
+var W=h+P-1;
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(U<c.length):(U in c))){
+c[W]=c[U];
+}else{
+delete c[W];
+}
+}
+}else{
+for(var h=K;h<o-L;h++){
+var U=h+L;
+var W=h+P;
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(U<c.length):(U in c))){
+c[W]=c[U];
+}else{
+delete c[W];
+}
+}
+for(var h=o;h>o-L+P;h--){
+delete c[h-1];
+}
+}
+}
+}
+function ArrayToString(){
+var c;
+var X;
+if((%_IsArray(this))){
+X=this.join;
+if(X===ArrayJoin){
+return Join(this,this.length,',',ConvertToString);
+}
+c=this;
+}else{
+c=ToObject(this);
+X=c.join;
+}
+if(!(%_ClassOf(X)==='Function')){
+return %_CallFunction(c,ObjectToString);
+}
+return %_CallFunction(c,X);
+}
+function ArrayToLocaleString(){
+var c=ToObject(this);
+var Y=c.length;
+var o=(Y>>>0);
+if(o===0)return"";
+return Join(c,o,',',ConvertToLocaleString);
+}
+function ArrayJoin(r){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.join"]);
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var j=(c.length>>>0);
+if((r===(void 0))){
+r=',';
+}else if(!(typeof(r)==='string')){
+r=NonStringToString(r);
+}
+var H=%_FastOneByteArrayJoin(c,r);
+if(!(H===(void 0)))return H;
+if(j===1){
+var i=c[0];
+if((typeof(i)==='string'))return i;
+if((i==null))return'';
+return NonStringToString(i);
+}
+return Join(c,j,r,ConvertToString);
+}
+function ObservedArrayPop(Z){
+Z--;
+var aa=this[Z];
+try{
+$observeBeginPerformSplice(this);
+delete this[Z];
+this.length=Z;
+}finally{
+$observeEndPerformSplice(this);
+$observeEnqueueSpliceRecord(this,Z,[aa],0);
+}
+return aa;
+}
+function ArrayPop(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.pop"]);
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var Z=(c.length>>>0);
+if(Z==0){
+c.length=Z;
+return;
+}
+if(%IsObserved(c))
+return ObservedArrayPop.call(c,Z);
+Z--;
+var aa=c[Z];
+Delete(c,ToName(Z),true);
+c.length=Z;
+return aa;
+}
+function ObservedArrayPush(){
+var Z=(this.length>>>0);
+var ab=%_ArgumentsLength();
+try{
+$observeBeginPerformSplice(this);
+for(var h=0;h<ab;h++){
+this[h+Z]=%_Arguments(h);
+}
+var ac=Z+ab;
+this.length=ac;
+}finally{
+$observeEndPerformSplice(this);
+$observeEnqueueSpliceRecord(this,Z,[],ab);
+}
+return ac;
+}
+function ArrayPush(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.push"]);
+if(%IsObserved(this))
+return ObservedArrayPush.apply(this,arguments);
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var Z=(c.length>>>0);
+var ab=%_ArgumentsLength();
+for(var h=0;h<ab;h++){
+c[h+Z]=%_Arguments(h);
+}
+var ac=Z+ab;
+c.length=ac;
+return ac;
+}
+function ArrayConcatJS(ad){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.concat"]);
+var c=ToObject(this);
+var ae=%_ArgumentsLength();
+var af=new InternalArray(1+ae);
+af[0]=c;
+for(var h=0;h<ae;h++){
+af[h+1]=%_Arguments(h);
+}
+return %ArrayConcat(af);
+}
+function SparseReverse(c,o){
+var e=GetSortedArrayKeys(c,%GetArrayKeys(c,o));
+var ag=e.length-1;
+var ah=0;
+while(ah<=ag){
+var h=e[ah];
+var ai=e[ag];
+var aj=o-ai-1;
+var ak,al;
+if(aj<=h){
+al=ai;
+while(e[--ag]==ai){}
+ak=aj;
+}
+if(aj>=h){
+ak=h;
+while(e[++ah]==h){}
+al=o-h-1;
+}
+var am=c[ak];
+if(!(am===(void 0))||ak in c){
+var an=c[al];
+if(!(an===(void 0))||al in c){
+c[ak]=an;
+c[al]=am;
+}else{
+c[al]=am;
+delete c[ak];
+}
+}else{
+var an=c[al];
+if(!(an===(void 0))||al in c){
+c[ak]=an;
+delete c[al];
+}
+}
+}
+}
+function ArrayReverse(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.reverse"]);
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var o=(c.length>>>0);
+if(UseSparseVariant(c,o,(%_IsArray(c)),o)){
+%NormalizeElements(c);
+SparseReverse(c,o);
+return c;
+}
+var ai=o-1;
+for(var h=0;h<ai;h++,ai--){
+var am=c[h];
+if(!(am===(void 0))||h in c){
+var an=c[ai];
+if(!(an===(void 0))||ai in c){
+c[h]=an;
+c[ai]=am;
+}else{
+c[ai]=am;
+delete c[h];
+}
+}else{
+var an=c[ai];
+if(!(an===(void 0))||ai in c){
+c[h]=an;
+delete c[ai];
+}
+}
+}
+return c;
+}
+function ObservedArrayShift(o){
+var ao=this[0];
+try{
+$observeBeginPerformSplice(this);
+SimpleMove(this,0,1,o,0);
+this.length=o-1;
+}finally{
+$observeEndPerformSplice(this);
+$observeEnqueueSpliceRecord(this,0,[ao],0);
+}
+return ao;
+}
+function ArrayShift(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.shift"]);
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var o=(c.length>>>0);
+if(o===0){
+c.length=0;
+return;
+}
+if(ObjectIsSealed(c)){
+throw MakeTypeError("array_functions_change_sealed",
+["Array.prototype.shift"]);
+}
+if(%IsObserved(c))
+return ObservedArrayShift.call(c,o);
+var ao=c[0];
+if(UseSparseVariant(c,o,(%_IsArray(c)),o)){
+SparseMove(c,0,1,o,0);
+}else{
+SimpleMove(c,0,1,o,0);
+}
+c.length=o-1;
+return ao;
+}
+function ObservedArrayUnshift(){
+var o=(this.length>>>0);
+var ap=%_ArgumentsLength();
+try{
+$observeBeginPerformSplice(this);
+SimpleMove(this,0,0,o,ap);
+for(var h=0;h<ap;h++){
+this[h]=%_Arguments(h);
+}
+var ac=o+ap;
+this.length=ac;
+}finally{
+$observeEndPerformSplice(this);
+$observeEnqueueSpliceRecord(this,0,[],ap);
+}
+return ac;
+}
+function ArrayUnshift(ad){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.unshift"]);
+if(%IsObserved(this))
+return ObservedArrayUnshift.apply(this,arguments);
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var o=(c.length>>>0);
+var ap=%_ArgumentsLength();
+if(o>0&&UseSparseVariant(c,o,(%_IsArray(c)),o)&&
+!ObjectIsSealed(c)){
+SparseMove(c,0,0,o,ap);
+}else{
+SimpleMove(c,0,0,o,ap);
+}
+for(var h=0;h<ap;h++){
+c[h]=%_Arguments(h);
+}
+var ac=o+ap;
+c.length=ac;
+return ac;
+}
+function ArraySlice(aq,ar){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.slice"]);
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var o=(c.length>>>0);
+var K=(%_IsSmi(%IS_VAR(aq))?aq:%NumberToInteger(ToNumber(aq)));
+var as=o;
+if(!(ar===(void 0)))as=(%_IsSmi(%IS_VAR(ar))?ar:%NumberToInteger(ToNumber(ar)));
+if(K<0){
+K+=o;
+if(K<0)K=0;
+}else{
+if(K>o)K=o;
+}
+if(as<0){
+as+=o;
+if(as<0)as=0;
+}else{
+if(as>o)as=o;
+}
+var H=[];
+if(as<K)return H;
+if(UseSparseVariant(c,o,(%_IsArray(c)),as-K)){
+%NormalizeElements(c);
+%NormalizeElements(H);
+SparseSlice(c,K,as-K,o,H);
+}else{
+SimpleSlice(c,K,as-K,o,H);
+}
+H.length=as-K;
+return H;
+}
+function ComputeSpliceStartIndex(K,o){
+if(K<0){
+K+=o;
+return K<0?0:K;
+}
+return K>o?o:K;
+}
+function ComputeSpliceDeleteCount(at,ap,o,K){
+var L=0;
+if(ap==1)
+return o-K;
+L=(%_IsSmi(%IS_VAR(at))?at:%NumberToInteger(ToNumber(at)));
+if(L<0)
+return 0;
+if(L>o-K)
+return o-K;
+return L;
+}
+function ObservedArraySplice(aq,at){
+var ap=%_ArgumentsLength();
+var o=(this.length>>>0);
+var K=ComputeSpliceStartIndex((%_IsSmi(%IS_VAR(aq))?aq:%NumberToInteger(ToNumber(aq))),o);
+var L=ComputeSpliceDeleteCount(at,ap,o,
+K);
+var M=[];
+M.length=L;
+var au=ap>2?ap-2:0;
+try{
+$observeBeginPerformSplice(this);
+SimpleSlice(this,K,L,o,M);
+SimpleMove(this,K,L,o,au);
+var h=K;
+var av=2;
+var aw=%_ArgumentsLength();
+while(av<aw){
+this[h++]=%_Arguments(av++);
+}
+this.length=o-L+au;
+}finally{
+$observeEndPerformSplice(this);
+if(M.length||au){
+$observeEnqueueSpliceRecord(this,
+K,
+M.slice(),
+au);
+}
+}
+return M;
+}
+function ArraySplice(aq,at){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.splice"]);
+if(%IsObserved(this))
+return ObservedArraySplice.apply(this,arguments);
+var ap=%_ArgumentsLength();
+var c=((%_IsSpecObject(%IS_VAR(this)))?this:ToObject(this));
+var o=(c.length>>>0);
+var K=ComputeSpliceStartIndex((%_IsSmi(%IS_VAR(aq))?aq:%NumberToInteger(ToNumber(aq))),o);
+var L=ComputeSpliceDeleteCount(at,ap,o,
+K);
+var M=[];
+M.length=L;
+var au=ap>2?ap-2:0;
+if(L!=au&&ObjectIsSealed(c)){
+throw MakeTypeError("array_functions_change_sealed",
+["Array.prototype.splice"]);
+}else if(L>0&&ObjectIsFrozen(c)){
+throw MakeTypeError("array_functions_on_frozen",
+["Array.prototype.splice"]);
+}
+var ax=L;
+if(au!=L){
+ax+=o-K-L;
+}
+if(UseSparseVariant(c,o,(%_IsArray(c)),ax)){
+%NormalizeElements(c);
+%NormalizeElements(M);
+SparseSlice(c,K,L,o,M);
+SparseMove(c,K,L,o,au);
+}else{
+SimpleSlice(c,K,L,o,M);
+SimpleMove(c,K,L,o,au);
+}
+var h=K;
+var av=2;
+var aw=%_ArgumentsLength();
+while(av<aw){
+c[h++]=%_Arguments(av++);
+}
+c.length=o-L+au;
+return M;
+}
+function ArraySort(ay){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.sort"]);
+if(!(%_ClassOf(ay)==='Function')){
+ay=function(I,az){
+if(I===az)return 0;
+if(%_IsSmi(I)&&%_IsSmi(az)){
+return %SmiLexicographicCompare(I,az);
+}
+I=ToString(I);
+az=ToString(az);
+if(I==az)return 0;
+else return I<az?-1:1;
+};
+}
+var aA=%GetDefaultReceiver(ay);
+var aB=function InsertionSort(m,aC,aD){
+for(var h=aC+1;h<aD;h++){
+var aE=m[h];
+for(var ai=h-1;ai>=aC;ai--){
+var aF=m[ai];
+var aG=%_CallFunction(aA,aF,aE,ay);
+if(aG>0){
+m[ai+1]=aF;
+}else{
+break;
+}
+}
+m[ai+1]=aE;
+}
+};
+var aH=function(m,aC,aD){
+var aI=[];
+var aJ=200+((aD-aC)&15);
+for(var h=aC+1,ai=0;h<aD-1;h+=aJ,ai++){
+aI[ai]=[h,m[h]];
+}
+%_CallFunction(aI,function(m,n){
+return %_CallFunction(aA,m[1],n[1],ay);
+},ArraySort);
+var aK=aI[aI.length>>1][0];
+return aK;
+}
+var aL=function QuickSort(m,aC,aD){
+var aK=0;
+while(true){
+if(aD-aC<=10){
+aB(m,aC,aD);
+return;
+}
+if(aD-aC>1000){
+aK=aH(m,aC,aD);
+}else{
+aK=aC+((aD-aC)>>1);
+}
+var aM=m[aC];
+var aN=m[aD-1];
+var aO=m[aK];
+var aP=%_CallFunction(aA,aM,aN,ay);
+if(aP>0){
+var aF=aM;
+aM=aN;
+aN=aF;
+}
+var aQ=%_CallFunction(aA,aM,aO,ay);
+if(aQ>=0){
+var aF=aM;
+aM=aO;
+aO=aN;
+aN=aF;
+}else{
+var aR=%_CallFunction(aA,aN,aO,ay);
+if(aR>0){
+var aF=aN;
+aN=aO;
+aO=aF;
+}
+}
+m[aC]=aM;
+m[aD-1]=aO;
+var aS=aN;
+var aT=aC+1;
+var aU=aD-1;
+m[aK]=m[aT];
+m[aT]=aS;
+partition:for(var h=aT+1;h<aU;h++){
+var aE=m[h];
+var aG=%_CallFunction(aA,aE,aS,ay);
+if(aG<0){
+m[h]=m[aT];
+m[aT]=aE;
+aT++;
+}else if(aG>0){
+do{
+aU--;
+if(aU==h)break partition;
+var aV=m[aU];
+aG=%_CallFunction(aA,aV,aS,ay);
+}while(aG>0);
+m[h]=m[aU];
+m[aU]=aE;
+if(aG<0){
+aE=m[h];
+m[h]=m[aT];
+m[aT]=aE;
+aT++;
+}
+}
+}
+if(aD-aU<aT-aC){
+aL(m,aU,aD);
+aD=aT;
+}else{
+aL(m,aC,aT);
+aC=aU;
+}
+}
+};
+var aW=function CopyFromPrototype(aX,j){
+var aY=0;
+for(var aZ=%_GetPrototype(aX);aZ;aZ=%_GetPrototype(aZ)){
+var d=%GetArrayKeys(aZ,j);
+if((typeof(d)==='number')){
+var ba=d;
+for(var h=0;h<ba;h++){
+if(!(%_CallFunction(aX,h,ObjectHasOwnProperty))&&(%_CallFunction(aZ,h,ObjectHasOwnProperty))){
+aX[h]=aZ[h];
+if(h>=aY){aY=h+1;}
+}
+}
+}else{
+for(var h=0;h<d.length;h++){
+var T=d[h];
+if(!(T===(void 0))&&!(%_CallFunction(aX,T,ObjectHasOwnProperty))
+&&(%_CallFunction(aZ,T,ObjectHasOwnProperty))){
+aX[T]=aZ[T];
+if(T>=aY){aY=T+1;}
+}
+}
+}
+}
+return aY;
+};
+var bb=function(aX,aC,aD){
+for(var aZ=%_GetPrototype(aX);aZ;aZ=%_GetPrototype(aZ)){
+var d=%GetArrayKeys(aZ,aD);
+if((typeof(d)==='number')){
+var ba=d;
+for(var h=aC;h<ba;h++){
+if((%_CallFunction(aZ,h,ObjectHasOwnProperty))){
+aX[h]=(void 0);
+}
+}
+}else{
+for(var h=0;h<d.length;h++){
+var T=d[h];
+if(!(T===(void 0))&&aC<=T&&
+(%_CallFunction(aZ,T,ObjectHasOwnProperty))){
+aX[T]=(void 0);
+}
+}
+}
+}
+};
+var bc=function SafeRemoveArrayHoles(aX){
+var bd=0;
+var be=j-1;
+var bf=0;
+while(bd<be){
+while(bd<be&&
+!(aX[bd]===(void 0))){
+bd++;
+}
+if(!(%_CallFunction(aX,bd,ObjectHasOwnProperty))){
+bf++;
+}
+while(bd<be&&
+(aX[be]===(void 0))){
+if(!(%_CallFunction(aX,be,ObjectHasOwnProperty))){
+bf++;
+}
+be--;
+}
+if(bd<be){
+aX[bd]=aX[be];
+aX[be]=(void 0);
+}
+}
+if(!(aX[bd]===(void 0)))bd++;
+var h;
+for(h=bd;h<j-bf;h++){
+aX[h]=(void 0);
+}
+for(h=j-bf;h<j;h++){
+if(h in %_GetPrototype(aX)){
+aX[h]=(void 0);
+}else{
+delete aX[h];
+}
+}
+return bd;
+};
+var j=(this.length>>>0);
+if(j<2)return this;
+var C=(%_IsArray(this));
+var bg;
+if(!C){
+bg=aW(this,j);
+}
+var bh=%RemoveArrayHoles(this,j);
+if(bh==-1){
+bh=bc(this);
+}
+aL(this,0,bh);
+if(!C&&(bh+1<bg)){
+bb(this,bh,bg);
+}
+return this;
+}
+function ArrayFilter(bi,aA){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.filter"]);
+var c=ToObject(this);
+var j=ToUint32(c.length);
+if(!(%_ClassOf(bi)==='Function'))throw MakeTypeError(2,bi);
+var bj=false;
+if((aA==null)){
+aA=%GetDefaultReceiver(bi)||aA;
+}else{
+bj=(!(%_IsSpecObject(aA))&&%IsSloppyModeFunction(bi));
+}
+var H=new a();
+var bk=new InternalArray();
+var bl=0;
+var C=(%_IsArray(c));
+var bm=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(bi);
+for(var h=0;h<j;h++){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+var aE=c[h];
+if(bm)%DebugPrepareStepInIfStepping(bi);
+var bn=bj?ToObject(aA):aA;
+if(%_CallFunction(bn,aE,h,c,bi)){
+bk[bl++]=aE;
+}
+}
+}
+%MoveArrayContents(bk,H);
+return H;
+}
+function ArrayForEach(bi,aA){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.forEach"]);
+var c=ToObject(this);
+var j=(c.length>>>0);
+if(!(%_ClassOf(bi)==='Function'))throw MakeTypeError(2,bi);
+var bj=false;
+if((aA==null)){
+aA=%GetDefaultReceiver(bi)||aA;
+}else{
+bj=(!(%_IsSpecObject(aA))&&%IsSloppyModeFunction(bi));
+}
+var C=(%_IsArray(c));
+var bm=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(bi);
+for(var h=0;h<j;h++){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+var aE=c[h];
+if(bm)%DebugPrepareStepInIfStepping(bi);
+var bn=bj?ToObject(aA):aA;
+%_CallFunction(bn,aE,h,c,bi);
+}
+}
+}
+function ArraySome(bi,aA){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.some"]);
+var c=ToObject(this);
+var j=(c.length>>>0);
+if(!(%_ClassOf(bi)==='Function'))throw MakeTypeError(2,bi);
+var bj=false;
+if((aA==null)){
+aA=%GetDefaultReceiver(bi)||aA;
+}else{
+bj=(!(%_IsSpecObject(aA))&&%IsSloppyModeFunction(bi));
+}
+var C=(%_IsArray(c));
+var bm=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(bi);
+for(var h=0;h<j;h++){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+var aE=c[h];
+if(bm)%DebugPrepareStepInIfStepping(bi);
+var bn=bj?ToObject(aA):aA;
+if(%_CallFunction(bn,aE,h,c,bi))return true;
+}
+}
+return false;
+}
+function ArrayEvery(bi,aA){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.every"]);
+var c=ToObject(this);
+var j=(c.length>>>0);
+if(!(%_ClassOf(bi)==='Function'))throw MakeTypeError(2,bi);
+var bj=false;
+if((aA==null)){
+aA=%GetDefaultReceiver(bi)||aA;
+}else{
+bj=(!(%_IsSpecObject(aA))&&%IsSloppyModeFunction(bi));
+}
+var C=(%_IsArray(c));
+var bm=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(bi);
+for(var h=0;h<j;h++){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+var aE=c[h];
+if(bm)%DebugPrepareStepInIfStepping(bi);
+var bn=bj?ToObject(aA):aA;
+if(!%_CallFunction(bn,aE,h,c,bi))return false;
+}
+}
+return true;
+}
+function ArrayMap(bi,aA){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.map"]);
+var c=ToObject(this);
+var j=(c.length>>>0);
+if(!(%_ClassOf(bi)==='Function'))throw MakeTypeError(2,bi);
+var bj=false;
+if((aA==null)){
+aA=%GetDefaultReceiver(bi)||aA;
+}else{
+bj=(!(%_IsSpecObject(aA))&&%IsSloppyModeFunction(bi));
+}
+var H=new a();
+var bk=new InternalArray(j);
+var C=(%_IsArray(c));
+var bm=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(bi);
+for(var h=0;h<j;h++){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+var aE=c[h];
+if(bm)%DebugPrepareStepInIfStepping(bi);
+var bn=bj?ToObject(aA):aA;
+bk[h]=%_CallFunction(bn,aE,h,c,bi);
+}
+}
+%MoveArrayContents(bk,H);
+return H;
+}
+function ArrayIndexOf(aE,T){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.indexOf"]);
+var j=(this.length>>>0);
+if(j==0)return-1;
+if((T===(void 0))){
+T=0;
+}else{
+T=(%_IsSmi(%IS_VAR(T))?T:%NumberToInteger(ToNumber(T)));
+if(T<0){
+T=j+T;
+if(T<0)T=0;
+}
+}
+var bo=T;
+var aY=j;
+if(UseSparseVariant(this,j,(%_IsArray(this)),aY-bo)){
+%NormalizeElements(this);
+var d=%GetArrayKeys(this,j);
+if((typeof(d)==='number')){
+aY=d;
+}else{
+if(d.length==0)return-1;
+var bp=GetSortedArrayKeys(this,d);
+var Z=bp.length;
+var h=0;
+while(h<Z&&bp[h]<T)h++;
+while(h<Z){
+var l=bp[h];
+if(!(l===(void 0))&&this[l]===aE)return l;
+h++;
+}
+return-1;
+}
+}
+if(!(aE===(void 0))){
+for(var h=bo;h<aY;h++){
+if(this[h]===aE)return h;
+}
+return-1;
+}
+for(var h=bo;h<aY;h++){
+if((this[h]===(void 0))&&h in this){
+return h;
+}
+}
+return-1;
+}
+function ArrayLastIndexOf(aE,T){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.lastIndexOf"]);
+var j=(this.length>>>0);
+if(j==0)return-1;
+if(%_ArgumentsLength()<2){
+T=j-1;
+}else{
+T=(%_IsSmi(%IS_VAR(T))?T:%NumberToInteger(ToNumber(T)));
+if(T<0)T+=j;
+if(T<0)return-1;
+else if(T>=j)T=j-1;
+}
+var bo=0;
+var aY=T;
+if(UseSparseVariant(this,j,(%_IsArray(this)),T)){
+%NormalizeElements(this);
+var d=%GetArrayKeys(this,T+1);
+if((typeof(d)==='number')){
+aY=d;
+}else{
+if(d.length==0)return-1;
+var bp=GetSortedArrayKeys(this,d);
+var h=bp.length-1;
+while(h>=0){
+var l=bp[h];
+if(!(l===(void 0))&&this[l]===aE)return l;
+h--;
+}
+return-1;
+}
+}
+if(!(aE===(void 0))){
+for(var h=aY;h>=bo;h--){
+if(this[h]===aE)return h;
+}
+return-1;
+}
+for(var h=aY;h>=bo;h--){
+if((this[h]===(void 0))&&h in this){
+return h;
+}
+}
+return-1;
+}
+function ArrayReduce(bq,N){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.reduce"]);
+var c=ToObject(this);
+var j=ToUint32(c.length);
+if(!(%_ClassOf(bq)==='Function')){
+throw MakeTypeError(2,bq);
+}
+var C=(%_IsArray(c));
+var h=0;
+find_initial:if(%_ArgumentsLength()<2){
+for(;h<j;h++){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+N=c[h++];
+break find_initial;
+}
+}
+throw MakeTypeError('reduce_no_initial',[]);
+}
+var aA=%GetDefaultReceiver(bq);
+var bm=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(bq);
+for(;h<j;h++){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+var aE=c[h];
+if(bm)%DebugPrepareStepInIfStepping(bq);
+N=%_CallFunction(aA,N,aE,h,c,bq);
+}
+}
+return N;
+}
+function ArrayReduceRight(bq,N){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.reduceRight"]);
+var c=ToObject(this);
+var j=ToUint32(c.length);
+if(!(%_ClassOf(bq)==='Function')){
+throw MakeTypeError(2,bq);
+}
+var C=(%_IsArray(c));
+var h=j-1;
+find_initial:if(%_ArgumentsLength()<2){
+for(;h>=0;h--){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+N=c[h--];
+break find_initial;
+}
+}
+throw MakeTypeError('reduce_no_initial',[]);
+}
+var aA=%GetDefaultReceiver(bq);
+var bm=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(bq);
+for(;h>=0;h--){
+if(((C&&%_HasFastPackedElements(%IS_VAR(c)))?(h<c.length):(h in c))){
+var aE=c[h];
+if(bm)%DebugPrepareStepInIfStepping(bq);
+N=%_CallFunction(aA,N,aE,h,c,bq);
+}
+}
+return N;
+}
+function ArrayIsArray(aX){
+return(%_IsArray(aX));
+}
+%AddNamedProperty(a.prototype,"constructor",a,
+2);
+var br={
+__proto__:null,
+copyWithin:true,
+entries:true,
+fill:true,
+find:true,
+findIndex:true,
+keys:true,
+};
+%AddNamedProperty(a.prototype,symbolUnscopables,br,
+2|1);
+InstallFunctions(a,2,[
+"isArray",ArrayIsArray
+]);
+var bs=%SpecialArrayFunctions();
+var bt=function(bu,bv,o){
+var bi=bv;
+if(bs.hasOwnProperty(bu)){
+bi=bs[bu];
+}
+if(!(o===(void 0))){
+%FunctionSetLength(bi,o);
+}
+return bi;
+};
+InstallFunctions(a.prototype,2,[
+"toString",bt("toString",ArrayToString),
+"toLocaleString",bt("toLocaleString",ArrayToLocaleString),
+"join",bt("join",ArrayJoin),
+"pop",bt("pop",ArrayPop),
+"push",bt("push",ArrayPush,1),
+"concat",bt("concat",ArrayConcatJS,1),
+"reverse",bt("reverse",ArrayReverse),
+"shift",bt("shift",ArrayShift),
+"unshift",bt("unshift",ArrayUnshift,1),
+"slice",bt("slice",ArraySlice,2),
+"splice",bt("splice",ArraySplice,2),
+"sort",bt("sort",ArraySort),
+"filter",bt("filter",ArrayFilter,1),
+"forEach",bt("forEach",ArrayForEach,1),
+"some",bt("some",ArraySome,1),
+"every",bt("every",ArrayEvery,1),
+"map",bt("map",ArrayMap,1),
+"indexOf",bt("indexOf",ArrayIndexOf,1),
+"lastIndexOf",bt("lastIndexOf",ArrayLastIndexOf,1),
+"reduce",bt("reduce",ArrayReduce,1),
+"reduceRight",bt("reduceRight",ArrayReduceRight,1)
+]);
+%FinishArrayPrototypeSetup(a.prototype);
+SetUpLockedPrototype(InternalArray,a(),[
+"concat",bt("concat",ArrayConcatJS),
+"indexOf",bt("indexOf",ArrayIndexOf),
+"join",bt("join",ArrayJoin),
+"pop",bt("pop",ArrayPop),
+"push",bt("push",ArrayPush),
+"splice",bt("splice",ArraySplice)
+]);
+SetUpLockedPrototype(InternalPackedArray,a(),[
+"join",bt("join",ArrayJoin),
+"pop",bt("pop",ArrayPop),
+"push",bt("push",ArrayPush)
+]);
+$arrayConcat=ArrayConcatJS;
+$arrayJoin=ArrayJoin;
+$arrayPush=ArrayPush;
+$arrayPop=ArrayPop;
+$arrayShift=ArrayShift;
+$arraySlice=ArraySlice;
+$arraySplice=ArraySplice;
+$arrayUnshift=ArrayUnshift;
+})();
+
+\18stringnX\ 1
+var $stringCharAt;
+var $stringIndexOf;
+var $stringSubstring;
+(function(){
+%CheckIsBootstrapping();
+var a=global.RegExp;
+var b=global.String;
+function StringConstructor(c){
+if(%_ArgumentsLength()==0)c='';
+if(%_IsConstructCall()){
+%_SetValueOf(this,((typeof(%IS_VAR(c))==='string')?c:NonStringToString(c)));
+}else{
+return(typeof(c)==='symbol')?
+%_CallFunction(c,$symbolToString):((typeof(%IS_VAR(c))==='string')?c:NonStringToString(c));
+}
+}
+function StringToString(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw MakeTypeError(14,'String.prototype.toString');
+}
+return %_ValueOf(this);
+}
+function StringValueOf(){
+if(!(typeof(this)==='string')&&!(%_ClassOf(this)==='String')){
+throw MakeTypeError(14,'String.prototype.valueOf');
+}
+return %_ValueOf(this);
+}
+function StringCharAtJS(d){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.charAt"]);
+var e=%_StringCharAt(this,d);
+if(%_IsSmi(e)){
+e=%_StringCharAt(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)),(%_IsSmi(%IS_VAR(d))?d:%NumberToInteger(ToNumber(d))));
+}
+return e;
+}
+function StringCharCodeAtJS(d){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.charCodeAt"]);
+var e=%_StringCharCodeAt(this,d);
+if(!%_IsSmi(e)){
+e=%_StringCharCodeAt(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)),(%_IsSmi(%IS_VAR(d))?d:%NumberToInteger(ToNumber(d))));
+}
+return e;
+}
+function StringConcat(g){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.concat"]);
+var h=%_ArgumentsLength();
+var i=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+if(h===1){
+return i+((typeof(%IS_VAR(g))==='string')?g:NonStringToString(g));
+}
+var j=new InternalArray(h+1);
+j[0]=i;
+for(var k=0;k<h;k++){
+var l=%_Arguments(k);
+j[k+1]=((typeof(%IS_VAR(l))==='string')?l:NonStringToString(l));
+}
+return %StringBuilderConcat(j,h+1,"");
+}
+function StringIndexOfJS(m){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.indexOf"]);
+var n=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+m=((typeof(%IS_VAR(m))==='string')?m:NonStringToString(m));
+var o=0;
+if(%_ArgumentsLength()>1){
+o=%_Arguments(1);
+o=(%_IsSmi(%IS_VAR(o))?o:%NumberToInteger(ToNumber(o)));
+if(o<0)o=0;
+if(o>n.length)o=n.length;
+}
+return %StringIndexOf(n,m,o);
+}
+function StringLastIndexOfJS(q){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.lastIndexOf"]);
+var r=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+var t=r.length;
+var q=((typeof(%IS_VAR(q))==='string')?q:NonStringToString(q));
+var u=q.length;
+var o=t-u;
+if(%_ArgumentsLength()>1){
+var w=ToNumber(%_Arguments(1));
+if(!(!%_IsSmi(%IS_VAR(w))&&!(w==w))){
+w=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(w<0){
+w=0;
+}
+if(w+u<t){
+o=w;
+}
+}
+}
+if(o<0){
+return-1;
+}
+return %StringLastIndexOf(r,q,o);
+}
+function StringLocaleCompareJS(g){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.localeCompare"]);
+return %StringLocaleCompare(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)),
+((typeof(%IS_VAR(g))==='string')?g:NonStringToString(g)));
+}
+function StringMatchJS(z){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.match"]);
+var n=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+if((%_IsRegExp(z))){
+var A=z.lastIndex;
+(%_IsSmi(%IS_VAR(A))?A:ToNumber(A));
+if(!z.global)return $regexpExecNoTests(z,n,0);
+var e=%StringMatch(n,z,$regexpLastMatchInfo);
+if(e!==null)$regexpLastMatchInfoOverride=null;
+z.lastIndex=0;
+return e;
+}
+z=new a(z);
+return $regexpExecNoTests(z,n,0);
+}
+var B=['NFC','NFD','NFKC','NFKD'];
+function StringNormalizeJS(C){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.normalize"]);
+var C=C?((typeof(%IS_VAR(C))==='string')?C:NonStringToString(C)):'NFC';
+var D=B.indexOf(C);
+if(D===-1){
+throw new $RangeError('The normalization form should be one of '
++B.join(', ')+'.');
+}
+return %_ValueOf(this);
+}
+var E=[2,"","",-1,-1];
+function StringReplace(G,H){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.replace"]);
+var n=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+if((%_IsRegExp(G))){
+var A=G.lastIndex;
+(%_IsSmi(%IS_VAR(A))?A:ToNumber(A));
+if(!(%_ClassOf(H)==='Function')){
+H=((typeof(%IS_VAR(H))==='string')?H:NonStringToString(H));
+if(!G.global){
+var I=$regexpExec(G,n,0);
+if(I==null){
+G.lastIndex=0
+return n;
+}
+if(H.length==0){
+return %_SubString(n,0,I[3])+
+%_SubString(n,I[4],n.length)
+}
+return ExpandReplacement(H,n,$regexpLastMatchInfo,
+%_SubString(n,0,I[3]))+
+%_SubString(n,I[4],n.length);
+}
+G.lastIndex=0;
+if($regexpLastMatchInfoOverride==null){
+return %StringReplaceGlobalRegExpWithString(
+n,G,H,$regexpLastMatchInfo);
+}else{
+var J=$regexpLastMatchInfo[1];
+$regexpLastMatchInfo[1]=0;
+var K=%StringReplaceGlobalRegExpWithString(
+n,G,H,$regexpLastMatchInfo);
+if(%_IsSmi($regexpLastMatchInfo[1])){
+$regexpLastMatchInfo[1]=J;
+}else{
+$regexpLastMatchInfoOverride=null;
+}
+return K;
+}
+}
+if(G.global){
+return StringReplaceGlobalRegExpWithFunction(n,G,H);
+}
+return StringReplaceNonGlobalRegExpWithFunction(n,G,H);
+}
+G=((typeof(%IS_VAR(G))==='string')?G:NonStringToString(G));
+if(G.length==1&&
+n.length>0xFF&&
+(typeof(H)==='string')&&
+%StringIndexOf(H,'$',0)<0){
+return %StringReplaceOneCharWithString(n,G,H);
+}
+var L=%StringIndexOf(n,G,0);
+if(L<0)return n;
+var M=L+G.length;
+var e=%_SubString(n,0,L);
+if((%_ClassOf(H)==='Function')){
+var N=%GetDefaultReceiver(H);
+e+=%_CallFunction(N,G,L,n,H);
+}else{
+E[3]=L;
+E[4]=M;
+e=ExpandReplacement(((typeof(%IS_VAR(H))==='string')?H:NonStringToString(H)),
+n,
+E,
+e);
+}
+return e+%_SubString(n,M,n.length);
+}
+function ExpandReplacement(P,n,Q,e){
+var R=P.length;
+var S=%StringIndexOf(P,'$',0);
+if(S<0){
+if(R>0)e+=P;
+return e;
+}
+if(S>0)e+=%_SubString(P,0,S);
+while(true){
+var T='$';
+var w=S+1;
+if(w<R){
+var U=%_StringCharCodeAt(P,w);
+if(U==36){
+++w;
+e+='$';
+}else if(U==38){
+++w;
+e+=
+%_SubString(n,Q[3],Q[4]);
+}else if(U==96){
+++w;
+e+=%_SubString(n,0,Q[3]);
+}else if(U==39){
+++w;
+e+=%_SubString(n,Q[4],n.length);
+}else if(U>=48&&U<=57){
+var W=(U-48)<<1;
+var X=1;
+var Y=((Q)[0]);
+if(w+1<P.length){
+var S=%_StringCharCodeAt(P,w+1);
+if(S>=48&&S<=57){
+var Z=W*10+((S-48)<<1);
+if(Z<Y){
+W=Z;
+X=2;
+}
+}
+}
+if(W!=0&&W<Y){
+var L=Q[(3+(W))];
+if(L>=0){
+e+=
+%_SubString(n,L,Q[(3+(W+1))]);
+}
+w+=X;
+}else{
+e+='$';
+}
+}else{
+e+='$';
+}
+}else{
+e+='$';
+}
+S=%StringIndexOf(P,'$',w);
+if(S<0){
+if(w<R){
+e+=%_SubString(P,w,R);
+}
+return e;
+}
+if(S>w){
+e+=%_SubString(P,w,S);
+}
+}
+return e;
+}
+function CaptureString(P,aa,o){
+var ab=o<<1;
+var L=aa[(3+(ab))];
+if(L<0)return;
+var M=aa[(3+(ab+1))];
+return %_SubString(P,L,M);
+}
+var ac=new InternalArray(16);
+function StringReplaceGlobalRegExpWithFunction(n,z,H){
+var ad=ac;
+if(ad){
+ac=null;
+}else{
+ad=new InternalArray(16);
+}
+var ae=%RegExpExecMultiple(z,
+n,
+$regexpLastMatchInfo,
+ad);
+z.lastIndex=0;
+if((ae===null)){
+ac=ad;
+return n;
+}
+var h=ae.length;
+if((($regexpLastMatchInfo)[0])==2){
+var af=0;
+var ag=new InternalPackedArray(null,0,n);
+var N=%GetDefaultReceiver(H);
+for(var k=0;k<h;k++){
+var ah=ae[k];
+if(%_IsSmi(ah)){
+if(ah>0){
+af=(ah>>11)+(ah&0x7ff);
+}else{
+af=ae[++k]-ah;
+}
+}else{
+ag[0]=ah;
+ag[1]=af;
+$regexpLastMatchInfoOverride=ag;
+var ai=
+%_CallFunction(N,ah,af,n,H);
+ae[k]=((typeof(%IS_VAR(ai))==='string')?ai:NonStringToString(ai));
+af+=ah.length;
+}
+}
+}else{
+var N=%GetDefaultReceiver(H);
+for(var k=0;k<h;k++){
+var ah=ae[k];
+if(!%_IsSmi(ah)){
+$regexpLastMatchInfoOverride=ah;
+var ai=%Apply(H,N,ah,0,ah.length);
+ae[k]=((typeof(%IS_VAR(ai))==='string')?ai:NonStringToString(ai));
+}
+}
+}
+var e=%StringBuilderConcat(ae,ae.length,n);
+ad.length=0;
+ac=ad;
+return e;
+}
+function StringReplaceNonGlobalRegExpWithFunction(n,z,H){
+var Q=$regexpExec(z,n,0);
+if((Q===null)){
+z.lastIndex=0;
+return n;
+}
+var o=Q[3];
+var e=%_SubString(n,0,o);
+var aj=Q[4];
+var ak=((Q)[0])>>1;
+var al;
+var N=%GetDefaultReceiver(H);
+if(ak==1){
+var am=%_SubString(n,o,aj);
+al=%_CallFunction(N,am,o,n,H);
+}else{
+var an=new InternalArray(ak+2);
+for(var ao=0;ao<ak;ao++){
+an[ao]=CaptureString(n,Q,ao);
+}
+an[ao]=o;
+an[ao+1]=n;
+al=%Apply(H,N,an,0,ao+2);
+}
+e+=al;
+return e+%_SubString(n,aj,n.length);
+}
+function StringSearch(ap){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.search"]);
+var z;
+if((typeof(ap)==='string')){
+z=%_GetFromCache(0,ap);
+}else if((%_IsRegExp(ap))){
+z=ap;
+}else{
+z=new a(ap);
+}
+var I=$regexpExec(z,((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)),0);
+if(I){
+return I[3];
+}
+return-1;
+}
+function StringSlice(L,M){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.slice"]);
+var am=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+var aq=am.length;
+var ar=(%_IsSmi(%IS_VAR(L))?L:%NumberToInteger(ToNumber(L)));
+var as=aq;
+if(!(M===(void 0))){
+as=(%_IsSmi(%IS_VAR(M))?M:%NumberToInteger(ToNumber(M)));
+}
+if(ar<0){
+ar+=aq;
+if(ar<0){
+ar=0;
+}
+}else{
+if(ar>aq){
+return'';
+}
+}
+if(as<0){
+as+=aq;
+if(as<0){
+return'';
+}
+}else{
+if(as>aq){
+as=aq;
+}
+}
+if(as<=ar){
+return'';
+}
+return %_SubString(am,ar,as);
+}
+function StringSplitJS(at,au){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.split"]);
+var n=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+au=((au===(void 0)))?0xffffffff:(au>>>0);
+var R=n.length;
+if(!(%_IsRegExp(at))){
+var av=((typeof(%IS_VAR(at))==='string')?at:NonStringToString(at));
+if(au===0)return[];
+if((at===(void 0)))return[n];
+var aw=av.length;
+if(aw===0)return %StringToArray(n,au);
+var e=%StringSplit(n,av,au);
+return e;
+}
+if(au===0)return[];
+return StringSplitOnRegExp(n,at,au,R);
+}
+function StringSplitOnRegExp(n,at,au,R){
+if(R===0){
+if($regexpExec(at,n,0,0)!=null){
+return[];
+}
+return[n];
+}
+var ax=0;
+var ay=0;
+var az=0;
+var e=new InternalArray();
+outer_loop:
+while(true){
+if(ay===R){
+e[e.length]=%_SubString(n,ax,R);
+break;
+}
+var Q=$regexpExec(at,n,ay);
+if(Q==null||R===(az=Q[3])){
+e[e.length]=%_SubString(n,ax,R);
+break;
+}
+var aA=Q[4];
+if(ay===aA&&aA===ax){
+ay++;
+continue;
+}
+e[e.length]=%_SubString(n,ax,az);
+if(e.length===au)break;
+var aB=((Q)[0])+3;
+for(var k=3+2;k<aB;){
+var L=Q[k++];
+var M=Q[k++];
+if(M!=-1){
+e[e.length]=%_SubString(n,L,M);
+}else{
+e[e.length]=(void 0);
+}
+if(e.length===au)break outer_loop;
+}
+ay=ax=aA;
+}
+var aC=[];
+%MoveArrayContents(e,aC);
+return aC;
+}
+function StringSubstring(L,M){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.subString"]);
+var am=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+var aq=am.length;
+var ar=(%_IsSmi(%IS_VAR(L))?L:%NumberToInteger(ToNumber(L)));
+if(ar<0){
+ar=0;
+}else if(ar>aq){
+ar=aq;
+}
+var as=aq;
+if(!(M===(void 0))){
+as=(%_IsSmi(%IS_VAR(M))?M:%NumberToInteger(ToNumber(M)));
+if(as>aq){
+as=aq;
+}else{
+if(as<0)as=0;
+if(ar>as){
+var aD=as;
+as=ar;
+ar=aD;
+}
+}
+}
+return %_SubString(am,ar,as);
+}
+function StringSubstr(L,aE){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.substr"]);
+var am=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+var h;
+if((aE===(void 0))){
+h=am.length;
+}else{
+h=(%_IsSmi(%IS_VAR(aE))?aE:%NumberToInteger(ToNumber(aE)));
+if(h<=0)return'';
+}
+if((L===(void 0))){
+L=0;
+}else{
+L=(%_IsSmi(%IS_VAR(L))?L:%NumberToInteger(ToNumber(L)));
+if(L>=am.length)return'';
+if(L<0){
+L+=am.length;
+if(L<0)L=0;
+}
+}
+var M=L+h;
+if(M>am.length)M=am.length;
+return %_SubString(am,L,M);
+}
+function StringToLowerCaseJS(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.toLowerCase"]);
+return %StringToLowerCase(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)));
+}
+function StringToLocaleLowerCase(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.toLocaleLowerCase"]);
+return %StringToLowerCase(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)));
+}
+function StringToUpperCaseJS(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.toUpperCase"]);
+return %StringToUpperCase(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)));
+}
+function StringToLocaleUpperCase(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.toLocaleUpperCase"]);
+return %StringToUpperCase(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)));
+}
+function StringTrimJS(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.trim"]);
+return %StringTrim(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)),true,true);
+}
+function StringTrimLeft(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.trimLeft"]);
+return %StringTrim(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)),true,false);
+}
+function StringTrimRight(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.trimRight"]);
+return %StringTrim(((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this)),false,true);
+}
+function StringFromCharCode(aF){
+var aE=%_ArgumentsLength();
+if(aE==1){
+if(!%_IsSmi(aF))aF=ToNumber(aF);
+return %_StringCharFromCode(aF&0xffff);
+}
+var aG=%NewString(aE,true);
+var k;
+for(k=0;k<aE;k++){
+var aF=%_Arguments(k);
+if(!%_IsSmi(aF))aF=ToNumber(aF)&0xffff;
+if(aF<0)aF=aF&0xffff;
+if(aF>0xff)break;
+%_OneByteSeqStringSetChar(k,aF,aG);
+}
+if(k==aE)return aG;
+aG=%TruncateString(aG,k);
+var aH=%NewString(aE-k,false);
+for(var ao=0;k<aE;k++,ao++){
+var aF=%_Arguments(k);
+if(!%_IsSmi(aF))aF=ToNumber(aF)&0xffff;
+%_TwoByteSeqStringSetChar(ao,aF,aH);
+}
+return aG+aH;
+}
+function HtmlEscape(aI){
+return((typeof(%IS_VAR(aI))==='string')?aI:NonStringToString(aI)).replace(/"/g,""");
+}
+function StringAnchor(aJ){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.anchor"]);
+return"<a name=\""+HtmlEscape(aJ)+"\">"+this+"</a>";
+}
+function StringBig(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.big"]);
+return"<big>"+this+"</big>";
+}
+function StringBlink(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.blink"]);
+return"<blink>"+this+"</blink>";
+}
+function StringBold(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.bold"]);
+return"<b>"+this+"</b>";
+}
+function StringFixed(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.fixed"]);
+return"<tt>"+this+"</tt>";
+}
+function StringFontcolor(aK){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.fontcolor"]);
+return"<font color=\""+HtmlEscape(aK)+"\">"+this+"</font>";
+}
+function StringFontsize(aL){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.fontsize"]);
+return"<font size=\""+HtmlEscape(aL)+"\">"+this+"</font>";
+}
+function StringItalics(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.italics"]);
+return"<i>"+this+"</i>";
+}
+function StringLink(am){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.link"]);
+return"<a href=\""+HtmlEscape(am)+"\">"+this+"</a>";
+}
+function StringSmall(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.small"]);
+return"<small>"+this+"</small>";
+}
+function StringStrike(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.strike"]);
+return"<strike>"+this+"</strike>";
+}
+function StringSub(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.sub"]);
+return"<sub>"+this+"</sub>";
+}
+function StringSup(){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.sup"]);
+return"<sup>"+this+"</sup>";
+}
+function StringRepeat(aM){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.repeat"]);
+var am=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+var aE=ToInteger(aM);
+if(aE<0||aE>%_MaxSmi()){
+throw MakeRangeError("invalid_count_value",[]);
+}
+var aN="";
+while(true){
+if(aE&1)aN+=am;
+aE>>=1;
+if(aE===0)return aN;
+am+=am;
+}
+}
+function StringStartsWith(aO){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.startsWith"]);
+var am=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+if((%_IsRegExp(aO))){
+throw MakeTypeError("first_argument_not_regexp",
+["String.prototype.startsWith"]);
+}
+var aP=((typeof(%IS_VAR(aO))==='string')?aO:NonStringToString(aO));
+var d=0;
+if(%_ArgumentsLength()>1){
+d=%_Arguments(1);
+d=ToInteger(d);
+}
+var aq=am.length;
+var L=$min($max(d,0),aq);
+var aQ=aP.length;
+if(aQ+L>aq){
+return false;
+}
+return %StringIndexOf(am,aP,L)===L;
+}
+function StringEndsWith(aO){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.endsWith"]);
+var am=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+if((%_IsRegExp(aO))){
+throw MakeTypeError("first_argument_not_regexp",
+["String.prototype.endsWith"]);
+}
+var aP=((typeof(%IS_VAR(aO))==='string')?aO:NonStringToString(aO));
+var aq=am.length;
+var d=aq;
+if(%_ArgumentsLength()>1){
+var aR=%_Arguments(1);
+if(!(aR===(void 0))){
+d=ToInteger(aR);
+}
+}
+var M=$min($max(d,0),aq);
+var aQ=aP.length;
+var L=M-aQ;
+if(L<0){
+return false;
+}
+return %StringLastIndexOf(am,aP,L)===L;
+}
+function StringIncludes(aO){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.includes"]);
+var am=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+if((%_IsRegExp(aO))){
+throw MakeTypeError("first_argument_not_regexp",
+["String.prototype.includes"]);
+}
+var aP=((typeof(%IS_VAR(aO))==='string')?aO:NonStringToString(aO));
+var d=0;
+if(%_ArgumentsLength()>1){
+d=%_Arguments(1);
+d=ToInteger(d);
+}
+var aq=am.length;
+var L=$min($max(d,0),aq);
+var aQ=aP.length;
+if(aQ+L>aq){
+return false;
+}
+return %StringIndexOf(am,aP,L)!==-1;
+}
+function StringCodePointAt(d){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.codePointAt"]);
+var P=((typeof(%IS_VAR(this))==='string')?this:NonStringToString(this));
+var aL=P.length;
+d=(%_IsSmi(%IS_VAR(d))?d:%NumberToInteger(ToNumber(d)));
+if(d<0||d>=aL){
+return(void 0);
+}
+var aS=%_StringCharCodeAt(P,d);
+if(aS<0xD800||aS>0xDBFF||d+1==aL){
+return aS;
+}
+var aT=%_StringCharCodeAt(P,d+1);
+if(aT<0xDC00||aT>0xDFFF){
+return aS;
+}
+return(aS-0xD800)*0x400+aT+0x2400;
+}
+function StringFromCodePoint(aU){
+var aF;
+var R=%_ArgumentsLength();
+var o;
+var e="";
+for(o=0;o<R;o++){
+aF=%_Arguments(o);
+if(!%_IsSmi(aF)){
+aF=ToNumber(aF);
+}
+if(aF<0||aF>0x10FFFF||aF!==(%_IsSmi(%IS_VAR(aF))?aF:%NumberToInteger(ToNumber(aF)))){
+throw MakeRangeError("invalid_code_point",[aF]);
+}
+if(aF<=0xFFFF){
+e+=%_StringCharFromCode(aF);
+}else{
+aF-=0x10000;
+e+=%_StringCharFromCode((aF>>>10)&0x3FF|0xD800);
+e+=%_StringCharFromCode(aF&0x3FF|0xDC00);
+}
+}
+return e;
+}
+function StringRaw(aV){
+var aW=%_ArgumentsLength();
+var aX=ToObject(aV);
+var aY=ToObject(aX.raw);
+var aZ=ToLength(aY.length);
+if(aZ<=0)return"";
+var e=ToString(aY[0]);
+for(var k=1;k<aZ;++k){
+if(k<aW){
+e+=ToString(%_Arguments(k));
+}
+e+=ToString(aY[k]);
+}
+return e;
+}
+%SetCode(b,StringConstructor);
+%FunctionSetPrototype(b,new b());
+%AddNamedProperty(
+b.prototype,"constructor",b,2);
+InstallFunctions(b,2,[
+"fromCharCode",StringFromCharCode,
+"fromCodePoint",StringFromCodePoint,
+"raw",StringRaw
+]);
+InstallFunctions(b.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
+]);
+$stringCharAt=StringCharAtJS;
+$stringIndexOf=StringIndexOfJS;
+$stringSubstring=StringSubstring;
+})();
+
+\furi}]
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Object;
+var b=global.Array;
+function HexValueOf(c){
+if(c>=48&&c<=57)return c-48;
+if(c>=65&&c<=70)return c-55;
+if(c>=97&&c<=102)return c-87;
+return-1;
+}
+function isAlphaNumeric(d){
+if(97<=d&&d<=122)return true;
+if(65<=d&&d<=90)return true;
+if(48<=d&&d<=57)return true;
+return false;
+}
+var e=0;
+function URIAddEncodedOctetToBuffer(g,h,i){
+h[i++]=37;
+h[i++]=e[g>>4];
+h[i++]=e[g&0x0F];
+return i;
+}
+function URIEncodeOctets(j,h,i){
+if(e===0){
+e=[48,49,50,51,52,53,54,55,56,57,
+65,66,67,68,69,70];
+}
+i=URIAddEncodedOctetToBuffer(j[0],h,i);
+if(j[1])i=URIAddEncodedOctetToBuffer(j[1],h,i);
+if(j[2])i=URIAddEncodedOctetToBuffer(j[2],h,i);
+if(j[3])i=URIAddEncodedOctetToBuffer(j[3],h,i);
+return i;
+}
+function URIEncodeSingle(d,h,i){
+var k=(d>>12)&0xF;
+var l=(d>>6)&63;
+var m=d&63;
+var j=new b(3);
+if(d<=0x007F){
+j[0]=d;
+}else if(d<=0x07FF){
+j[0]=l+192;
+j[1]=m+128;
+}else{
+j[0]=k+224;
+j[1]=l+128;
+j[2]=m+128;
+}
+return URIEncodeOctets(j,h,i);
+}
+function URIEncodePair(n,o,h,i){
+var q=((n>>6)&0xF)+1;
+var r=(n>>2)&0xF;
+var k=n&3;
+var l=(o>>6)&0xF;
+var m=o&63;
+var j=new b(4);
+j[0]=(q>>2)+240;
+j[1]=(((q&3)<<4)|r)+128;
+j[2]=((k<<4)|l)+128;
+j[3]=m+128;
+return URIEncodeOctets(j,h,i);
+}
+function URIHexCharsToCharCode(t,u){
+var w=HexValueOf(t);
+var z=HexValueOf(u);
+if(w==-1||z==-1){
+throw new $URIError("URI malformed");
+}
+return(w<<4)|z;
+}
+function URIDecodeOctets(j,h,i){
+var A;
+var B=j[0];
+if(B<0x80){
+A=B;
+}else if(B<0xc2){
+throw new $URIError("URI malformed");
+}else{
+var C=j[1];
+if(B<0xe0){
+var D=B&0x1f;
+if((C<0x80)||(C>0xbf)){
+throw new $URIError("URI malformed");
+}
+var E=C&0x3f;
+A=(D<<6)+E;
+if(A<0x80||A>0x7ff){
+throw new $URIError("URI malformed");
+}
+}else{
+var G=j[2];
+if(B<0xf0){
+var D=B&0x0f;
+if((C<0x80)||(C>0xbf)){
+throw new $URIError("URI malformed");
+}
+var E=C&0x3f;
+if((G<0x80)||(G>0xbf)){
+throw new $URIError("URI malformed");
+}
+var H=G&0x3f;
+A=(D<<12)+(E<<6)+H;
+if((A<0x800)||(A>0xffff)){
+throw new $URIError("URI malformed");
+}
+}else{
+var I=j[3];
+if(B<0xf8){
+var D=(B&0x07);
+if((C<0x80)||(C>0xbf)){
+throw new $URIError("URI malformed");
+}
+var E=(C&0x3f);
+if((G<0x80)||(G>0xbf)){
+throw new $URIError("URI malformed");
+}
+var H=(G&0x3f);
+if((I<0x80)||(I>0xbf)){
+throw new $URIError("URI malformed");
+}
+var J=(I&0x3f);
+A=(D<<18)+(E<<12)+(H<<6)+J;
+if((A<0x10000)||(A>0x10ffff)){
+throw new $URIError("URI malformed");
+}
+}else{
+throw new $URIError("URI malformed");
+}
+}
+}
+}
+if(0xD800<=A&&A<=0xDFFF){
+throw new $URIError("URI malformed");
+}
+if(A<0x10000){
+%_TwoByteSeqStringSetChar(i++,A,h);
+}else{
+%_TwoByteSeqStringSetChar(i++,(A>>10)+0xd7c0,h);
+%_TwoByteSeqStringSetChar(i++,(A&0x3ff)+0xdc00,h);
+}
+return i;
+}
+function Encode(K,L){
+var M=K.length;
+var N=new InternalArray(M);
+var i=0;
+for(var P=0;P<M;P++){
+var n=K.charCodeAt(P);
+if(L(n)){
+N[i++]=n;
+}else{
+if(n>=0xDC00&&n<=0xDFFF)throw new $URIError("URI malformed");
+if(n<0xD800||n>0xDBFF){
+i=URIEncodeSingle(n,N,i);
+}else{
+P++;
+if(P==M)throw new $URIError("URI malformed");
+var o=K.charCodeAt(P);
+if(o<0xDC00||o>0xDFFF)throw new $URIError("URI malformed");
+i=URIEncodePair(n,o,N,i);
+}
+}
+}
+var h=%NewString(N.length,true);
+for(var Q=0;Q<N.length;Q++){
+%_OneByteSeqStringSetChar(Q,N[Q],h);
+}
+return h;
+}
+function Decode(K,R){
+var M=K.length;
+var S=%NewString(M,true);
+var i=0;
+var P=0;
+for(;P<M;P++){
+var c=K.charCodeAt(P);
+if(c==37){
+if(P+2>=M)throw new $URIError("URI malformed");
+var d=URIHexCharsToCharCode(K.charCodeAt(P+1),K.charCodeAt(P+2));
+if(d>>7)break;
+if(R(d)){
+%_OneByteSeqStringSetChar(i++,37,S);
+%_OneByteSeqStringSetChar(i++,K.charCodeAt(P+1),S);
+%_OneByteSeqStringSetChar(i++,K.charCodeAt(P+2),S);
+}else{
+%_OneByteSeqStringSetChar(i++,d,S);
+}
+P+=2;
+}else{
+if(c>0x7f)break;
+%_OneByteSeqStringSetChar(i++,c,S);
+}
+}
+S=%TruncateString(S,i);
+if(P==M)return S;
+var T=%NewString(M-P,false);
+i=0;
+for(;P<M;P++){
+var c=K.charCodeAt(P);
+if(c==37){
+if(P+2>=M)throw new $URIError("URI malformed");
+var d=URIHexCharsToCharCode(K.charCodeAt(++P),K.charCodeAt(++P));
+if(d>>7){
+var U=0;
+while(((d<<++U)&0x80)!=0){}
+if(U==1||U>4)throw new $URIError("URI malformed");
+var j=new b(U);
+j[0]=d;
+if(P+3*(U-1)>=M)throw new $URIError("URI malformed");
+for(var Q=1;Q<U;Q++){
+if(K.charAt(++P)!='%')throw new $URIError("URI malformed");
+j[Q]=URIHexCharsToCharCode(K.charCodeAt(++P),
+K.charCodeAt(++P));
+}
+i=URIDecodeOctets(j,T,i);
+}else if(R(d)){
+%_TwoByteSeqStringSetChar(i++,37,T);
+%_TwoByteSeqStringSetChar(i++,K.charCodeAt(P-1),T);
+%_TwoByteSeqStringSetChar(i++,K.charCodeAt(P),T);
+}else{
+%_TwoByteSeqStringSetChar(i++,d,T);
+}
+}else{
+%_TwoByteSeqStringSetChar(i++,c,T);
+}
+}
+T=%TruncateString(T,i);
+return S+T;
+}
+function URIEscapeJS(W){
+var X=ToString(W);
+return %URIEscape(X);
+}
+function URIUnescapeJS(W){
+var X=ToString(W);
+return %URIUnescape(X);
+}
+function URIDecode(K){
+var Y=function(d){
+if(35<=d&&d<=36)return true;
+if(d==38)return true;
+if(43<=d&&d<=44)return true;
+if(d==47)return true;
+if(58<=d&&d<=59)return true;
+if(d==61)return true;
+if(63<=d&&d<=64)return true;
+return false;
+};
+var Z=ToString(K);
+return Decode(Z,Y);
+}
+function URIDecodeComponent(aa){
+var Y=function(d){return false;};
+var Z=ToString(aa);
+return Decode(Z,Y);
+}
+function URIEncode(K){
+var ab=function(d){
+if(isAlphaNumeric(d))return true;
+if(d==33)return true;
+if(35<=d&&d<=36)return true;
+if(38<=d&&d<=47)return true;
+if(58<=d&&d<=59)return true;
+if(d==61)return true;
+if(63<=d&&d<=64)return true;
+if(d==95)return true;
+if(d==126)return true;
+return false;
+};
+var Z=ToString(K);
+return Encode(Z,ab);
+}
+function URIEncodeComponent(aa){
+var ab=function(d){
+if(isAlphaNumeric(d))return true;
+if(d==33)return true;
+if(39<=d&&d<=42)return true;
+if(45<=d&&d<=46)return true;
+if(d==95)return true;
+if(d==126)return true;
+return false;
+};
+var Z=ToString(aa);
+return Encode(Z,ab);
+}
+InstallFunctions(global,2,[
+"escape",URIEscapeJS,
+"unescape",URIUnescapeJS,
+"decodeURI",URIDecode,
+"decodeURIComponent",URIDecodeComponent,
+"encodeURI",URIEncode,
+"encodeURIComponent",URIEncodeComponent
+]);
+})();
+
+\10mathM\
+var rngstate;
+var $abs;
+var $exp;
+var $floor;
+var $max;
+var $min;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Object;
+function MathAbs(b){
+b=+b;
+return(b>0)?b:0-b;
+}
+function MathAcosJS(b){
+return %_MathAcos(+b);
+}
+function MathAsinJS(b){
+return %_MathAsin(+b);
+}
+function MathAtanJS(b){
+return %_MathAtan(+b);
+}
+function MathAtan2JS(c,b){
+c=+c;
+b=+b;
+return %_MathAtan2(c,b);
+}
+function MathCeil(b){
+return-%_MathFloor(-b);
+}
+function MathExp(b){
+return %MathExpRT(((typeof(%IS_VAR(b))==='number')?b:NonNumberToNumber(b)));
+}
+function MathFloorJS(b){
+return %_MathFloor(+b);
+}
+function MathLog(b){
+return %_MathLogRT(((typeof(%IS_VAR(b))==='number')?b:NonNumberToNumber(b)));
+}
+function MathMax(d,e){
+var g=%_ArgumentsLength();
+if(g==2){
+d=((typeof(%IS_VAR(d))==='number')?d:NonNumberToNumber(d));
+e=((typeof(%IS_VAR(e))==='number')?e:NonNumberToNumber(e));
+if(e>d)return e;
+if(d>e)return d;
+if(d==e){
+return(d===0&&%_IsMinusZero(d))?e:d;
+}
+return $NaN;
+}
+var h=-(1/0);
+for(var i=0;i<g;i++){
+var j=%_Arguments(i);
+if(!(typeof(j)==='number'))j=NonNumberToNumber(j);
+if((!%_IsSmi(%IS_VAR(j))&&!(j==j))||j>h||(h===0&&j===0&&%_IsMinusZero(h))){
+h=j;
+}
+}
+return h;
+}
+function MathMin(d,e){
+var g=%_ArgumentsLength();
+if(g==2){
+d=((typeof(%IS_VAR(d))==='number')?d:NonNumberToNumber(d));
+e=((typeof(%IS_VAR(e))==='number')?e:NonNumberToNumber(e));
+if(e>d)return d;
+if(d>e)return e;
+if(d==e){
+return(d===0&&%_IsMinusZero(d))?d:e;
+}
+return $NaN;
+}
+var h=(1/0);
+for(var i=0;i<g;i++){
+var j=%_Arguments(i);
+if(!(typeof(j)==='number'))j=NonNumberToNumber(j);
+if((!%_IsSmi(%IS_VAR(j))&&!(j==j))||j<h||(h===0&&j===0&&%_IsMinusZero(j))){
+h=j;
+}
+}
+return h;
+}
+function MathPowJS(b,c){
+return %_MathPow(((typeof(%IS_VAR(b))==='number')?b:NonNumberToNumber(b)),((typeof(%IS_VAR(c))==='number')?c:NonNumberToNumber(c)));
+}
+function MathRandom(){
+var k=(MathImul(18030,rngstate[0]&0xFFFF)+(rngstate[0]>>>16))|0;
+rngstate[0]=k;
+var l=(MathImul(36969,rngstate[1]&0xFFFF)+(rngstate[1]>>>16))|0;
+rngstate[1]=l;
+var b=((k<<16)+(l&0xFFFF))|0;
+return(b<0?(b+0x100000000):b)*2.3283064365386962890625e-10;
+}
+function MathRound(b){
+return %RoundNumber(((typeof(%IS_VAR(b))==='number')?b:NonNumberToNumber(b)));
+}
+function MathSqrtJS(b){
+return %_MathSqrt(+b);
+}
+function MathImul(b,c){
+return %NumberImul(((typeof(%IS_VAR(b))==='number')?b:NonNumberToNumber(b)),((typeof(%IS_VAR(c))==='number')?c:NonNumberToNumber(c)));
+}
+function MathSign(b){
+b=+b;
+if(b>0)return 1;
+if(b<0)return-1;
+return b;
+}
+function MathTrunc(b){
+b=+b;
+if(b>0)return %_MathFloor(b);
+if(b<0)return-%_MathFloor(-b);
+return b;
+}
+function MathTanh(b){
+if(!(typeof(b)==='number'))b=NonNumberToNumber(b);
+if(b===0)return b;
+if(!(%_IsSmi(%IS_VAR(b))||((b==b)&&(b!=1/0)&&(b!=-1/0))))return MathSign(b);
+var m=MathExp(b);
+var n=MathExp(-b);
+return(m-n)/(m+n);
+}
+function MathAsinh(b){
+if(!(typeof(b)==='number'))b=NonNumberToNumber(b);
+if(b===0||!(%_IsSmi(%IS_VAR(b))||((b==b)&&(b!=1/0)&&(b!=-1/0))))return b;
+if(b>0)return MathLog(b+%_MathSqrt(b*b+1));
+return-MathLog(-b+%_MathSqrt(b*b+1));
+}
+function MathAcosh(b){
+if(!(typeof(b)==='number'))b=NonNumberToNumber(b);
+if(b<1)return $NaN;
+if(!(%_IsSmi(%IS_VAR(b))||((b==b)&&(b!=1/0)&&(b!=-1/0))))return b;
+return MathLog(b+%_MathSqrt(b+1)*%_MathSqrt(b-1));
+}
+function MathAtanh(b){
+if(!(typeof(b)==='number'))b=NonNumberToNumber(b);
+if(b===0)return b;
+if(!(%_IsSmi(%IS_VAR(b))||((b==b)&&(b!=1/0)&&(b!=-1/0))))return $NaN;
+return 0.5*MathLog((1+b)/(1-b));
+}
+function MathHypot(b,c){
+var g=%_ArgumentsLength();
+var o=new InternalArray(g);
+var q=0;
+for(var i=0;i<g;i++){
+var j=%_Arguments(i);
+if(!(typeof(j)==='number'))j=NonNumberToNumber(j);
+if(j===(1/0)||j===-(1/0))return(1/0);
+j=MathAbs(j);
+if(j>q)q=j;
+o[i]=j;
+}
+if(q===0)q=1;
+var r=0;
+var t=0;
+for(var i=0;i<g;i++){
+var j=o[i]/q;
+var u=j*j-t;
+var w=r+u;
+t=(w-r)-u;
+r=w;
+}
+return %_MathSqrt(r)*q;
+}
+function MathFroundJS(b){
+return %MathFround(((typeof(%IS_VAR(b))==='number')?b:NonNumberToNumber(b)));
+}
+function MathClz32JS(b){
+return %_MathClz32(b>>>0);
+}
+function MathCbrt(b){
+if(!(typeof(b)==='number'))b=NonNumberToNumber(b);
+if(b==0||!(%_IsSmi(%IS_VAR(b))||((b==b)&&(b!=1/0)&&(b!=-1/0))))return b;
+return b>=0?CubeRoot(b):-CubeRoot(-b);
+}
+function CubeRoot(b){
+var z=MathFloorJS(%_DoubleHi(b)/3)+0x2A9F7893;
+var A=%_ConstructDouble(z,0);
+A=(1.0/3.0)*(b/(A*A)+2*A);
+;
+A=(1.0/3.0)*(b/(A*A)+2*A);
+;
+A=(1.0/3.0)*(b/(A*A)+2*A);
+;
+return(1.0/3.0)*(b/(A*A)+2*A);
+;
+}
+function MathConstructor(){}
+var B=new MathConstructor();
+%InternalSetPrototype(B,a.prototype);
+%AddNamedProperty(global,"Math",B,2);
+%FunctionSetInstanceClassName(MathConstructor,'Math');
+%AddNamedProperty(B,symbolToStringTag,"Math",1|2);
+InstallConstants(B,[
+"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
+]);
+InstallFunctions(B,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,
+"tanh",MathTanh,
+"asinh",MathAsinh,
+"acosh",MathAcosh,
+"atanh",MathAtanh,
+"hypot",MathHypot,
+"fround",MathFroundJS,
+"clz32",MathClz32JS,
+"cbrt",MathCbrt
+]);
+%SetInlineBuiltinFlag(MathAbs);
+%SetInlineBuiltinFlag(MathAcosJS);
+%SetInlineBuiltinFlag(MathAsinJS);
+%SetInlineBuiltinFlag(MathAtanJS);
+%SetInlineBuiltinFlag(MathAtan2JS);
+%SetInlineBuiltinFlag(MathCeil);
+%SetInlineBuiltinFlag(MathClz32JS);
+%SetInlineBuiltinFlag(MathFloorJS);
+%SetInlineBuiltinFlag(MathRandom);
+%SetInlineBuiltinFlag(MathSign);
+%SetInlineBuiltinFlag(MathSqrtJS);
+%SetInlineBuiltinFlag(MathTrunc);
+$abs=MathAbs;
+$exp=MathExp;
+$floor=MathFloorJS;
+$max=MathMax;
+$min=MathMin;
+})();
+
+\18fdlibme¨
+var kMath;
+var rempio2result;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Math;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function KernelTan(b,c,d){
+var e;
+var g;
+var h=%_DoubleHi(b);
+var i=h&0x7fffffff;
+if(i<0x3e300000){
+if(((i|%_DoubleLo(b))|(d+1))==0){
+return 1/$abs(b);
+}else{
+if(d==1){
+return b;
+}else{
+var g=b+c;
+var e=%_ConstructDouble(%_DoubleHi(g),0);
+var j=c-(e-b);
+var k=-1/g;
+var l=%_ConstructDouble(%_DoubleHi(k),0);
+var m=1+l*e;
+return l+k*(m+l*j);
+}
+}
+}
+if(i>=0x3fe59428){
+if(b<0){
+b=-b;
+c=-c;
+}
+e=kMath[32]-b;
+g=kMath[33]-c;
+b=e+g;
+c=0;
+}
+e=b*b;
+g=e*e;
+var n=kMath[19+1]
++g*(kMath[19+3]
++g*(kMath[19+5]
++
+g*(kMath[19+7]
++g*(kMath[19+9]
++g*kMath[19+11]
+))));
+var j=e*(kMath[19+2]
++g*(kMath[19+4]
++g*(kMath[19+6]
++
+g*(kMath[19+8]
++g*(kMath[19+10]
++g*kMath[19+12]
+)))));
+var m=e*b;
+n=c+e*(m*(n+j)+c);
+n=n+kMath[19+0]
+*m;
+g=b+n;
+if(i>=0x3fe59428){
+return(1-((h>>30)&2))*
+(d-2.0*(b-(g*g/(g+d)-n)));
+}
+if(d==1){
+return g;
+}else{
+e=%_ConstructDouble(%_DoubleHi(g),0);
+j=n-(e-b);
+var k=-1/g;
+var l=%_ConstructDouble(%_DoubleHi(k),0);
+m=1+l*e;
+return l+k*(m+l*j);
+}
+}
+function MathSinSlow(b){
+var o,q,r;
+var h=%_DoubleHi(b);
+var i=h&0x7fffffff;
+if(i<0x4002d97c){
+if(h>0){
+var e=b-kMath[1];
+if(i!=0x3ff921fb){
+q=e-kMath[2];
+r=(e-q)-kMath[2];
+}else{
+e-=kMath[3];
+q=e-kMath[4];
+r=(e-q)-kMath[4];
+}
+o=1;
+}else{
+var e=b+kMath[1];
+if(i!=0x3ff921fb){
+q=e+kMath[2];
+r=(e-q)+kMath[2];
+}else{
+e+=kMath[3];
+q=e+kMath[4];
+r=(e-q)+kMath[4];
+}
+o=-1;
+}
+}else if(i<=0x413921fb){
+var l=$abs(b);
+o=(l*kMath[0]+0.5)|0;
+var n=l-o*kMath[1];
+var g=o*kMath[2];
+q=n-g;
+if(i-(%_DoubleHi(q)&0x7ff00000)>0x1000000){
+l=n;
+g=o*kMath[3];
+n=l-g;
+g=o*kMath[4]-((l-n)-g);
+q=n-g;
+if(i-(%_DoubleHi(q)&0x7ff00000)>0x3100000){
+l=n;
+g=o*kMath[5];
+n=l-g;
+g=o*kMath[6]-((l-n)-g);
+q=n-g;
+}
+}
+r=(n-q)-g;
+if(h<0){
+o=-o;
+q=-q;
+r=-r;
+}
+}else{
+o=%RemPiO2(b,rempio2result);
+q=rempio2result[0];
+r=rempio2result[1];
+}
+;
+var t=1-(o&2);
+if(o&1){
+var i=%_DoubleHi(q)&0x7fffffff;
+var e=q*q;
+var n=e*(4.16666666666666019037e-02+e*(-1.38888888888741095749e-03+e*(2.48015872894767294178e-05+e*(-2.75573143513906633035e-07+e*(2.08757232129817482790e-09+e*-1.13596475577881948265e-11)))));
+if(i<0x3fd33333){
+return(1-(0.5*e-(e*n-q*r)))*t;
+}else{
+var u;
+if(i>0x3fe90000){
+u=0.28125;
+}else{
+u=%_ConstructDouble(%_DoubleHi(0.25*q),0);
+}
+var w=0.5*e-u;
+return(1-u-(w-(e*n-q*r)))*t;
+}
+;
+}else{
+var e=q*q;
+var j=e*q;
+var n=8.33333333332248946124e-03+e*(-1.98412698298579493134e-04+e*(2.75573137070700676789e-06+e*(-2.50507602534068634195e-08+e*1.58969099521155010221e-10)));
+return(q-((e*(0.5*r-j*n)-r)-j*-1.66666666666666324348e-01))*t;
+;
+}
+}
+function MathCosSlow(b){
+var o,q,r;
+var h=%_DoubleHi(b);
+var i=h&0x7fffffff;
+if(i<0x4002d97c){
+if(h>0){
+var e=b-kMath[1];
+if(i!=0x3ff921fb){
+q=e-kMath[2];
+r=(e-q)-kMath[2];
+}else{
+e-=kMath[3];
+q=e-kMath[4];
+r=(e-q)-kMath[4];
+}
+o=1;
+}else{
+var e=b+kMath[1];
+if(i!=0x3ff921fb){
+q=e+kMath[2];
+r=(e-q)+kMath[2];
+}else{
+e+=kMath[3];
+q=e+kMath[4];
+r=(e-q)+kMath[4];
+}
+o=-1;
+}
+}else if(i<=0x413921fb){
+var l=$abs(b);
+o=(l*kMath[0]+0.5)|0;
+var n=l-o*kMath[1];
+var g=o*kMath[2];
+q=n-g;
+if(i-(%_DoubleHi(q)&0x7ff00000)>0x1000000){
+l=n;
+g=o*kMath[3];
+n=l-g;
+g=o*kMath[4]-((l-n)-g);
+q=n-g;
+if(i-(%_DoubleHi(q)&0x7ff00000)>0x3100000){
+l=n;
+g=o*kMath[5];
+n=l-g;
+g=o*kMath[6]-((l-n)-g);
+q=n-g;
+}
+}
+r=(n-q)-g;
+if(h<0){
+o=-o;
+q=-q;
+r=-r;
+}
+}else{
+o=%RemPiO2(b,rempio2result);
+q=rempio2result[0];
+r=rempio2result[1];
+}
+;
+if(o&1){
+var t=(o&2)-1;
+var e=q*q;
+var j=e*q;
+var n=8.33333333332248946124e-03+e*(-1.98412698298579493134e-04+e*(2.75573137070700676789e-06+e*(-2.50507602534068634195e-08+e*1.58969099521155010221e-10)));
+return(q-((e*(0.5*r-j*n)-r)-j*-1.66666666666666324348e-01))*t;
+;
+}else{
+var t=1-(o&2);
+var i=%_DoubleHi(q)&0x7fffffff;
+var e=q*q;
+var n=e*(4.16666666666666019037e-02+e*(-1.38888888888741095749e-03+e*(2.48015872894767294178e-05+e*(-2.75573143513906633035e-07+e*(2.08757232129817482790e-09+e*-1.13596475577881948265e-11)))));
+if(i<0x3fd33333){
+return(1-(0.5*e-(e*n-q*r)))*t;
+}else{
+var u;
+if(i>0x3fe90000){
+u=0.28125;
+}else{
+u=%_ConstructDouble(%_DoubleHi(0.25*q),0);
+}
+var w=0.5*e-u;
+return(1-u-(w-(e*n-q*r)))*t;
+}
+;
+}
+}
+function MathSin(b){
+b=+b;
+if((%_DoubleHi(b)&0x7fffffff)<=0x3fe921fb){
+var e=b*b;
+var j=e*b;
+var n=8.33333333332248946124e-03+e*(-1.98412698298579493134e-04+e*(2.75573137070700676789e-06+e*(-2.50507602534068634195e-08+e*1.58969099521155010221e-10)));
+return(b-((e*(0.5*0-j*n)-0)-j*-1.66666666666666324348e-01));
+;
+}
+return+MathSinSlow(b);
+}
+function MathCos(b){
+b=+b;
+if((%_DoubleHi(b)&0x7fffffff)<=0x3fe921fb){
+var i=%_DoubleHi(b)&0x7fffffff;
+var e=b*b;
+var n=e*(4.16666666666666019037e-02+e*(-1.38888888888741095749e-03+e*(2.48015872894767294178e-05+e*(-2.75573143513906633035e-07+e*(2.08757232129817482790e-09+e*-1.13596475577881948265e-11)))));
+if(i<0x3fd33333){
+return(1-(0.5*e-(e*n-b*0)));
+}else{
+var u;
+if(i>0x3fe90000){
+u=0.28125;
+}else{
+u=%_ConstructDouble(%_DoubleHi(0.25*b),0);
+}
+var w=0.5*e-u;
+return(1-u-(w-(e*n-b*0)));
+}
+;
+}
+return+MathCosSlow(b);
+}
+function MathTan(b){
+b=b*1;
+if((%_DoubleHi(b)&0x7fffffff)<=0x3fe921fb){
+return KernelTan(b,0,1);
+}
+var o,q,r;
+var h=%_DoubleHi(b);
+var i=h&0x7fffffff;
+if(i<0x4002d97c){
+if(h>0){
+var e=b-kMath[1];
+if(i!=0x3ff921fb){
+q=e-kMath[2];
+r=(e-q)-kMath[2];
+}else{
+e-=kMath[3];
+q=e-kMath[4];
+r=(e-q)-kMath[4];
+}
+o=1;
+}else{
+var e=b+kMath[1];
+if(i!=0x3ff921fb){
+q=e+kMath[2];
+r=(e-q)+kMath[2];
+}else{
+e+=kMath[3];
+q=e+kMath[4];
+r=(e-q)+kMath[4];
+}
+o=-1;
+}
+}else if(i<=0x413921fb){
+var l=$abs(b);
+o=(l*kMath[0]+0.5)|0;
+var n=l-o*kMath[1];
+var g=o*kMath[2];
+q=n-g;
+if(i-(%_DoubleHi(q)&0x7ff00000)>0x1000000){
+l=n;
+g=o*kMath[3];
+n=l-g;
+g=o*kMath[4]-((l-n)-g);
+q=n-g;
+if(i-(%_DoubleHi(q)&0x7ff00000)>0x3100000){
+l=n;
+g=o*kMath[5];
+n=l-g;
+g=o*kMath[6]-((l-n)-g);
+q=n-g;
+}
+}
+r=(n-q)-g;
+if(h<0){
+o=-o;
+q=-q;
+r=-r;
+}
+}else{
+o=%RemPiO2(b,rempio2result);
+q=rempio2result[0];
+r=rempio2result[1];
+}
+;
+return KernelTan(q,r,(o&1)?-1:1);
+}
+
+
+
+
+function MathLog1p(b){
+b=b*1;
+var h=%_DoubleHi(b);
+var z=h&0x7fffffff;
+var A=1;
+var B=b;
+var C=1;
+var D=0;
+var E=b;
+if(h<0x3fda827a){
+if(z>=0x3ff00000){
+if(b===-1){
+return-(1/0);
+}else{
+return $NaN;
+}
+}else if(z<0x3c900000){
+return b;
+}else if(z<0x3e200000){
+return b-b*b*0.5;
+}
+if((h>0)||(h<=-0x402D413D)){
+A=0;
+}
+}
+if(h>=0x7ff00000)return b;
+if(A!==0){
+if(h<0x43400000){
+E=1+b;
+C=%_DoubleHi(E);
+A=(C>>20)-1023;
+D=(A>0)?1-(E-b):b-(E-1);
+D=D/E;
+}else{
+C=%_DoubleHi(E);
+A=(C>>20)-1023;
+}
+C=C&0xfffff;
+if(C<0x6a09e){
+E=%_ConstructDouble(C|0x3ff00000,%_DoubleLo(E));
+}else{
+++A;
+E=%_ConstructDouble(C|0x3fe00000,%_DoubleLo(E));
+C=(0x00100000-C)>>2;
+}
+B=E-1;
+}
+var G=0.5*B*B;
+if(C===0){
+if(B===0){
+if(A===0){
+return 0.0;
+}else{
+return A*kMath[34]+(D+A*kMath[35]);
+}
+}
+var H=G*(1-kMath[36]*B);
+if(A===0){
+return B-H;
+}else{
+return A*kMath[34]-((H-(A*kMath[35]+D))-B);
+}
+}
+var m=B/(2+B);
+var e=m*m;
+var H=e*((kMath[37+0])
++e*((kMath[37+1])
++e*
+((kMath[37+2])
++e*((kMath[37+3])
++e*
+((kMath[37+4])
++e*((kMath[37+5])
++e*(kMath[37+6])
+))))));
+if(A===0){
+return B-(G-m*(G+H));
+}else{
+return A*kMath[34]-((G-(m*(G+H)+(A*kMath[35]+D)))-B);
+}
+}
+
+
+function MathExpm1(b){
+b=b*1;
+var c;
+var I;
+var J;
+var A;
+var l;
+var D;
+var h=%_DoubleHi(b);
+var K=h&0x80000000;
+var c=(K===0)?b:-b;
+h&=0x7fffffff;
+if(h>=0x4043687a){
+if(h>=0x40862e42){
+if(h>=0x7ff00000){
+return(b===-(1/0))?-1:b;
+}
+if(b>kMath[44])return(1/0);
+}
+if(K!=0)return-1;
+}
+if(h>0x3fd62e42){
+if(h<0x3ff0a2b2){
+if(K===0){
+I=b-kMath[34];
+J=kMath[35];
+A=1;
+}else{
+I=b+kMath[34];
+J=-kMath[35];
+A=-1;
+}
+}else{
+A=(kMath[45]*b+((K===0)?0.5:-0.5))|0;
+l=A;
+I=b-l*kMath[34];
+J=l*kMath[35];
+}
+b=I-J;
+D=(I-b)-J;
+}else if(h<0x3c900000){
+return b;
+}else{
+A=0;
+}
+var L=0.5*b;
+var M=b*L;
+var N=1+M*((kMath[46+0])
++M*((kMath[46+1])
++M*
+((kMath[46+2])
++M*((kMath[46+3])
++M*(kMath[46+4])
+))));
+l=3-N*L;
+var P=M*((N-l)/(6-b*l));
+if(A===0){
+return b-(b*P-M);
+}else{
+P=(b*(P-D)-D);
+P-=M;
+if(A===-1)return 0.5*(b-P)-0.5;
+if(A===1){
+if(b<-0.25)return-2*(P-(b+0.5));
+return 1+2*(b-P);
+}
+if(A<=-2||A>56){
+c=1-(P-b);
+c=%_ConstructDouble(%_DoubleHi(c)+(A<<20),%_DoubleLo(c));
+return c-1;
+}
+if(A<20){
+l=%_ConstructDouble(0x3ff00000-(0x200000>>A),0);
+c=l-(P-b);
+c=%_ConstructDouble(%_DoubleHi(c)+(A<<20),%_DoubleLo(c));
+}else{
+l=%_ConstructDouble((0x3ff-A)<<20,0);
+c=b-(P+l);
+c+=1;
+c=%_ConstructDouble(%_DoubleHi(c)+(A<<20),%_DoubleLo(c));
+}
+}
+return c;
+}
+
+
+
+function MathSinh(b){
+b=b*1;
+var Q=(b<0)?-0.5:0.5;
+var z=$abs(b);
+if(z<22){
+if(z<3.725290298461914e-9)return b;
+var l=MathExpm1(z);
+if(z<1)return Q*(2*l-l*l/(l+1));
+return Q*(l+l/(l+1));
+}
+if(z<709.7822265625)return Q*$exp(z);
+if(z<=kMath[51]){
+var g=$exp(0.5*z);
+var l=Q*g;
+return l*g;
+}
+return b*(1/0);
+}
+
+function MathCosh(b){
+b=b*1;
+var i=%_DoubleHi(b)&0x7fffffff;
+if(i<0x3fd62e43){
+var l=MathExpm1($abs(b));
+var g=1+l;
+if(i<0x3c800000)return g;
+return 1+(l*l)/(g+g);
+}
+if(i<0x40360000){
+var l=$exp($abs(b));
+return 0.5*l+0.5/l;
+}
+if(i<0x40862e42)return 0.5*$exp($abs(b));
+if($abs(b)<=kMath[51]){
+var g=$exp(0.5*$abs(b));
+var l=0.5*g;
+return l*g;
+}
+if((!%_IsSmi(%IS_VAR(b))&&!(b==b)))return b;
+return(1/0);
+}
+
+
+
+function MathLog10(b){
+b=b*1;
+var h=%_DoubleHi(b);
+var R=%_DoubleLo(b);
+var A=0;
+if(h<0x00100000){
+if(((h&0x7fffffff)|R)===0)return-(1/0);
+if(h<0)return $NaN;
+A-=54;
+b*=18014398509481984;
+h=%_DoubleHi(b);
+R=%_DoubleLo(b);
+}
+if(h>=0x7ff00000)return b;
+A+=(h>>20)-1023;
+var S=(A&0x80000000)>>>31;
+h=(h&0x000fffff)|((0x3ff-S)<<20);
+var c=A+S;
+b=%_ConstructDouble(h,R);
+var e=c*kMath[54]+kMath[52]*%_MathLogRT(b);
+return e+c*kMath[53];
+}
+
+
+
+
+
+
+function MathLog2(b){
+b=b*1;
+var z=$abs(b);
+var h=%_DoubleHi(b);
+var R=%_DoubleLo(b);
+var i=h&0x7fffffff;
+if((i|R)==0)return-(1/0);
+if(h<0)return $NaN;
+if(i>=0x7ff00000)return b;
+var o=0;
+if(i<0x00100000){
+z*=9007199254740992;
+o-=53;
+i=%_DoubleHi(z);
+}
+o+=(i>>20)-0x3ff;
+var T=i&0x000fffff;
+i=T|0x3ff00000;
+var U=1;
+var W=0;
+var X=0;
+if(T>0x3988e){
+if(T<0xbb67a){
+U=1.5;
+W=kMath[64];
+X=kMath[65];
+}else{
+o+=1;
+i-=0x00100000;
+}
+}
+z=%_ConstructDouble(i,%_DoubleLo(z));
+var E=z-U;
+var j=1/(z+U);
+var Y=E*j;
+var Z=%_ConstructDouble(%_DoubleHi(Y),0);
+var aa=%_ConstructDouble(%_DoubleHi(z+U),0)
+var ab=z-(aa-U);
+var ac=j*((E-Z*aa)-Z*ab);
+var ad=Y*Y;
+var n=ad*ad*((kMath[55+0])
++ad*((kMath[55+1])
++ad*((kMath[55+2])
++ad*(
+(kMath[55+3])
++ad*((kMath[55+4])
++ad*(kMath[55+5])
+)))));
+n+=ac*(Z+Y);
+ad=Z*Z;
+aa=%_ConstructDouble(%_DoubleHi(3.0+ad+n),0);
+ab=n-((aa-3.0)-ad);
+E=Z*aa;
+j=ac*aa+ab*Y;
+p_h=%_ConstructDouble(%_DoubleHi(E+j),0);
+p_l=j-(p_h-E);
+z_h=kMath[62]*p_h;
+z_l=kMath[63]*p_h+p_l*kMath[61]+X;
+var l=o;
+var ae=%_ConstructDouble(%_DoubleHi(((z_h+z_l)+W)+l),0);
+var af=z_l-(((ae-l)-W)-z_h);
+return ae+af;
+}
+InstallFunctions(a,2,[
+"cos",MathCos,
+"sin",MathSin,
+"tan",MathTan,
+"sinh",MathSinh,
+"cosh",MathCosh,
+"log10",MathLog10,
+"log2",MathLog2,
+"log1p",MathLog1p,
+"expm1",MathExpm1
+]);
+%SetInlineBuiltinFlag(MathSin);
+%SetInlineBuiltinFlag(MathCos);
+})();
+
+\10dateAå
+var $createDate;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Date;
+function ThrowDateTypeError(){
+throw new $TypeError('this is not a Date object.');
+}
+var b=$NaN;
+var c;
+function LocalTimezone(d){
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))return"";
+CheckDateCacheCurrent();
+if(d==b){
+return c;
+}
+var e=%DateLocalTimezone(d);
+b=d;
+c=e;
+return e;
+}
+function UTC(g){
+if((!%_IsSmi(%IS_VAR(g))&&!(g==g)))return g;
+return %DateToUTC(g);
+}
+function MakeTime(h,i,j,k){
+if(!$isFinite(h))return $NaN;
+if(!$isFinite(i))return $NaN;
+if(!$isFinite(j))return $NaN;
+if(!$isFinite(k))return $NaN;
+return(%_IsSmi(%IS_VAR(h))?h:%NumberToInteger(ToNumber(h)))*3600000
++(%_IsSmi(%IS_VAR(i))?i:%NumberToInteger(ToNumber(i)))*60000
++(%_IsSmi(%IS_VAR(j))?j:%NumberToInteger(ToNumber(j)))*1000
++(%_IsSmi(%IS_VAR(k))?k:%NumberToInteger(ToNumber(k)));
+}
+function TimeInYear(l){
+return DaysInYear(l)*86400000;
+}
+function MakeDay(l,m,n){
+if(!$isFinite(l)||!$isFinite(m)||!$isFinite(n))return $NaN;
+l=(%_IsSmi(%IS_VAR(l))?l:%NumberToIntegerMapMinusZero(ToNumber(l)));
+m=(%_IsSmi(%IS_VAR(m))?m:%NumberToIntegerMapMinusZero(ToNumber(m)));
+n=(%_IsSmi(%IS_VAR(n))?n:%NumberToIntegerMapMinusZero(ToNumber(n)));
+if(l<-1000000||l>1000000||
+m<-10000000||m>10000000){
+return $NaN;
+}
+return %DateMakeDay(l|0,m|0)+n-1;
+}
+function MakeDate(o,g){
+var g=o*86400000+g;
+if($abs(g)>8640002592000000)return $NaN;
+return g;
+}
+function TimeClip(g){
+if(!$isFinite(g))return $NaN;
+if($abs(g)>8640000000000000)return $NaN;
+return(%_IsSmi(%IS_VAR(g))?g:%NumberToInteger(ToNumber(g)));
+}
+var q={
+time:0,
+string:null
+};
+function DateConstructor(l,m,n,r,t,u,k){
+if(!%_IsConstructCall()){
+return(new a()).toString();
+}
+var w=%_ArgumentsLength();
+var z;
+if(w==0){
+z=%DateCurrentTime();
+(%DateSetValue(this,z,1));
+}else if(w==1){
+if((typeof(l)==='number')){
+z=l;
+}else if((typeof(l)==='string')){
+CheckDateCacheCurrent();
+var A=q;
+if(A.string===l){
+z=A.time;
+}else{
+z=DateParse(l);
+if(!(!%_IsSmi(%IS_VAR(z))&&!(z==z))){
+A.time=z;
+A.string=l;
+}
+}
+}else{
+var g=ToPrimitive(l,1);
+z=(typeof(g)==='string')?DateParse(g):ToNumber(g);
+}
+(%DateSetValue(this,z,1));
+}else{
+l=ToNumber(l);
+m=ToNumber(m);
+n=w>2?ToNumber(n):1;
+r=w>3?ToNumber(r):0;
+t=w>4?ToNumber(t):0;
+u=w>5?ToNumber(u):0;
+k=w>6?ToNumber(k):0;
+l=(!(!%_IsSmi(%IS_VAR(l))&&!(l==l))&&
+0<=(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l)))&&
+(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l)))<=99)?1900+(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l))):l;
+var o=MakeDay(l,m,n);
+var g=MakeTime(r,t,u,k);
+z=MakeDate(o,g);
+(%DateSetValue(this,z,0));
+}
+}
+var B=['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
+var C=['Jan','Feb','Mar','Apr','May','Jun',
+'Jul','Aug','Sep','Oct','Nov','Dec'];
+function TwoDigitString(z){
+return z<10?"0"+z:""+z;
+}
+function DateString(n){
+return B[(%_DateField(n,4))]+' '
++C[(%_DateField(n,2))]+' '
++TwoDigitString((%_DateField(n,3)))+' '
++(%_DateField(n,1));
+}
+var D=['Sunday','Monday','Tuesday','Wednesday',
+'Thursday','Friday','Saturday'];
+var E=['January','February','March','April','May','June',
+'July','August','September','October','November','December'];
+function LongDateString(n){
+return D[(%_DateField(n,4))]+', '
++E[(%_DateField(n,2))]+' '
++TwoDigitString((%_DateField(n,3)))+', '
++(%_DateField(n,1));
+}
+function TimeString(n){
+return TwoDigitString((%_DateField(n,5)))+':'
++TwoDigitString((%_DateField(n,6)))+':'
++TwoDigitString((%_DateField(n,7)));
+}
+function TimeStringUTC(n){
+return TwoDigitString((%_DateField(n,15)))+':'
++TwoDigitString((%_DateField(n,16)))+':'
++TwoDigitString((%_DateField(n,17)));
+}
+function LocalTimezoneString(n){
+var e=LocalTimezone((%_DateField(n,0)));
+var G=-(%_DateField(n,21));
+var H=(G>=0)?1:-1;
+var r=$floor((H*G)/60);
+var i=$floor((H*G)%60);
+var I=' GMT'+((H==1)?'+':'-')+
+TwoDigitString(r)+TwoDigitString(i);
+return I+' ('+e+')';
+}
+function DatePrintString(n){
+return DateString(n)+' '+TimeString(n);
+}
+var J=new InternalArray(8);
+function DateParse(K){
+var L=%DateParseString(ToString(K),J);
+if((L===null))return $NaN;
+var o=MakeDay(L[0],L[1],L[2]);
+var g=MakeTime(L[3],L[4],L[5],L[6]);
+var n=MakeDate(o,g);
+if((L[7]===null)){
+return TimeClip(UTC(n));
+}else{
+return TimeClip(n-L[7]*1000);
+}
+}
+function DateUTC(l,m,n,r,t,u,k){
+l=ToNumber(l);
+m=ToNumber(m);
+var w=%_ArgumentsLength();
+n=w>2?ToNumber(n):1;
+r=w>3?ToNumber(r):0;
+t=w>4?ToNumber(t):0;
+u=w>5?ToNumber(u):0;
+k=w>6?ToNumber(k):0;
+l=(!(!%_IsSmi(%IS_VAR(l))&&!(l==l))&&
+0<=(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l)))&&
+(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l)))<=99)?1900+(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l))):l;
+var o=MakeDay(l,m,n);
+var g=MakeTime(r,t,u,k);
+return TimeClip(MakeDate(o,g));
+}
+function DateNow(){
+return %DateCurrentTime();
+}
+function DateToString(){
+var d=(%_DateField(this,0))
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))return'Invalid Date';
+var M=LocalTimezoneString(this)
+return DatePrintString(this)+M;
+}
+function DateToDateString(){
+var d=(%_DateField(this,0));
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))return'Invalid Date';
+return DateString(this);
+}
+function DateToTimeString(){
+var d=(%_DateField(this,0));
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))return'Invalid Date';
+var M=LocalTimezoneString(this);
+return TimeString(this)+M;
+}
+function DateToLocaleString(){
+return %_CallFunction(this,DateToString);
+}
+function DateToLocaleDateString(){
+var d=(%_DateField(this,0));
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))return'Invalid Date';
+return LongDateString(this);
+}
+function DateToLocaleTimeString(){
+var d=(%_DateField(this,0));
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))return'Invalid Date';
+return TimeString(this);
+}
+function DateValueOf(){
+return(%_DateField(this,0));
+}
+function DateGetTime(){
+return(%_DateField(this,0));
+}
+function DateGetFullYear(){
+return(%_DateField(this,1));
+}
+function DateGetUTCFullYear(){
+return(%_DateField(this,11));
+}
+function DateGetMonth(){
+return(%_DateField(this,2));
+}
+function DateGetUTCMonth(){
+return(%_DateField(this,12));
+}
+function DateGetDate(){
+return(%_DateField(this,3));
+}
+function DateGetUTCDate(){
+return(%_DateField(this,13));
+}
+function DateGetDay(){
+return(%_DateField(this,4));
+}
+function DateGetUTCDay(){
+return(%_DateField(this,14));
+}
+function DateGetHours(){
+return(%_DateField(this,5));
+}
+function DateGetUTCHours(){
+return(%_DateField(this,15));
+}
+function DateGetMinutes(){
+return(%_DateField(this,6));
+}
+function DateGetUTCMinutes(){
+return(%_DateField(this,16));
+}
+function DateGetSeconds(){
+return(%_DateField(this,7));
+}
+function DateGetUTCSeconds(){
+return(%_DateField(this,17))
+}
+function DateGetMilliseconds(){
+return(%_DateField(this,8));
+}
+function DateGetUTCMilliseconds(){
+return(%_DateField(this,18));
+}
+function DateGetTimezoneOffset(){
+return(%_DateField(this,21));
+}
+function DateSetTime(k){
+if(%_ClassOf(this)!=='Date')ThrowDateTypeError();
+(%DateSetValue(this,ToNumber(k),1));
+return(%_DateField(this,0));
+}
+function DateSetMilliseconds(k){
+var d=(%_DateField(this,0)+%_DateField(this,21));
+k=ToNumber(k);
+var g=MakeTime((%_DateField(this,5)),(%_DateField(this,6)),(%_DateField(this,7)),k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,9)),g),0));
+}
+function DateSetUTCMilliseconds(k){
+var d=(%_DateField(this,0));
+k=ToNumber(k);
+var g=MakeTime((%_DateField(this,15)),
+(%_DateField(this,16)),
+(%_DateField(this,17)),
+k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,19)),g),1));
+}
+function DateSetSeconds(j,k){
+var d=(%_DateField(this,0)+%_DateField(this,21));
+j=ToNumber(j);
+k=%_ArgumentsLength()<2?(%_DateField(this,8)):ToNumber(k);
+var g=MakeTime((%_DateField(this,5)),(%_DateField(this,6)),j,k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,9)),g),0));
+}
+function DateSetUTCSeconds(j,k){
+var d=(%_DateField(this,0));
+j=ToNumber(j);
+k=%_ArgumentsLength()<2?(%_DateField(this,18)):ToNumber(k);
+var g=MakeTime((%_DateField(this,15)),(%_DateField(this,16)),j,k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,19)),g),1));
+}
+function DateSetMinutes(i,j,k){
+var d=(%_DateField(this,0)+%_DateField(this,21));
+i=ToNumber(i);
+var w=%_ArgumentsLength();
+j=w<2?(%_DateField(this,7)):ToNumber(j);
+k=w<3?(%_DateField(this,8)):ToNumber(k);
+var g=MakeTime((%_DateField(this,5)),i,j,k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,9)),g),0));
+}
+function DateSetUTCMinutes(i,j,k){
+var d=(%_DateField(this,0));
+i=ToNumber(i);
+var w=%_ArgumentsLength();
+j=w<2?(%_DateField(this,17)):ToNumber(j);
+k=w<3?(%_DateField(this,18)):ToNumber(k);
+var g=MakeTime((%_DateField(this,15)),i,j,k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,19)),g),1));
+}
+function DateSetHours(h,i,j,k){
+var d=(%_DateField(this,0)+%_DateField(this,21));
+h=ToNumber(h);
+var w=%_ArgumentsLength();
+i=w<2?(%_DateField(this,6)):ToNumber(i);
+j=w<3?(%_DateField(this,7)):ToNumber(j);
+k=w<4?(%_DateField(this,8)):ToNumber(k);
+var g=MakeTime(h,i,j,k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,9)),g),0));
+}
+function DateSetUTCHours(h,i,j,k){
+var d=(%_DateField(this,0));
+h=ToNumber(h);
+var w=%_ArgumentsLength();
+i=w<2?(%_DateField(this,16)):ToNumber(i);
+j=w<3?(%_DateField(this,17)):ToNumber(j);
+k=w<4?(%_DateField(this,18)):ToNumber(k);
+var g=MakeTime(h,i,j,k);
+return(%DateSetValue(this,MakeDate((%_DateField(this,19)),g),1));
+}
+function DateSetDate(n){
+var d=(%_DateField(this,0)+%_DateField(this,21));
+n=ToNumber(n);
+var o=MakeDay((%_DateField(this,1)),(%_DateField(this,2)),n);
+return(%DateSetValue(this,MakeDate(o,(%_DateField(this,10))),0));
+}
+function DateSetUTCDate(n){
+var d=(%_DateField(this,0));
+n=ToNumber(n);
+var o=MakeDay((%_DateField(this,11)),(%_DateField(this,12)),n);
+return(%DateSetValue(this,MakeDate(o,(%_DateField(this,20))),1));
+}
+function DateSetMonth(m,n){
+var d=(%_DateField(this,0)+%_DateField(this,21));
+m=ToNumber(m);
+n=%_ArgumentsLength()<2?(%_DateField(this,3)):ToNumber(n);
+var o=MakeDay((%_DateField(this,1)),m,n);
+return(%DateSetValue(this,MakeDate(o,(%_DateField(this,10))),0));
+}
+function DateSetUTCMonth(m,n){
+var d=(%_DateField(this,0));
+m=ToNumber(m);
+n=%_ArgumentsLength()<2?(%_DateField(this,13)):ToNumber(n);
+var o=MakeDay((%_DateField(this,11)),m,n);
+return(%DateSetValue(this,MakeDate(o,(%_DateField(this,20))),1));
+}
+function DateSetFullYear(l,m,n){
+var d=(%_DateField(this,0)+%_DateField(this,21));
+l=ToNumber(l);
+var w=%_ArgumentsLength();
+var g;
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d))){
+m=w<2?0:ToNumber(m);
+n=w<3?1:ToNumber(n);
+g=0;
+}else{
+m=w<2?(%_DateField(this,2)):ToNumber(m);
+n=w<3?(%_DateField(this,3)):ToNumber(n);
+g=(%_DateField(this,10));
+}
+var o=MakeDay(l,m,n);
+return(%DateSetValue(this,MakeDate(o,g),0));
+}
+function DateSetUTCFullYear(l,m,n){
+var d=(%_DateField(this,0));
+l=ToNumber(l);
+var w=%_ArgumentsLength();
+var g;
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d))){
+m=w<2?0:ToNumber(m);
+n=w<3?1:ToNumber(n);
+g=0;
+}else{
+m=w<2?(%_DateField(this,12)):ToNumber(m);
+n=w<3?(%_DateField(this,13)):ToNumber(n);
+g=(%_DateField(this,20));
+}
+var o=MakeDay(l,m,n);
+return(%DateSetValue(this,MakeDate(o,g),1));
+}
+function DateToUTCString(){
+var d=(%_DateField(this,0));
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))return'Invalid Date';
+return B[(%_DateField(this,14))]+', '
++TwoDigitString((%_DateField(this,13)))+' '
++C[(%_DateField(this,12))]+' '
++(%_DateField(this,11))+' '
++TimeStringUTC(this)+' GMT';
+}
+function DateGetYear(){
+return(%_DateField(this,1))-1900;
+}
+function DateSetYear(l){
+if(%_ClassOf(this)!=='Date')ThrowDateTypeError();
+l=ToNumber(l);
+if((!%_IsSmi(%IS_VAR(l))&&!(l==l)))return(%DateSetValue(this,$NaN,1));
+l=(0<=(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l)))&&(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l)))<=99)
+?1900+(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l))):l;
+var d=(%_DateField(this,0)+%_DateField(this,21));
+var m,n,g;
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d))){
+m=0;
+n=1;
+g=0;
+}else{
+m=(%_DateField(this,2));
+n=(%_DateField(this,3));
+g=(%_DateField(this,10));
+}
+var o=MakeDay(l,m,n);
+return(%DateSetValue(this,MakeDate(o,g),0));
+}
+function DateToGMTString(){
+return %_CallFunction(this,DateToUTCString);
+}
+function PadInt(N,P){
+if(P==1)return N;
+return N<%_MathPow(10,P-1)?'0'+PadInt(N,P-1):N;
+}
+function DateToISOString(){
+var d=(%_DateField(this,0));
+if((!%_IsSmi(%IS_VAR(d))&&!(d==d)))throw MakeRangeError("invalid_time_value",[]);
+var l=this.getUTCFullYear();
+var Q;
+if(l>=0&&l<=9999){
+Q=PadInt(l,4);
+}else{
+if(l<0){
+Q="-"+PadInt(-l,6);
+}else{
+Q="+"+PadInt(l,6);
+}
+}
+return Q+
+'-'+PadInt(this.getUTCMonth()+1,2)+
+'-'+PadInt(this.getUTCDate(),2)+
+'T'+PadInt(this.getUTCHours(),2)+
+':'+PadInt(this.getUTCMinutes(),2)+
+':'+PadInt(this.getUTCSeconds(),2)+
+'.'+PadInt(this.getUTCMilliseconds(),3)+
+'Z';
+}
+function DateToJSON(R){
+var S=ToObject(this);
+var T=DefaultNumber(S);
+if((typeof(T)==='number')&&!(%_IsSmi(%IS_VAR(T))||((T==T)&&(T!=1/0)&&(T!=-1/0)))){
+return null;
+}
+return S.toISOString();
+}
+var U;
+var W=$NaN;
+function CheckDateCacheCurrent(){
+if(!U){
+U=%DateCacheVersion();
+if(!U)return;
+}
+if(U[0]==W){
+return;
+}
+W=U[0];
+b=$NaN;
+c=(void 0);
+q.time=$NaN;
+q.string=null;
+}
+function CreateDate(g){
+var n=new a();
+n.setTime(g);
+return n;
+}
+%SetCode(a,DateConstructor);
+%FunctionSetPrototype(a,new a($NaN));
+InstallFunctions(a,2,[
+"UTC",DateUTC,
+"parse",DateParse,
+"now",DateNow
+]);
+%AddNamedProperty(a.prototype,"constructor",a,2);
+InstallFunctions(a.prototype,2,[
+"toString",DateToString,
+"toDateString",DateToDateString,
+"toTimeString",DateToTimeString,
+"toLocaleString",DateToLocaleString,
+"toLocaleDateString",DateToLocaleDateString,
+"toLocaleTimeString",DateToLocaleTimeString,
+"valueOf",DateValueOf,
+"getTime",DateGetTime,
+"getFullYear",DateGetFullYear,
+"getUTCFullYear",DateGetUTCFullYear,
+"getMonth",DateGetMonth,
+"getUTCMonth",DateGetUTCMonth,
+"getDate",DateGetDate,
+"getUTCDate",DateGetUTCDate,
+"getDay",DateGetDay,
+"getUTCDay",DateGetUTCDay,
+"getHours",DateGetHours,
+"getUTCHours",DateGetUTCHours,
+"getMinutes",DateGetMinutes,
+"getUTCMinutes",DateGetUTCMinutes,
+"getSeconds",DateGetSeconds,
+"getUTCSeconds",DateGetUTCSeconds,
+"getMilliseconds",DateGetMilliseconds,
+"getUTCMilliseconds",DateGetUTCMilliseconds,
+"getTimezoneOffset",DateGetTimezoneOffset,
+"setTime",DateSetTime,
+"setMilliseconds",DateSetMilliseconds,
+"setUTCMilliseconds",DateSetUTCMilliseconds,
+"setSeconds",DateSetSeconds,
+"setUTCSeconds",DateSetUTCSeconds,
+"setMinutes",DateSetMinutes,
+"setUTCMinutes",DateSetUTCMinutes,
+"setHours",DateSetHours,
+"setUTCHours",DateSetUTCHours,
+"setDate",DateSetDate,
+"setUTCDate",DateSetUTCDate,
+"setMonth",DateSetMonth,
+"setUTCMonth",DateSetUTCMonth,
+"setFullYear",DateSetFullYear,
+"setUTCFullYear",DateSetUTCFullYear,
+"toGMTString",DateToGMTString,
+"toUTCString",DateToUTCString,
+"getYear",DateGetYear,
+"setYear",DateSetYear,
+"toISOString",DateToISOString,
+"toJSON",DateToJSON
+]);
+$createDate=CreateDate;
+})();
+
+\18regexp9m
+var $regexpExec;
+var $regexpExecNoTests;
+var $regexpLastMatchInfo;
+var $regexpLastMatchInfoOverride;
+var harmony_regexps=false;
+var harmony_unicode_regexps=false;
+(function(){
+%CheckIsBootstrapping();
+var a=global.RegExp;
+$regexpLastMatchInfo=new InternalPackedArray(
+2,
+"",
+(void 0),
+0,
+0
+);
+$regexpLastMatchInfoOverride=null;
+function DoConstructRegExp(b,c,d){
+if((%_IsRegExp(c))){
+if(!(d===(void 0))){
+throw MakeTypeError('regexp_flags',[]);
+}
+d=(c.global?'g':'')
++(c.ignoreCase?'i':'')
++(c.multiline?'m':'');
+if(harmony_unicode_regexps)
+d+=(c.unicode?'u':'');
+if(harmony_regexps)
+d+=(c.sticky?'y':'');
+c=c.source;
+}
+c=(c===(void 0))?'':ToString(c);
+d=(d===(void 0))?'':ToString(d);
+%RegExpInitializeAndCompile(b,c,d);
+}
+function RegExpConstructor(c,d){
+if(%_IsConstructCall()){
+DoConstructRegExp(this,c,d);
+}else{
+if((%_IsRegExp(c))&&(d===(void 0))){
+return c;
+}
+return new a(c,d);
+}
+}
+function RegExpCompileJS(c,d){
+if(this==a.prototype){
+throw MakeTypeError(8,
+'RegExp.prototype.compile',this);
+}
+if((c===(void 0))&&%_ArgumentsLength()!=0){
+DoConstructRegExp(this,'undefined',d);
+}else{
+DoConstructRegExp(this,c,d);
+}
+}
+function DoRegExpExec(e,g,h){
+var i=%_RegExpExec(e,g,h,$regexpLastMatchInfo);
+if(i!==null)$regexpLastMatchInfoOverride=null;
+return i;
+}
+function RegExpExecNoTests(e,g,j){
+var k=%_RegExpExec(e,g,j,$regexpLastMatchInfo);
+if(k!==null){
+$regexpLastMatchInfoOverride=null;
+var l=((k)[0])>>1;
+var j=k[3];
+var m=k[4];
+var n=%_SubString(g,j,m);
+var i=%_RegExpConstructResult(l,j,g);
+i[0]=n;
+if(l==1)return i;
+var o=3+2;
+for(var q=1;q<l;q++){
+j=k[o++];
+if(j!=-1){
+m=k[o];
+i[q]=%_SubString(g,j,m);
+}
+o++;
+}
+return i;
+;
+}
+e.lastIndex=0;
+return null;
+}
+function RegExpExecJS(g){
+if(!(%_IsRegExp(this))){
+throw MakeTypeError(8,
+'RegExp.prototype.exec',this);
+}
+g=((typeof(%IS_VAR(g))==='string')?g:NonStringToString(g));
+var r=this.lastIndex;
+var q=(%_IsSmi(%IS_VAR(r))?r:%NumberToInteger(ToNumber(r)));
+var t=this.global||(harmony_regexps&&this.sticky);
+if(t){
+if(q<0||q>g.length){
+this.lastIndex=0;
+return null;
+}
+}else{
+q=0;
+}
+var u=%_RegExpExec(this,g,q,$regexpLastMatchInfo);
+if((u===null)){
+this.lastIndex=0;
+return null;
+}
+$regexpLastMatchInfoOverride=null;
+if(t){
+this.lastIndex=$regexpLastMatchInfo[4];
+}
+var l=((u)[0])>>1;
+var j=u[3];
+var m=u[4];
+var n=%_SubString(g,j,m);
+var i=%_RegExpConstructResult(l,j,g);
+i[0]=n;
+if(l==1)return i;
+var o=3+2;
+for(var q=1;q<l;q++){
+j=u[o++];
+if(j!=-1){
+m=u[o];
+i[q]=%_SubString(g,j,m);
+}
+o++;
+}
+return i;
+;
+}
+var w;
+var z;
+function RegExpTest(g){
+if(!(%_IsRegExp(this))){
+throw MakeTypeError(8,
+'RegExp.prototype.test',this);
+}
+g=((typeof(%IS_VAR(g))==='string')?g:NonStringToString(g));
+var r=this.lastIndex;
+var q=(%_IsSmi(%IS_VAR(r))?r:%NumberToInteger(ToNumber(r)));
+if(this.global||(harmony_regexps&&this.sticky)){
+if(q<0||q>g.length){
+this.lastIndex=0;
+return false;
+}
+var u=%_RegExpExec(this,g,q,$regexpLastMatchInfo);
+if((u===null)){
+this.lastIndex=0;
+return false;
+}
+$regexpLastMatchInfoOverride=null;
+this.lastIndex=$regexpLastMatchInfo[4];
+return true;
+}else{
+var e=this;
+if(e.source.length>=3&&
+%_StringCharCodeAt(e.source,0)==46&&
+%_StringCharCodeAt(e.source,1)==42&&
+%_StringCharCodeAt(e.source,2)!=63){
+e=TrimRegExp(e);
+}
+var u=%_RegExpExec(e,g,0,$regexpLastMatchInfo);
+if((u===null)){
+this.lastIndex=0;
+return false;
+}
+$regexpLastMatchInfoOverride=null;
+return true;
+}
+}
+function TrimRegExp(e){
+if(!%_ObjectEquals(w,e)){
+w=e;
+z=
+new a(%_SubString(e.source,2,e.source.length),
+(e.ignoreCase?e.multiline?"im":"i"
+:e.multiline?"m":""));
+}
+return z;
+}
+function RegExpToString(){
+if(!(%_IsRegExp(this))){
+throw MakeTypeError(8,
+'RegExp.prototype.toString',this);
+}
+var i='/'+this.source+'/';
+if(this.global)i+='g';
+if(this.ignoreCase)i+='i';
+if(this.multiline)i+='m';
+if(harmony_unicode_regexps&&this.unicode)i+='u';
+if(harmony_regexps&&this.sticky)i+='y';
+return i;
+}
+function RegExpGetLastMatch(){
+if($regexpLastMatchInfoOverride!==null){
+return(($regexpLastMatchInfoOverride)[0]);
+}
+var A=(($regexpLastMatchInfo)[1]);
+return %_SubString(A,
+$regexpLastMatchInfo[3],
+$regexpLastMatchInfo[4]);
+}
+function RegExpGetLastParen(){
+if($regexpLastMatchInfoOverride){
+var B=$regexpLastMatchInfoOverride;
+if(B.length<=3)return'';
+return B[B.length-3];
+}
+var C=(($regexpLastMatchInfo)[0]);
+if(C<=2)return'';
+var A=(($regexpLastMatchInfo)[1]);
+var j=$regexpLastMatchInfo[(3+(C-2))];
+var m=$regexpLastMatchInfo[(3+(C-1))];
+if(j!=-1&&m!=-1){
+return %_SubString(A,j,m);
+}
+return"";
+}
+function RegExpGetLeftContext(){
+var D;
+var E;
+if(!$regexpLastMatchInfoOverride){
+D=$regexpLastMatchInfo[3];
+E=(($regexpLastMatchInfo)[1]);
+}else{
+var B=$regexpLastMatchInfoOverride;
+D=((B)[(B).length-2]);
+E=((B)[(B).length-1]);
+}
+return %_SubString(E,0,D);
+}
+function RegExpGetRightContext(){
+var D;
+var E;
+if(!$regexpLastMatchInfoOverride){
+D=$regexpLastMatchInfo[4];
+E=(($regexpLastMatchInfo)[1]);
+}else{
+var B=$regexpLastMatchInfoOverride;
+E=((B)[(B).length-1]);
+var G=((B)[0]);
+D=((B)[(B).length-2])+G.length;
+}
+return %_SubString(E,D,E.length);
+}
+function RegExpMakeCaptureGetter(H){
+return function foo(){
+if($regexpLastMatchInfoOverride){
+if(H<$regexpLastMatchInfoOverride.length-2){
+return(($regexpLastMatchInfoOverride)[(H)]);
+}
+return'';
+}
+var h=H*2;
+if(h>=(($regexpLastMatchInfo)[0]))return'';
+var I=$regexpLastMatchInfo[(3+(h))];
+var J=$regexpLastMatchInfo[(3+(h+1))];
+if(I==-1||J==-1)return'';
+return %_SubString((($regexpLastMatchInfo)[1]),I,J);
+};
+}
+%FunctionSetInstanceClassName(a,'RegExp');
+%AddNamedProperty(
+a.prototype,'constructor',a,2);
+%SetCode(a,RegExpConstructor);
+InstallFunctions(a.prototype,2,[
+"exec",RegExpExecJS,
+"test",RegExpTest,
+"toString",RegExpToString,
+"compile",RegExpCompileJS
+]);
+%FunctionSetLength(a.prototype.compile,1);
+var K=function(){
+var L=(($regexpLastMatchInfo)[2]);
+return(L===(void 0))?"":L;
+};
+var M=function(g){
+(($regexpLastMatchInfo)[2])=ToString(g);
+};
+%OptimizeObjectForAddingMultipleProperties(a,22);
+%DefineAccessorPropertyUnchecked(a,'input',K,
+M,4);
+%DefineAccessorPropertyUnchecked(a,'$_',K,
+M,2|4);
+var N=false;
+var P=function(){return N;};
+var Q=function(R){N=R?true:false;};
+%DefineAccessorPropertyUnchecked(a,'multiline',P,
+Q,4);
+%DefineAccessorPropertyUnchecked(a,'$*',P,
+Q,
+2|4);
+var S=function(T){};
+%DefineAccessorPropertyUnchecked(a,'lastMatch',RegExpGetLastMatch,
+S,4);
+%DefineAccessorPropertyUnchecked(a,'$&',RegExpGetLastMatch,
+S,2|4);
+%DefineAccessorPropertyUnchecked(a,'lastParen',RegExpGetLastParen,
+S,4);
+%DefineAccessorPropertyUnchecked(a,'$+',RegExpGetLastParen,
+S,2|4);
+%DefineAccessorPropertyUnchecked(a,'leftContext',
+RegExpGetLeftContext,S,
+4);
+%DefineAccessorPropertyUnchecked(a,'$`',RegExpGetLeftContext,
+S,2|4);
+%DefineAccessorPropertyUnchecked(a,'rightContext',
+RegExpGetRightContext,S,
+4);
+%DefineAccessorPropertyUnchecked(a,"$'",RegExpGetRightContext,
+S,2|4);
+for(var q=1;q<10;++q){
+%DefineAccessorPropertyUnchecked(a,'$'+q,
+RegExpMakeCaptureGetter(q),S,
+4);
+}
+%ToFastProperties(a);
+$regexpExecNoTests=RegExpExecNoTests;
+$regexpExec=DoRegExpExec;
+})();
+
+,arraybufferE\17
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.ArrayBuffer;
+var b=global.Object;
+function ArrayBufferConstructor(c){
+if(%_IsConstructCall()){
+var d=ToPositiveInteger(c,'invalid_array_buffer_length');
+%ArrayBufferInitialize(this,d);
+}else{
+throw MakeTypeError('constructor_not_function',["ArrayBuffer"]);
+}
+}
+function ArrayBufferGetByteLen(){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw MakeTypeError(8,
+'ArrayBuffer.prototype.byteLength',this);
+}
+return %_ArrayBufferGetByteLength(this);
+}
+function ArrayBufferSlice(e,g){
+if(!(%_ClassOf(this)==='ArrayBuffer')){
+throw MakeTypeError(8,
+'ArrayBuffer.prototype.slice',this);
+}
+var h=(%_IsSmi(%IS_VAR(e))?e:%NumberToInteger(ToNumber(e)));
+if(!(g===(void 0))){
+g=(%_IsSmi(%IS_VAR(g))?g:%NumberToInteger(ToNumber(g)));
+}
+var i;
+var j=%_ArrayBufferGetByteLength(this);
+if(h<0){
+i=$max(j+h,0);
+}else{
+i=$min(h,j);
+}
+var k=(g===(void 0))?j:g;
+var l;
+if(k<0){
+l=$max(j+k,0);
+}else{
+l=$min(k,j);
+}
+if(l<i){
+l=i;
+}
+var m=l-i;
+var n=new a(m);
+%ArrayBufferSliceImpl(this,n,i);
+return n;
+}
+function ArrayBufferIsViewJS(o){
+return %ArrayBufferIsView(o);
+}
+%SetCode(a,ArrayBufferConstructor);
+%FunctionSetPrototype(a,new b());
+%AddNamedProperty(
+a.prototype,"constructor",a,2);
+%AddNamedProperty(a.prototype,
+symbolToStringTag,"ArrayBuffer",2|1);
+InstallGetter(a.prototype,"byteLength",ArrayBufferGetByteLen);
+InstallFunctions(a,2,[
+"isView",ArrayBufferIsViewJS
+]);
+InstallFunctions(a.prototype,2,[
+"slice",ArrayBufferSlice
+]);
+})();
+
+(typedarray:¯\ 2
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Array;
+var b=global.ArrayBuffer;
+function Uint8ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 1!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Uint8Array",1]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 1!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Uint8Array",1]);
+}
+j=h-i;
+k=j/1;
+}else{
+var k=g;
+j=k*1;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,1,d,i,j);
+}
+function Uint8ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*1;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,1,d,0,m);
+}else{
+%_TypedArrayInitialize(c,1,null,0,m);
+}
+}
+function Uint8ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,1,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Uint8ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Uint8ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Uint8ArrayConstructByLength(this,q);
+}else{
+Uint8ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Uint8Array"])
+}
+}
+function Uint8Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw MakeTypeError(8,"Uint8Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Uint8Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw MakeTypeError(8,"Uint8Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Uint8Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw MakeTypeError(8,"Uint8Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Uint8Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw MakeTypeError(8,"Uint8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var u=global.Uint8Array;
+function Uint8ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Uint8Array')){
+throw MakeTypeError(8,"Uint8Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*1;
+return new u(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Int8ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 1!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Int8Array",1]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 1!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Int8Array",1]);
+}
+j=h-i;
+k=j/1;
+}else{
+var k=g;
+j=k*1;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,2,d,i,j);
+}
+function Int8ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*1;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,2,d,0,m);
+}else{
+%_TypedArrayInitialize(c,2,null,0,m);
+}
+}
+function Int8ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,2,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Int8ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Int8ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Int8ArrayConstructByLength(this,q);
+}else{
+Int8ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Int8Array"])
+}
+}
+function Int8Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw MakeTypeError(8,"Int8Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Int8Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw MakeTypeError(8,"Int8Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Int8Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw MakeTypeError(8,"Int8Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Int8Array_GetLength(){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw MakeTypeError(8,"Int8Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var E=global.Int8Array;
+function Int8ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Int8Array')){
+throw MakeTypeError(8,"Int8Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*1;
+return new E(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Uint16ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 2!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Uint16Array",2]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 2!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Uint16Array",2]);
+}
+j=h-i;
+k=j/2;
+}else{
+var k=g;
+j=k*2;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,3,d,i,j);
+}
+function Uint16ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*2;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,3,d,0,m);
+}else{
+%_TypedArrayInitialize(c,3,null,0,m);
+}
+}
+function Uint16ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,3,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Uint16ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Uint16ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Uint16ArrayConstructByLength(this,q);
+}else{
+Uint16ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Uint16Array"])
+}
+}
+function Uint16Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw MakeTypeError(8,"Uint16Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Uint16Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw MakeTypeError(8,"Uint16Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Uint16Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw MakeTypeError(8,"Uint16Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Uint16Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw MakeTypeError(8,"Uint16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var G=global.Uint16Array;
+function Uint16ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Uint16Array')){
+throw MakeTypeError(8,"Uint16Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*2;
+return new G(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Int16ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 2!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Int16Array",2]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 2!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Int16Array",2]);
+}
+j=h-i;
+k=j/2;
+}else{
+var k=g;
+j=k*2;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,4,d,i,j);
+}
+function Int16ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*2;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,4,d,0,m);
+}else{
+%_TypedArrayInitialize(c,4,null,0,m);
+}
+}
+function Int16ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,4,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Int16ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Int16ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Int16ArrayConstructByLength(this,q);
+}else{
+Int16ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Int16Array"])
+}
+}
+function Int16Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw MakeTypeError(8,"Int16Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Int16Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw MakeTypeError(8,"Int16Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Int16Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw MakeTypeError(8,"Int16Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Int16Array_GetLength(){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw MakeTypeError(8,"Int16Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var H=global.Int16Array;
+function Int16ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Int16Array')){
+throw MakeTypeError(8,"Int16Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*2;
+return new H(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Uint32ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 4!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Uint32Array",4]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 4!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Uint32Array",4]);
+}
+j=h-i;
+k=j/4;
+}else{
+var k=g;
+j=k*4;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,5,d,i,j);
+}
+function Uint32ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*4;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,5,d,0,m);
+}else{
+%_TypedArrayInitialize(c,5,null,0,m);
+}
+}
+function Uint32ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,5,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Uint32ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Uint32ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Uint32ArrayConstructByLength(this,q);
+}else{
+Uint32ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Uint32Array"])
+}
+}
+function Uint32Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw MakeTypeError(8,"Uint32Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Uint32Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw MakeTypeError(8,"Uint32Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Uint32Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw MakeTypeError(8,"Uint32Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Uint32Array_GetLength(){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw MakeTypeError(8,"Uint32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var I=global.Uint32Array;
+function Uint32ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Uint32Array')){
+throw MakeTypeError(8,"Uint32Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*4;
+return new I(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Int32ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 4!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Int32Array",4]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 4!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Int32Array",4]);
+}
+j=h-i;
+k=j/4;
+}else{
+var k=g;
+j=k*4;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,6,d,i,j);
+}
+function Int32ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*4;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,6,d,0,m);
+}else{
+%_TypedArrayInitialize(c,6,null,0,m);
+}
+}
+function Int32ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,6,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Int32ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Int32ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Int32ArrayConstructByLength(this,q);
+}else{
+Int32ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Int32Array"])
+}
+}
+function Int32Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw MakeTypeError(8,"Int32Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Int32Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw MakeTypeError(8,"Int32Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Int32Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw MakeTypeError(8,"Int32Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Int32Array_GetLength(){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw MakeTypeError(8,"Int32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var J=global.Int32Array;
+function Int32ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Int32Array')){
+throw MakeTypeError(8,"Int32Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*4;
+return new J(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Float32ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 4!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Float32Array",4]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 4!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Float32Array",4]);
+}
+j=h-i;
+k=j/4;
+}else{
+var k=g;
+j=k*4;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,7,d,i,j);
+}
+function Float32ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*4;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,7,d,0,m);
+}else{
+%_TypedArrayInitialize(c,7,null,0,m);
+}
+}
+function Float32ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,7,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Float32ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Float32ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Float32ArrayConstructByLength(this,q);
+}else{
+Float32ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Float32Array"])
+}
+}
+function Float32Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw MakeTypeError(8,"Float32Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Float32Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw MakeTypeError(8,"Float32Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Float32Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw MakeTypeError(8,"Float32Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Float32Array_GetLength(){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw MakeTypeError(8,"Float32Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var K=global.Float32Array;
+function Float32ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Float32Array')){
+throw MakeTypeError(8,"Float32Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*4;
+return new K(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Float64ArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 8!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Float64Array",8]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 8!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Float64Array",8]);
+}
+j=h-i;
+k=j/8;
+}else{
+var k=g;
+j=k*8;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,8,d,i,j);
+}
+function Float64ArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*8;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,8,d,0,m);
+}else{
+%_TypedArrayInitialize(c,8,null,0,m);
+}
+}
+function Float64ArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,8,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Float64ArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Float64ArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Float64ArrayConstructByLength(this,q);
+}else{
+Float64ArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Float64Array"])
+}
+}
+function Float64Array_GetBuffer(){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw MakeTypeError(8,"Float64Array.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Float64Array_GetByteLength(){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw MakeTypeError(8,"Float64Array.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Float64Array_GetByteOffset(){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw MakeTypeError(8,"Float64Array.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Float64Array_GetLength(){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw MakeTypeError(8,"Float64Array.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var L=global.Float64Array;
+function Float64ArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Float64Array')){
+throw MakeTypeError(8,"Float64Array.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*8;
+return new L(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+function Uint8ClampedArrayConstructByArrayBuffer(c,d,e,g){
+if(!(e===(void 0))){
+e=
+ToPositiveInteger(e,"invalid_typed_array_length");
+}
+if(!(g===(void 0))){
+g=ToPositiveInteger(g,"invalid_typed_array_length");
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i;
+if((e===(void 0))){
+i=0;
+}else{
+i=e;
+if(i % 1!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["start offset","Uint8ClampedArray",1]);
+}
+if(i>h){
+throw MakeRangeError("invalid_typed_array_offset");
+}
+}
+var j;
+var k;
+if((g===(void 0))){
+if(h % 1!==0){
+throw MakeRangeError("invalid_typed_array_alignment",
+["byte length","Uint8ClampedArray",1]);
+}
+j=h-i;
+k=j/1;
+}else{
+var k=g;
+j=k*1;
+}
+if((i+j>h)
+||(k>%_MaxSmi())){
+throw MakeRangeError("invalid_typed_array_length");
+}
+%_TypedArrayInitialize(c,9,d,i,j);
+}
+function Uint8ClampedArrayConstructByLength(c,g){
+var l=(g===(void 0))?
+0:ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+var m=l*1;
+if(m>%_TypedArrayMaxSizeInHeap()){
+var d=new b(m);
+%_TypedArrayInitialize(c,9,d,0,m);
+}else{
+%_TypedArrayInitialize(c,9,null,0,m);
+}
+}
+function Uint8ClampedArrayConstructByArrayLike(c,n){
+var g=n.length;
+var l=ToPositiveInteger(g,"invalid_typed_array_length");
+if(l>%_MaxSmi()){
+throw MakeRangeError("invalid_typed_array_length");
+}
+if(!%TypedArrayInitializeFromArrayLike(c,9,n,l)){
+for(var o=0;o<l;o++){
+c[o]=n[o];
+}
+}
+}
+function Uint8ClampedArrayConstructor(q,r,t){
+if(%_IsConstructCall()){
+if((%_ClassOf(q)==='ArrayBuffer')){
+Uint8ClampedArrayConstructByArrayBuffer(this,q,r,t);
+}else if((typeof(q)==='number')||(typeof(q)==='string')||
+(typeof(q)==='boolean')||(q===(void 0))){
+Uint8ClampedArrayConstructByLength(this,q);
+}else{
+Uint8ClampedArrayConstructByArrayLike(this,q);
+}
+}else{
+throw MakeTypeError("constructor_not_function",["Uint8ClampedArray"])
+}
+}
+function Uint8ClampedArray_GetBuffer(){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw MakeTypeError(8,"Uint8ClampedArray.buffer",this);
+}
+return %TypedArrayGetBuffer(this);
+}
+function Uint8ClampedArray_GetByteLength(){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw MakeTypeError(8,"Uint8ClampedArray.byteLength",this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function Uint8ClampedArray_GetByteOffset(){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw MakeTypeError(8,"Uint8ClampedArray.byteOffset",this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function Uint8ClampedArray_GetLength(){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw MakeTypeError(8,"Uint8ClampedArray.length",this);
+}
+return %_TypedArrayGetLength(this);
+}
+var M=global.Uint8ClampedArray;
+function Uint8ClampedArraySubArray(w,z){
+if(!(%_ClassOf(this)==='Uint8ClampedArray')){
+throw MakeTypeError(8,"Uint8ClampedArray.subarray",this);
+}
+var A=(%_IsSmi(%IS_VAR(w))?w:%NumberToInteger(ToNumber(w)));
+if(!(z===(void 0))){
+z=(%_IsSmi(%IS_VAR(z))?z:%NumberToInteger(ToNumber(z)));
+}
+var B=%_TypedArrayGetLength(this);
+if(A<0){
+A=$max(0,B+A);
+}else{
+A=$min(B,A);
+}
+var C=(z===(void 0))?B:z;
+if(C<0){
+C=$max(0,B+C);
+}else{
+C=$min(C,B);
+}
+if(C<A){
+C=A;
+}
+var k=C-A;
+var D=
+%_ArrayBufferViewGetByteOffset(this)+A*1;
+return new M(%TypedArrayGetBuffer(this),
+D,k);
+}
+
+
+function TypedArraySetFromArrayLike(N,P,Q,i){
+if(i>0){
+for(var o=0;o<Q;o++){
+N[i+o]=P[o];
+}
+}
+else{
+for(var o=0;o<Q;o++){
+N[o]=P[o];
+}
+}
+}
+function TypedArraySetFromOverlappingTypedArray(N,P,i){
+var R=P.BYTES_PER_ELEMENT;
+var S=N.BYTES_PER_ELEMENT;
+var Q=P.length;
+function CopyLeftPart(){
+var T=N.byteOffset+(i+1)*S;
+var U=P.byteOffset;
+for(var W=0;
+W<Q&&T<=U;
+W++){
+N[i+W]=P[W];
+T+=S;
+U+=R;
+}
+return W;
+}
+var W=CopyLeftPart();
+function CopyRightPart(){
+var T=
+N.byteOffset+(i+Q-1)*S;
+var U=
+P.byteOffset+Q*R;
+for(var X=Q-1;
+X>=W&&T>=U;
+X--){
+N[i+X]=P[X];
+T-=S;
+U-=R;
+}
+return X;
+}
+var X=CopyRightPart();
+var Y=new a(X+1-W);
+for(var o=W;o<=X;o++){
+Y[o-W]=P[o];
+}
+for(o=W;o<=X;o++){
+N[i+o]=Y[o-W];
+}
+}
+function TypedArraySet(c,i){
+var Z=(i===(void 0))?0:(%_IsSmi(%IS_VAR(i))?i:%NumberToInteger(ToNumber(i)));
+if(Z<0){
+throw MakeTypeError("typed_array_set_negative_offset");
+}
+if(Z>%_MaxSmi()){
+throw MakeRangeError("typed_array_set_source_too_large");
+}
+switch(%TypedArraySetFastCases(this,c,Z)){
+case 0:
+return;
+case 1:
+TypedArraySetFromOverlappingTypedArray(this,c,Z);
+return;
+case 2:
+TypedArraySetFromArrayLike(this,c,c.length,Z);
+return;
+case 3:
+var l=c.length;
+if((l===(void 0))){
+if((typeof(c)==='number')){
+throw MakeTypeError("invalid_argument");
+}
+return;
+}
+if(Z+l>this.length){
+throw MakeRangeError("typed_array_set_source_too_large");
+}
+TypedArraySetFromArrayLike(this,c,l,Z);
+return;
+}
+}
+function TypedArrayGetToStringTag(){
+if(!%IsTypedArray(this))return;
+var aa=%_ClassOf(this);
+if((aa===(void 0)))return;
+return aa;
+}
+%SetCode(global.Uint8Array,Uint8ArrayConstructor);
+%FunctionSetPrototype(global.Uint8Array,new $Object());
+%AddNamedProperty(global.Uint8Array,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(global.Uint8Array.prototype,
+"constructor",global.Uint8Array,2);
+%AddNamedProperty(global.Uint8Array.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+InstallGetter(global.Uint8Array.prototype,"buffer",Uint8Array_GetBuffer);
+InstallGetter(global.Uint8Array.prototype,"byteOffset",Uint8Array_GetByteOffset,
+2|4);
+InstallGetter(global.Uint8Array.prototype,"byteLength",Uint8Array_GetByteLength,
+2|4);
+InstallGetter(global.Uint8Array.prototype,"length",Uint8Array_GetLength,
+2|4);
+InstallGetter(global.Uint8Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Uint8Array.prototype,2,[
+"subarray",Uint8ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Int8Array,Int8ArrayConstructor);
+%FunctionSetPrototype(global.Int8Array,new $Object());
+%AddNamedProperty(global.Int8Array,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(global.Int8Array.prototype,
+"constructor",global.Int8Array,2);
+%AddNamedProperty(global.Int8Array.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+InstallGetter(global.Int8Array.prototype,"buffer",Int8Array_GetBuffer);
+InstallGetter(global.Int8Array.prototype,"byteOffset",Int8Array_GetByteOffset,
+2|4);
+InstallGetter(global.Int8Array.prototype,"byteLength",Int8Array_GetByteLength,
+2|4);
+InstallGetter(global.Int8Array.prototype,"length",Int8Array_GetLength,
+2|4);
+InstallGetter(global.Int8Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Int8Array.prototype,2,[
+"subarray",Int8ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Uint16Array,Uint16ArrayConstructor);
+%FunctionSetPrototype(global.Uint16Array,new $Object());
+%AddNamedProperty(global.Uint16Array,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(global.Uint16Array.prototype,
+"constructor",global.Uint16Array,2);
+%AddNamedProperty(global.Uint16Array.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+InstallGetter(global.Uint16Array.prototype,"buffer",Uint16Array_GetBuffer);
+InstallGetter(global.Uint16Array.prototype,"byteOffset",Uint16Array_GetByteOffset,
+2|4);
+InstallGetter(global.Uint16Array.prototype,"byteLength",Uint16Array_GetByteLength,
+2|4);
+InstallGetter(global.Uint16Array.prototype,"length",Uint16Array_GetLength,
+2|4);
+InstallGetter(global.Uint16Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Uint16Array.prototype,2,[
+"subarray",Uint16ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Int16Array,Int16ArrayConstructor);
+%FunctionSetPrototype(global.Int16Array,new $Object());
+%AddNamedProperty(global.Int16Array,"BYTES_PER_ELEMENT",2,
+1|2|4);
+%AddNamedProperty(global.Int16Array.prototype,
+"constructor",global.Int16Array,2);
+%AddNamedProperty(global.Int16Array.prototype,
+"BYTES_PER_ELEMENT",2,
+1|2|4);
+InstallGetter(global.Int16Array.prototype,"buffer",Int16Array_GetBuffer);
+InstallGetter(global.Int16Array.prototype,"byteOffset",Int16Array_GetByteOffset,
+2|4);
+InstallGetter(global.Int16Array.prototype,"byteLength",Int16Array_GetByteLength,
+2|4);
+InstallGetter(global.Int16Array.prototype,"length",Int16Array_GetLength,
+2|4);
+InstallGetter(global.Int16Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Int16Array.prototype,2,[
+"subarray",Int16ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Uint32Array,Uint32ArrayConstructor);
+%FunctionSetPrototype(global.Uint32Array,new $Object());
+%AddNamedProperty(global.Uint32Array,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(global.Uint32Array.prototype,
+"constructor",global.Uint32Array,2);
+%AddNamedProperty(global.Uint32Array.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+InstallGetter(global.Uint32Array.prototype,"buffer",Uint32Array_GetBuffer);
+InstallGetter(global.Uint32Array.prototype,"byteOffset",Uint32Array_GetByteOffset,
+2|4);
+InstallGetter(global.Uint32Array.prototype,"byteLength",Uint32Array_GetByteLength,
+2|4);
+InstallGetter(global.Uint32Array.prototype,"length",Uint32Array_GetLength,
+2|4);
+InstallGetter(global.Uint32Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Uint32Array.prototype,2,[
+"subarray",Uint32ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Int32Array,Int32ArrayConstructor);
+%FunctionSetPrototype(global.Int32Array,new $Object());
+%AddNamedProperty(global.Int32Array,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(global.Int32Array.prototype,
+"constructor",global.Int32Array,2);
+%AddNamedProperty(global.Int32Array.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+InstallGetter(global.Int32Array.prototype,"buffer",Int32Array_GetBuffer);
+InstallGetter(global.Int32Array.prototype,"byteOffset",Int32Array_GetByteOffset,
+2|4);
+InstallGetter(global.Int32Array.prototype,"byteLength",Int32Array_GetByteLength,
+2|4);
+InstallGetter(global.Int32Array.prototype,"length",Int32Array_GetLength,
+2|4);
+InstallGetter(global.Int32Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Int32Array.prototype,2,[
+"subarray",Int32ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Float32Array,Float32ArrayConstructor);
+%FunctionSetPrototype(global.Float32Array,new $Object());
+%AddNamedProperty(global.Float32Array,"BYTES_PER_ELEMENT",4,
+1|2|4);
+%AddNamedProperty(global.Float32Array.prototype,
+"constructor",global.Float32Array,2);
+%AddNamedProperty(global.Float32Array.prototype,
+"BYTES_PER_ELEMENT",4,
+1|2|4);
+InstallGetter(global.Float32Array.prototype,"buffer",Float32Array_GetBuffer);
+InstallGetter(global.Float32Array.prototype,"byteOffset",Float32Array_GetByteOffset,
+2|4);
+InstallGetter(global.Float32Array.prototype,"byteLength",Float32Array_GetByteLength,
+2|4);
+InstallGetter(global.Float32Array.prototype,"length",Float32Array_GetLength,
+2|4);
+InstallGetter(global.Float32Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Float32Array.prototype,2,[
+"subarray",Float32ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Float64Array,Float64ArrayConstructor);
+%FunctionSetPrototype(global.Float64Array,new $Object());
+%AddNamedProperty(global.Float64Array,"BYTES_PER_ELEMENT",8,
+1|2|4);
+%AddNamedProperty(global.Float64Array.prototype,
+"constructor",global.Float64Array,2);
+%AddNamedProperty(global.Float64Array.prototype,
+"BYTES_PER_ELEMENT",8,
+1|2|4);
+InstallGetter(global.Float64Array.prototype,"buffer",Float64Array_GetBuffer);
+InstallGetter(global.Float64Array.prototype,"byteOffset",Float64Array_GetByteOffset,
+2|4);
+InstallGetter(global.Float64Array.prototype,"byteLength",Float64Array_GetByteLength,
+2|4);
+InstallGetter(global.Float64Array.prototype,"length",Float64Array_GetLength,
+2|4);
+InstallGetter(global.Float64Array.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Float64Array.prototype,2,[
+"subarray",Float64ArraySubArray,
+"set",TypedArraySet
+]);
+
+%SetCode(global.Uint8ClampedArray,Uint8ClampedArrayConstructor);
+%FunctionSetPrototype(global.Uint8ClampedArray,new $Object());
+%AddNamedProperty(global.Uint8ClampedArray,"BYTES_PER_ELEMENT",1,
+1|2|4);
+%AddNamedProperty(global.Uint8ClampedArray.prototype,
+"constructor",global.Uint8ClampedArray,2);
+%AddNamedProperty(global.Uint8ClampedArray.prototype,
+"BYTES_PER_ELEMENT",1,
+1|2|4);
+InstallGetter(global.Uint8ClampedArray.prototype,"buffer",Uint8ClampedArray_GetBuffer);
+InstallGetter(global.Uint8ClampedArray.prototype,"byteOffset",Uint8ClampedArray_GetByteOffset,
+2|4);
+InstallGetter(global.Uint8ClampedArray.prototype,"byteLength",Uint8ClampedArray_GetByteLength,
+2|4);
+InstallGetter(global.Uint8ClampedArray.prototype,"length",Uint8ClampedArray_GetLength,
+2|4);
+InstallGetter(global.Uint8ClampedArray.prototype,symbolToStringTag,
+TypedArrayGetToStringTag);
+InstallFunctions(global.Uint8ClampedArray.prototype,2,[
+"subarray",Uint8ClampedArraySubArray,
+"set",TypedArraySet
+]);
+
+
+var ab=global.DataView;
+function DataViewConstructor(d,e,m){
+if(%_IsConstructCall()){
+if(!(%_ClassOf(d)==='ArrayBuffer')){
+throw MakeTypeError('data_view_not_array_buffer',[]);
+}
+if(!(e===(void 0))){
+e=ToPositiveInteger(e,'invalid_data_view_offset');
+}
+if(!(m===(void 0))){
+m=(%_IsSmi(%IS_VAR(m))?m:%NumberToInteger(ToNumber(m)));
+}
+var h=%_ArrayBufferGetByteLength(d);
+var i=(e===(void 0))?0:e;
+if(i>h){
+throw MakeRangeError('invalid_data_view_offset');
+}
+var g=(m===(void 0))
+?h-i
+:m;
+if(g<0||i+g>h){
+throw new MakeRangeError('invalid_data_view_length');
+}
+%_DataViewInitialize(this,d,i,g);
+}else{
+throw MakeTypeError('constructor_not_function',["DataView"]);
+}
+}
+function DataViewGetBufferJS(){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,'DataView.buffer',this);
+}
+return %DataViewGetBuffer(this);
+}
+function DataViewGetByteOffset(){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.byteOffset',this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function DataViewGetByteLength(){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.byteLength',this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function ToPositiveDataViewOffset(i){
+return ToPositiveInteger(i,'invalid_data_view_accessor_offset');
+}
+function DataViewGetInt8JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getInt8',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetInt8(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetInt8JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setInt8',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetInt8(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+function DataViewGetUint8JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getUint8',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetUint8(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetUint8JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setUint8',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetUint8(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+function DataViewGetInt16JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getInt16',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetInt16(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetInt16JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setInt16',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetInt16(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+function DataViewGetUint16JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getUint16',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetUint16(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetUint16JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setUint16',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetUint16(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+function DataViewGetInt32JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getInt32',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetInt32(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetInt32JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setInt32',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetInt32(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+function DataViewGetUint32JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getUint32',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetUint32(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetUint32JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setUint32',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetUint32(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+function DataViewGetFloat32JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getFloat32',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetFloat32(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetFloat32JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setFloat32',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetFloat32(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+function DataViewGetFloat64JS(i,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.getFloat64',this);
+}
+if(%_ArgumentsLength()<1){
+throw MakeTypeError('invalid_argument');
+}
+return %DataViewGetFloat64(this,
+ToPositiveDataViewOffset(i),
+!!ac);
+}
+function DataViewSetFloat64JS(i,ad,ac){
+if(!(%_ClassOf(this)==='DataView')){
+throw MakeTypeError(8,
+'DataView.setFloat64',this);
+}
+if(%_ArgumentsLength()<2){
+throw MakeTypeError('invalid_argument');
+}
+%DataViewSetFloat64(this,
+ToPositiveDataViewOffset(i),
+((typeof(%IS_VAR(ad))==='number')?ad:NonNumberToNumber(ad)),
+!!ac);
+}
+
+
+%SetCode(ab,DataViewConstructor);
+%FunctionSetPrototype(ab,new $Object);
+%AddNamedProperty(ab.prototype,"constructor",ab,2);
+%AddNamedProperty(
+ab.prototype,symbolToStringTag,"DataView",1|2);
+InstallGetter(ab.prototype,"buffer",DataViewGetBufferJS);
+InstallGetter(ab.prototype,"byteOffset",DataViewGetByteOffset);
+InstallGetter(ab.prototype,"byteLength",DataViewGetByteLength);
+InstallFunctions(ab.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
+]);
+})();
+
+$generator½\1d
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Function;
+function GeneratorObjectNext(b){
+if(!(%_ClassOf(this)==='Generator')){
+throw MakeTypeError(8,
+'[Generator].prototype.next',this);
+}
+var c=%GeneratorGetContinuation(this);
+if(c>0){
+if((%_DebugIsActive()!=0))%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,b);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(c==0){
+return{value:void 0,done:true};
+}else{
+throw MakeTypeError(6);
+}
+}
+function GeneratorObjectThrow(d){
+if(!(%_ClassOf(this)==='Generator')){
+throw MakeTypeError(8,
+'[Generator].prototype.throw',this);
+}
+var c=%GeneratorGetContinuation(this);
+if(c>0){
+try{
+return %_GeneratorThrow(this,d);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(c==0){
+throw d;
+}else{
+throw MakeTypeError(6);
+}
+}
+function GeneratorObjectIterator(){
+return this;
+}
+function GeneratorFunctionConstructor(e){
+var g=NewFunctionString(arguments,'function*');
+var h=%GlobalProxy(global);
+var i=%_CallFunction(h,%CompileString(g,true));
+%FunctionMarkNameShouldPrintAsAnonymous(i);
+return i;
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var j=GeneratorFunctionPrototype.prototype;
+InstallFunctions(j,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%FunctionSetName(GeneratorObjectIterator,'[Symbol.iterator]');
+%AddNamedProperty(j,symbolIterator,
+GeneratorObjectIterator,2|4|1);
+%AddNamedProperty(j,"constructor",
+GeneratorFunctionPrototype,2|1);
+%AddNamedProperty(j,
+symbolToStringTag,"Generator",2|1);
+%InternalSetPrototype(GeneratorFunctionPrototype,a.prototype);
+%AddNamedProperty(GeneratorFunctionPrototype,
+symbolToStringTag,"GeneratorFunction",2|1);
+%AddNamedProperty(GeneratorFunctionPrototype,"constructor",
+GeneratorFunction,2|1);
+%InternalSetPrototype(GeneratorFunction,a);
+%SetCode(GeneratorFunction,GeneratorFunctionConstructor);
+})();
+
+8object-observeM²
+var $observeNotifyChange;
+var $observeEnqueueSpliceRecord;
+var $observeBeginPerformSplice;
+var $observeEndPerformSplice;
+var $observeNativeObjectObserve;
+var $observeNativeObjectGetNotifier;
+var $observeNativeObjectNotifierPerformChange;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Array;
+var b=global.Object;
+var c;
+var d={};
+function GetObservationStateJS(){
+if((c===(void 0))){
+c=%GetObservationState();
+}
+if((c.callbackInfoMap===(void 0))){
+c.callbackInfoMap=%ObservationWeakMapCreate();
+c.objectInfoMap=%ObservationWeakMapCreate();
+c.notifierObjectInfoMap=%ObservationWeakMapCreate();
+c.pendingObservers=null;
+c.nextCallbackPriority=0;
+c.lastMicrotaskId=0;
+}
+return c;
+}
+function GetPendingObservers(){
+return GetObservationStateJS().pendingObservers;
+}
+function SetPendingObservers(e){
+GetObservationStateJS().pendingObservers=e;
+}
+function GetNextCallbackPriority(){
+return GetObservationStateJS().nextCallbackPriority++;
+}
+function nullProtoObject(){
+return{__proto__:null};
+}
+function TypeMapCreate(){
+return nullProtoObject();
+}
+function TypeMapAddType(g,h,i){
+g[h]=i?1:(g[h]||0)+1;
+}
+function TypeMapRemoveType(g,h){
+g[h]--;
+}
+function TypeMapCreateFromList(j,k){
+var g=TypeMapCreate();
+for(var l=0;l<k;l++){
+TypeMapAddType(g,j[l],true);
+}
+return g;
+}
+function TypeMapHasType(g,h){
+return!!g[h];
+}
+function TypeMapIsDisjointFrom(m,n){
+if(!m||!n)
+return true;
+for(var h in m){
+if(TypeMapHasType(m,h)&&TypeMapHasType(n,h))
+return false;
+}
+return true;
+}
+var o=(function(){
+var q=[
+'add',
+'update',
+'delete',
+'setPrototype',
+'reconfigure',
+'preventExtensions'
+];
+return TypeMapCreateFromList(q,q.length);
+})();
+function ObserverCreate(r,t){
+if((t===(void 0)))
+return r;
+var u=nullProtoObject();
+u.callback=r;
+u.accept=t;
+return u;
+}
+function ObserverGetCallback(u){
+return(%_ClassOf(u)==='Function')?u:u.callback;
+}
+function ObserverGetAcceptTypes(u){
+return(%_ClassOf(u)==='Function')?o:u.accept;
+}
+function ObserverIsActive(u,w){
+return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(w),
+ObserverGetAcceptTypes(u));
+}
+function ObjectInfoGetOrCreate(z){
+var w=ObjectInfoGet(z);
+if((w===(void 0))){
+if(!%_IsJSProxy(z)){
+%SetIsObserved(z);
+}
+w={
+object:z,
+changeObservers:null,
+notifier:null,
+performing:null,
+performingCount:0,
+};
+%WeakCollectionSet(GetObservationStateJS().objectInfoMap,
+z,w);
+}
+return w;
+}
+function ObjectInfoGet(z){
+return %WeakCollectionGet(GetObservationStateJS().objectInfoMap,z);
+}
+function ObjectInfoGetFromNotifier(A){
+return %WeakCollectionGet(GetObservationStateJS().notifierObjectInfoMap,
+A);
+}
+function ObjectInfoGetNotifier(w){
+if((w.notifier===null)){
+w.notifier={__proto__:d};
+%WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
+w.notifier,w);
+}
+return w.notifier;
+}
+function ChangeObserversIsOptimized(B){
+return(%_ClassOf(B)==='Function')||
+(%_ClassOf(B.callback)==='Function');
+}
+function ObjectInfoNormalizeChangeObservers(w){
+if(ChangeObserversIsOptimized(w.changeObservers)){
+var u=w.changeObservers;
+var r=ObserverGetCallback(u);
+var C=CallbackInfoGet(r);
+var D=CallbackInfoGetPriority(C);
+w.changeObservers=nullProtoObject();
+w.changeObservers[D]=u;
+}
+}
+function ObjectInfoAddObserver(w,r,t){
+var C=CallbackInfoGetOrCreate(r);
+var u=ObserverCreate(r,t);
+if(!w.changeObservers){
+w.changeObservers=u;
+return;
+}
+ObjectInfoNormalizeChangeObservers(w);
+var D=CallbackInfoGetPriority(C);
+w.changeObservers[D]=u;
+}
+function ObjectInfoRemoveObserver(w,r){
+if(!w.changeObservers)
+return;
+if(ChangeObserversIsOptimized(w.changeObservers)){
+if(r===ObserverGetCallback(w.changeObservers))
+w.changeObservers=null;
+return;
+}
+var C=CallbackInfoGet(r);
+var D=CallbackInfoGetPriority(C);
+w.changeObservers[D]=null;
+}
+function ObjectInfoHasActiveObservers(w){
+if((w===(void 0))||!w.changeObservers)
+return false;
+if(ChangeObserversIsOptimized(w.changeObservers))
+return ObserverIsActive(w.changeObservers,w);
+for(var D in w.changeObservers){
+var u=w.changeObservers[D];
+if(!(u===null)&&ObserverIsActive(u,w))
+return true;
+}
+return false;
+}
+function ObjectInfoAddPerformingType(w,h){
+w.performing=w.performing||TypeMapCreate();
+TypeMapAddType(w.performing,h);
+w.performingCount++;
+}
+function ObjectInfoRemovePerformingType(w,h){
+w.performingCount--;
+TypeMapRemoveType(w.performing,h);
+}
+function ObjectInfoGetPerformingTypes(w){
+return w.performingCount>0?w.performing:null;
+}
+function ConvertAcceptListToTypeMap(E){
+if((E===(void 0)))
+return E;
+if(!(%_IsSpecObject(E)))
+throw MakeTypeError("observe_invalid_accept");
+var G=ToInteger(E.length);
+if(G<0)G=0;
+return TypeMapCreateFromList(E,G);
+}
+function CallbackInfoGet(r){
+return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap,r);
+}
+function CallbackInfoSet(r,C){
+%WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+r,C);
+}
+function CallbackInfoGetOrCreate(r){
+var C=CallbackInfoGet(r);
+if(!(C===(void 0)))
+return C;
+var D=GetNextCallbackPriority();
+CallbackInfoSet(r,D);
+return D;
+}
+function CallbackInfoGetPriority(C){
+if((typeof(C)==='number'))
+return C;
+else
+return C.priority;
+}
+function CallbackInfoNormalize(r){
+var C=CallbackInfoGet(r);
+if((typeof(C)==='number')){
+var D=C;
+C=new InternalArray;
+C.priority=D;
+CallbackInfoSet(r,C);
+}
+return C;
+}
+function ObjectObserve(z,r,t){
+if(!(%_IsSpecObject(z)))
+throw MakeTypeError("observe_non_object",["observe"]);
+if(%IsJSGlobalProxy(z))
+throw MakeTypeError("observe_global_proxy",["observe"]);
+if(!(%_ClassOf(r)==='Function'))
+throw MakeTypeError("observe_non_function",["observe"]);
+if(ObjectIsFrozen(r))
+throw MakeTypeError("observe_callback_frozen");
+var H=%GetObjectContextObjectObserve(z);
+return H(z,r,t);
+}
+function NativeObjectObserve(z,r,t){
+var w=ObjectInfoGetOrCreate(z);
+var j=ConvertAcceptListToTypeMap(t);
+ObjectInfoAddObserver(w,r,j);
+return z;
+}
+function ObjectUnobserve(z,r){
+if(!(%_IsSpecObject(z)))
+throw MakeTypeError("observe_non_object",["unobserve"]);
+if(%IsJSGlobalProxy(z))
+throw MakeTypeError("observe_global_proxy",["unobserve"]);
+if(!(%_ClassOf(r)==='Function'))
+throw MakeTypeError("observe_non_function",["unobserve"]);
+var w=ObjectInfoGet(z);
+if((w===(void 0)))
+return z;
+ObjectInfoRemoveObserver(w,r);
+return z;
+}
+function ArrayObserve(z,r){
+return ObjectObserve(z,r,['add',
+'update',
+'delete',
+'splice']);
+}
+function ArrayUnobserve(z,r){
+return ObjectUnobserve(z,r);
+}
+function ObserverEnqueueIfActive(u,w,I){
+if(!ObserverIsActive(u,w)||
+!TypeMapHasType(ObserverGetAcceptTypes(u),I.type)){
+return;
+}
+var r=ObserverGetCallback(u);
+if(!%ObserverObjectAndRecordHaveSameOrigin(r,I.object,
+I)){
+return;
+}
+var C=CallbackInfoNormalize(r);
+if((GetPendingObservers()===null)){
+SetPendingObservers(nullProtoObject());
+if((%_DebugIsActive()!=0)){
+var J=++GetObservationStateJS().lastMicrotaskId;
+var K="Object.observe";
+%EnqueueMicrotask(function(){
+%DebugAsyncTaskEvent({type:"willHandle",id:J,name:K});
+ObserveMicrotaskRunner();
+%DebugAsyncTaskEvent({type:"didHandle",id:J,name:K});
+});
+%DebugAsyncTaskEvent({type:"enqueue",id:J,name:K});
+}else{
+%EnqueueMicrotask(ObserveMicrotaskRunner);
+}
+}
+GetPendingObservers()[C.priority]=r;
+C.push(I);
+}
+function ObjectInfoEnqueueExternalChangeRecord(w,I,h){
+if(!ObjectInfoHasActiveObservers(w))
+return;
+var L=!(h===(void 0));
+var M=L?
+{object:w.object,type:h}:
+{object:w.object};
+for(var N in I){
+if(N==='object'||(L&&N==='type'))continue;
+%DefineDataPropertyUnchecked(
+M,N,I[N],1+4);
+}
+ObjectFreezeJS(M);
+ObjectInfoEnqueueInternalChangeRecord(w,M);
+}
+function ObjectInfoEnqueueInternalChangeRecord(w,I){
+if((typeof(I.name)==='symbol'))return;
+if(ChangeObserversIsOptimized(w.changeObservers)){
+var u=w.changeObservers;
+ObserverEnqueueIfActive(u,w,I);
+return;
+}
+for(var D in w.changeObservers){
+var u=w.changeObservers[D];
+if((u===null))
+continue;
+ObserverEnqueueIfActive(u,w,I);
+}
+}
+function BeginPerformSplice(P){
+var w=ObjectInfoGet(P);
+if(!(w===(void 0)))
+ObjectInfoAddPerformingType(w,'splice');
+}
+function EndPerformSplice(P){
+var w=ObjectInfoGet(P);
+if(!(w===(void 0)))
+ObjectInfoRemovePerformingType(w,'splice');
+}
+function EnqueueSpliceRecord(P,Q,R,S){
+var w=ObjectInfoGet(P);
+if(!ObjectInfoHasActiveObservers(w))
+return;
+var I={
+type:'splice',
+object:P,
+index:Q,
+removed:R,
+addedCount:S
+};
+ObjectFreezeJS(I);
+ObjectFreezeJS(I.removed);
+ObjectInfoEnqueueInternalChangeRecord(w,I);
+}
+function NotifyChange(h,z,K,T){
+var w=ObjectInfoGet(z);
+if(!ObjectInfoHasActiveObservers(w))
+return;
+var I;
+if(arguments.length==2){
+I={type:h,object:z};
+}else if(arguments.length==3){
+I={type:h,object:z,name:K};
+}else{
+I={
+type:h,
+object:z,
+name:K,
+oldValue:T
+};
+}
+ObjectFreezeJS(I);
+ObjectInfoEnqueueInternalChangeRecord(w,I);
+}
+function ObjectNotifierNotify(I){
+if(!(%_IsSpecObject(this)))
+throw MakeTypeError(3,"notify");
+var w=ObjectInfoGetFromNotifier(this);
+if((w===(void 0)))
+throw MakeTypeError("observe_notify_non_notifier");
+if(!(typeof(I.type)==='string'))
+throw MakeTypeError("observe_type_non_string");
+ObjectInfoEnqueueExternalChangeRecord(w,I);
+}
+function ObjectNotifierPerformChange(U,W){
+if(!(%_IsSpecObject(this)))
+throw MakeTypeError(3,"performChange");
+var w=ObjectInfoGetFromNotifier(this);
+if((w===(void 0)))
+throw MakeTypeError("observe_notify_non_notifier");
+if(!(typeof(U)==='string'))
+throw MakeTypeError("observe_perform_non_string");
+if(!(%_ClassOf(W)==='Function'))
+throw MakeTypeError("observe_perform_non_function");
+var X=%GetObjectContextNotifierPerformChange(w);
+X(w,U,W);
+}
+function NativeObjectNotifierPerformChange(w,U,W){
+ObjectInfoAddPerformingType(w,U);
+var I;
+try{
+I=%_CallFunction((void 0),W);
+}finally{
+ObjectInfoRemovePerformingType(w,U);
+}
+if((%_IsSpecObject(I)))
+ObjectInfoEnqueueExternalChangeRecord(w,I,U);
+}
+function ObjectGetNotifier(z){
+if(!(%_IsSpecObject(z)))
+throw MakeTypeError("observe_non_object",["getNotifier"]);
+if(%IsJSGlobalProxy(z))
+throw MakeTypeError("observe_global_proxy",["getNotifier"]);
+if(ObjectIsFrozen(z))return null;
+if(!%ObjectWasCreatedInCurrentOrigin(z))return null;
+var Y=%GetObjectContextObjectGetNotifier(z);
+return Y(z);
+}
+function NativeObjectGetNotifier(z){
+var w=ObjectInfoGetOrCreate(z);
+return ObjectInfoGetNotifier(w);
+}
+function CallbackDeliverPending(r){
+var C=CallbackInfoGet(r);
+if((C===(void 0))||(typeof(C)==='number'))
+return false;
+var D=C.priority;
+CallbackInfoSet(r,D);
+var e=GetPendingObservers();
+if(!(e===null))
+delete e[D];
+var Z=[];
+%MoveArrayContents(C,Z);
+%DeliverObservationChangeRecords(r,Z);
+return true;
+}
+function ObjectDeliverChangeRecords(r){
+if(!(%_ClassOf(r)==='Function'))
+throw MakeTypeError("observe_non_function",["deliverChangeRecords"]);
+while(CallbackDeliverPending(r)){}
+}
+function ObserveMicrotaskRunner(){
+var e=GetPendingObservers();
+if(!(e===null)){
+SetPendingObservers(null);
+for(var l in e){
+CallbackDeliverPending(e[l]);
+}
+}
+}
+InstallFunctions(b,2,[
+"deliverChangeRecords",ObjectDeliverChangeRecords,
+"getNotifier",ObjectGetNotifier,
+"observe",ObjectObserve,
+"unobserve",ObjectUnobserve
+]);
+InstallFunctions(a,2,[
+"observe",ArrayObserve,
+"unobserve",ArrayUnobserve
+]);
+InstallFunctions(d,2,[
+"notify",ObjectNotifierNotify,
+"performChange",ObjectNotifierPerformChange
+]);
+$observeNotifyChange=NotifyChange;
+$observeEnqueueSpliceRecord=EnqueueSpliceRecord;
+$observeBeginPerformSplice=BeginPerformSplice;
+$observeEndPerformSplice=EndPerformSplice;
+$observeNativeObjectObserve=NativeObjectObserve;
+$observeNativeObjectGetNotifier=NativeObjectGetNotifier;
+$observeNativeObjectNotifierPerformChange=NativeObjectNotifierPerformChange;
+})();
+
+(collectionE{
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Map;
+var b=global.Object;
+var c=global.Set;
+function HashToEntry(d,e,g){
+var h=(e&((g)-1));
+return((%_FixedArrayGet(d,(3+(h))|0)));
+}
+%SetInlineBuiltinFlag(HashToEntry);
+function SetFindEntry(d,g,i,e){
+var j=NumberIsNaN(i);
+for(var k=HashToEntry(d,e,g);
+k!==-1;
+k=((%_FixedArrayGet(d,((3+(g)+((k)<<1))+1)|0)))){
+var l=((%_FixedArrayGet(d,((3+(g)+((k)<<1)))|0)));
+if(i===l){
+return k;
+}
+if(j&&NumberIsNaN(l)){
+return k;
+}
+}
+return-1;
+}
+%SetInlineBuiltinFlag(SetFindEntry);
+function MapFindEntry(d,g,i,e){
+var j=NumberIsNaN(i);
+for(var k=HashToEntry(d,e,g);
+k!==-1;
+k=((%_FixedArrayGet(d,((3+(g)+((k)*3))+2)|0)))){
+var l=((%_FixedArrayGet(d,((3+(g)+((k)*3)))|0)));
+if(i===l){
+return k;
+}
+if(j&&NumberIsNaN(l)){
+return k;
+}
+}
+return-1;
+}
+%SetInlineBuiltinFlag(MapFindEntry);
+function ComputeIntegerHash(i,m){
+var e=i;
+e=e^m;
+e=~e+(e<<15);
+e=e^(e>>>12);
+e=e+(e<<2);
+e=e^(e>>>4);
+e=(e*2057)|0;
+e=e^(e>>>16);
+return e;
+}
+%SetInlineBuiltinFlag(ComputeIntegerHash);
+function GetHash(i){
+if(%_IsSmi(i)){
+return ComputeIntegerHash(i,0);
+}
+if((typeof(i)==='string')){
+var n=%_StringGetRawHashField(i);
+if((n&1)===0){
+return n>>>2;
+}
+}
+return %GenericHash(i);
+}
+%SetInlineBuiltinFlag(GetHash);
+function SetConstructor(o){
+if(!%_IsConstructCall()){
+throw MakeTypeError('constructor_not_function',['Set']);
+}
+%_SetInitialize(this);
+if(!(o==null)){
+var q=this.add;
+if(!(%_ClassOf(q)==='Function')){
+throw MakeTypeError(21,'add',this);
+}
+for(var r of o){
+%_CallFunction(this,r,q);
+}
+}
+}
+function SetAdd(i){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,'Set.prototype.add',this);
+}
+if(i===0){
+i=0;
+}
+var d=%_JSCollectionGetTable(this);
+var g=((%_FixedArrayGet(d,(0)|0)));
+var e=GetHash(i);
+if(SetFindEntry(d,g,i,e)!==-1)return this;
+var t=((%_FixedArrayGet(d,(1)|0)));
+var u=((%_FixedArrayGet(d,(2)|0)));
+var w=g<<1;
+if((t+u)>=w){
+%SetGrow(this);
+d=%_JSCollectionGetTable(this);
+g=((%_FixedArrayGet(d,(0)|0)));
+t=((%_FixedArrayGet(d,(1)|0)));
+u=((%_FixedArrayGet(d,(2)|0)));
+}
+var k=t+u;
+var z=(3+(g)+((k)<<1));
+var h=(e&((g)-1));
+var A=((%_FixedArrayGet(d,(3+(h))|0)));
+((%_FixedArraySet(d,(3+(h))|0,k)));
+(((%_FixedArraySet(d,(1)|0,(t+1)|0))));
+(%_FixedArraySet(d,(z)|0,i));
+((%_FixedArraySet(d,(z+1)|0,(A)|0)));
+return this;
+}
+function SetHas(i){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,'Set.prototype.has',this);
+}
+var d=%_JSCollectionGetTable(this);
+var g=((%_FixedArrayGet(d,(0)|0)));
+var e=GetHash(i);
+return SetFindEntry(d,g,i,e)!==-1;
+}
+function SetDelete(i){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,
+'Set.prototype.delete',this);
+}
+var d=%_JSCollectionGetTable(this);
+var g=((%_FixedArrayGet(d,(0)|0)));
+var e=GetHash(i);
+var k=SetFindEntry(d,g,i,e);
+if(k===-1)return false;
+var t=((%_FixedArrayGet(d,(1)|0)))-1;
+var u=((%_FixedArrayGet(d,(2)|0)))+1;
+var z=(3+(g)+((k)<<1));
+(%_FixedArraySet(d,(z)|0,%_TheHole()));
+(((%_FixedArraySet(d,(1)|0,(t)|0))));
+(((%_FixedArraySet(d,(2)|0,(u)|0))));
+if(t<(g>>>1))%SetShrink(this);
+return true;
+}
+function SetGetSize(){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,
+'Set.prototype.size',this);
+}
+var d=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(d,(1)|0)));
+}
+function SetClearJS(){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,
+'Set.prototype.clear',this);
+}
+%_SetClear(this);
+}
+function SetForEach(B,C){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,
+'Set.prototype.forEach',this);
+}
+if(!(%_ClassOf(B)==='Function'))throw MakeTypeError(2,B);
+var D=false;
+if((C==null)){
+C=%GetDefaultReceiver(B)||C;
+}else{
+D=(!(%_IsSpecObject(C))&&%IsSloppyModeFunction(B));
+}
+var E=new SetIterator(this,2);
+var i;
+var G=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(B);
+var H=[(void 0)];
+while(%SetIteratorNext(E,H)){
+if(G)%DebugPrepareStepInIfStepping(B);
+i=H[0];
+var I=D?ToObject(C):C;
+%_CallFunction(I,i,i,this,B);
+}
+}
+%SetCode(c,SetConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new b());
+%AddNamedProperty(c.prototype,"constructor",c,2);
+%AddNamedProperty(c.prototype,symbolToStringTag,"Set",
+2|1);
+%FunctionSetLength(SetForEach,1);
+InstallGetter(c.prototype,"size",SetGetSize);
+InstallFunctions(c.prototype,2,[
+"add",SetAdd,
+"has",SetHas,
+"delete",SetDelete,
+"clear",SetClearJS,
+"forEach",SetForEach
+]);
+function MapConstructor(o){
+if(!%_IsConstructCall()){
+throw MakeTypeError('constructor_not_function',['Map']);
+}
+%_MapInitialize(this);
+if(!(o==null)){
+var q=this.set;
+if(!(%_ClassOf(q)==='Function')){
+throw MakeTypeError(21,'set',this);
+}
+for(var J of o){
+if(!(%_IsSpecObject(J))){
+throw MakeTypeError('iterator_value_not_an_object',[J]);
+}
+%_CallFunction(this,J[0],J[1],q);
+}
+}
+}
+function MapGet(i){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.get',this);
+}
+var d=%_JSCollectionGetTable(this);
+var g=((%_FixedArrayGet(d,(0)|0)));
+var e=GetHash(i);
+var k=MapFindEntry(d,g,i,e);
+if(k===-1)return(void 0);
+return((%_FixedArrayGet(d,((3+(g)+((k)*3))+1)|0)));
+}
+function MapSet(i,r){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.set',this);
+}
+if(i===0){
+i=0;
+}
+var d=%_JSCollectionGetTable(this);
+var g=((%_FixedArrayGet(d,(0)|0)));
+var e=GetHash(i);
+var k=MapFindEntry(d,g,i,e);
+if(k!==-1){
+var K=(3+(g)+((k)*3));
+(%_FixedArraySet(d,(K+1)|0,r));
+return this;
+}
+var t=((%_FixedArrayGet(d,(1)|0)));
+var u=((%_FixedArrayGet(d,(2)|0)));
+var w=g<<1;
+if((t+u)>=w){
+%MapGrow(this);
+d=%_JSCollectionGetTable(this);
+g=((%_FixedArrayGet(d,(0)|0)));
+t=((%_FixedArrayGet(d,(1)|0)));
+u=((%_FixedArrayGet(d,(2)|0)));
+}
+k=t+u;
+var z=(3+(g)+((k)*3));
+var h=(e&((g)-1));
+var A=((%_FixedArrayGet(d,(3+(h))|0)));
+((%_FixedArraySet(d,(3+(h))|0,k)));
+(((%_FixedArraySet(d,(1)|0,(t+1)|0))));
+(%_FixedArraySet(d,(z)|0,i));
+(%_FixedArraySet(d,(z+1)|0,r));
+(%_FixedArraySet(d,(z+2)|0,A));
+return this;
+}
+function MapHas(i){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.has',this);
+}
+var d=%_JSCollectionGetTable(this);
+var g=((%_FixedArrayGet(d,(0)|0)));
+var e=GetHash(i);
+return MapFindEntry(d,g,i,e)!==-1;
+}
+function MapDelete(i){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.delete',this);
+}
+var d=%_JSCollectionGetTable(this);
+var g=((%_FixedArrayGet(d,(0)|0)));
+var e=GetHash(i);
+var k=MapFindEntry(d,g,i,e);
+if(k===-1)return false;
+var t=((%_FixedArrayGet(d,(1)|0)))-1;
+var u=((%_FixedArrayGet(d,(2)|0)))+1;
+var z=(3+(g)+((k)*3));
+(%_FixedArraySet(d,(z)|0,%_TheHole()));
+(%_FixedArraySet(d,(z+1)|0,%_TheHole()));
+(((%_FixedArraySet(d,(1)|0,(t)|0))));
+(((%_FixedArraySet(d,(2)|0,(u)|0))));
+if(t<(g>>>1))%MapShrink(this);
+return true;
+}
+function MapGetSize(){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.size',this);
+}
+var d=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(d,(1)|0)));
+}
+function MapClearJS(){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.clear',this);
+}
+%_MapClear(this);
+}
+function MapForEach(B,C){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.forEach',this);
+}
+if(!(%_ClassOf(B)==='Function'))throw MakeTypeError(2,B);
+var D=false;
+if((C==null)){
+C=%GetDefaultReceiver(B)||C;
+}else{
+D=(!(%_IsSpecObject(C))&&%IsSloppyModeFunction(B));
+}
+var E=new MapIterator(this,3);
+var G=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(B);
+var H=[(void 0),(void 0)];
+while(%MapIteratorNext(E,H)){
+if(G)%DebugPrepareStepInIfStepping(B);
+var I=D?ToObject(C):C;
+%_CallFunction(I,H[1],H[0],this,B);
+}
+}
+%SetCode(a,MapConstructor);
+%FunctionSetLength(a,0);
+%FunctionSetPrototype(a,new b());
+%AddNamedProperty(a.prototype,"constructor",a,2);
+%AddNamedProperty(
+a.prototype,symbolToStringTag,"Map",2|1);
+%FunctionSetLength(MapForEach,1);
+InstallGetter(a.prototype,"size",MapGetSize);
+InstallFunctions(a.prototype,2,[
+"get",MapGet,
+"set",MapSet,
+"has",MapHas,
+"delete",MapDelete,
+"clear",MapClearJS,
+"forEach",MapForEach
+]);
+})();
+
+<weak-collection\81-
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Object;
+var b=global.WeakMap;
+var c=global.WeakSet;
+function WeakMapConstructor(d){
+if(!%_IsConstructCall()){
+throw MakeTypeError('constructor_not_function',['WeakMap']);
+}
+%WeakCollectionInitialize(this);
+if(!(d==null)){
+var e=this.set;
+if(!(%_ClassOf(e)==='Function')){
+throw MakeTypeError(21,'set',this);
+}
+for(var g of d){
+if(!(%_IsSpecObject(g))){
+throw MakeTypeError('iterator_value_not_an_object',[g]);
+}
+%_CallFunction(this,g[0],g[1],e);
+}
+}
+}
+function WeakMapGet(h){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw MakeTypeError(8,
+'WeakMap.prototype.get',this);
+}
+if(!(%_IsSpecObject(h)))return(void 0);
+return %WeakCollectionGet(this,h);
+}
+function WeakMapSet(h,i){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw MakeTypeError(8,
+'WeakMap.prototype.set',this);
+}
+if(!(%_IsSpecObject(h))){
+throw %MakeTypeError('invalid_weakmap_key',[this,h]);
+}
+return %WeakCollectionSet(this,h,i);
+}
+function WeakMapHas(h){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw MakeTypeError(8,
+'WeakMap.prototype.has',this);
+}
+if(!(%_IsSpecObject(h)))return false;
+return %WeakCollectionHas(this,h);
+}
+function WeakMapDelete(h){
+if(!(%_ClassOf(this)==='WeakMap')){
+throw MakeTypeError(8,
+'WeakMap.prototype.delete',this);
+}
+if(!(%_IsSpecObject(h)))return false;
+return %WeakCollectionDelete(this,h);
+}
+%SetCode(b,WeakMapConstructor);
+%FunctionSetLength(b,0);
+%FunctionSetPrototype(b,new a());
+%AddNamedProperty(b.prototype,"constructor",b,
+2);
+%AddNamedProperty(b.prototype,symbolToStringTag,"WeakMap",
+2|1);
+InstallFunctions(b.prototype,2,[
+"get",WeakMapGet,
+"set",WeakMapSet,
+"has",WeakMapHas,
+"delete",WeakMapDelete
+]);
+function WeakSetConstructor(d){
+if(!%_IsConstructCall()){
+throw MakeTypeError('constructor_not_function',['WeakSet']);
+}
+%WeakCollectionInitialize(this);
+if(!(d==null)){
+var e=this.add;
+if(!(%_ClassOf(e)==='Function')){
+throw MakeTypeError(21,'add',this);
+}
+for(var i of d){
+%_CallFunction(this,i,e);
+}
+}
+}
+function WeakSetAdd(i){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw MakeTypeError(8,
+'WeakSet.prototype.add',this);
+}
+if(!(%_IsSpecObject(i))){
+throw %MakeTypeError('invalid_weakset_value',[this,i]);
+}
+return %WeakCollectionSet(this,i,true);
+}
+function WeakSetHas(i){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw MakeTypeError(8,
+'WeakSet.prototype.has',this);
+}
+if(!(%_IsSpecObject(i)))return false;
+return %WeakCollectionHas(this,i);
+}
+function WeakSetDelete(i){
+if(!(%_ClassOf(this)==='WeakSet')){
+throw MakeTypeError(8,
+'WeakSet.prototype.delete',this);
+}
+if(!(%_IsSpecObject(i)))return false;
+return %WeakCollectionDelete(this,i);
+}
+%SetCode(c,WeakSetConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new a());
+%AddNamedProperty(c.prototype,"constructor",c,
+2);
+%AddNamedProperty(c.prototype,symbolToStringTag,"WeakSet",
+2|1);
+InstallFunctions(c.prototype,2,[
+"add",WeakSetAdd,
+"has",WeakSetHas,
+"delete",WeakSetDelete
+]);
+})();
+
+Lcollection-iterator\8d1
+var $mapEntries;
+var $mapIteratorNext;
+var $setIteratorNext;
+var $setValues;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Map;
+var b=global.Object;
+var c=global.Set;
+function SetIteratorConstructor(d,e){
+%SetIteratorInitialize(this,d,e);
+}
+function SetIteratorNextJS(){
+if(!(%_ClassOf(this)==='Set Iterator')){
+throw MakeTypeError(8,
+'Set Iterator.prototype.next',this);
+}
+var g=[(void 0),(void 0)];
+var h={value:g,done:false};
+switch(%SetIteratorNext(this,g)){
+case 0:
+h.value=(void 0);
+h.done=true;
+break;
+case 2:
+h.value=g[0];
+break;
+case 3:
+g[1]=g[0];
+break;
+}
+return h;
+}
+function SetIteratorSymbolIterator(){
+return this;
+}
+function SetEntries(){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,
+'Set.prototype.entries',this);
+}
+return new SetIterator(this,3);
+}
+function SetValues(){
+if(!(%_ClassOf(this)==='Set')){
+throw MakeTypeError(8,
+'Set.prototype.values',this);
+}
+return new SetIterator(this,2);
+}
+%SetCode(SetIterator,SetIteratorConstructor);
+%FunctionSetPrototype(SetIterator,new b());
+%FunctionSetInstanceClassName(SetIterator,'Set Iterator');
+InstallFunctions(SetIterator.prototype,2,[
+'next',SetIteratorNextJS
+]);
+%FunctionSetName(SetIteratorSymbolIterator,'[Symbol.iterator]');
+%AddNamedProperty(SetIterator.prototype,symbolIterator,
+SetIteratorSymbolIterator,2);
+%AddNamedProperty(SetIterator.prototype,symbolToStringTag,
+"Set Iterator",1|2);
+InstallFunctions(c.prototype,2,[
+'entries',SetEntries,
+'keys',SetValues,
+'values',SetValues
+]);
+%AddNamedProperty(c.prototype,symbolIterator,SetValues,2);
+$setIteratorNext=SetIteratorNextJS;
+$setValues=SetValues;
+function MapIteratorConstructor(i,e){
+%MapIteratorInitialize(this,i,e);
+}
+function MapIteratorSymbolIterator(){
+return this;
+}
+function MapIteratorNextJS(){
+if(!(%_ClassOf(this)==='Map Iterator')){
+throw MakeTypeError(8,
+'Map Iterator.prototype.next',this);
+}
+var g=[(void 0),(void 0)];
+var h={value:g,done:false};
+switch(%MapIteratorNext(this,g)){
+case 0:
+h.value=(void 0);
+h.done=true;
+break;
+case 1:
+h.value=g[0];
+break;
+case 2:
+h.value=g[1];
+break;
+}
+return h;
+}
+function MapEntries(){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.entries',this);
+}
+return new MapIterator(this,3);
+}
+function MapKeys(){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.keys',this);
+}
+return new MapIterator(this,1);
+}
+function MapValues(){
+if(!(%_ClassOf(this)==='Map')){
+throw MakeTypeError(8,
+'Map.prototype.values',this);
+}
+return new MapIterator(this,2);
+}
+%SetCode(MapIterator,MapIteratorConstructor);
+%FunctionSetPrototype(MapIterator,new b());
+%FunctionSetInstanceClassName(MapIterator,'Map Iterator');
+InstallFunctions(MapIterator.prototype,2,[
+'next',MapIteratorNextJS
+]);
+%FunctionSetName(MapIteratorSymbolIterator,'[Symbol.iterator]');
+%AddNamedProperty(MapIterator.prototype,symbolIterator,
+MapIteratorSymbolIterator,2);
+%AddNamedProperty(MapIterator.prototype,symbolToStringTag,
+"Map Iterator",1|2);
+InstallFunctions(a.prototype,2,[
+'entries',MapEntries,
+'keys',MapKeys,
+'values',MapValues
+]);
+%AddNamedProperty(a.prototype,symbolIterator,MapEntries,2);
+$mapEntries=MapEntries;
+$mapIteratorNext=MapIteratorNextJS;
+})();
+
+\1cpromise\9df
+var $promiseCreate;
+var $promiseResolve;
+var $promiseReject;
+var $promiseChain;
+var $promiseCatch;
+var $promiseThen;
+var $promiseHasUserDefinedRejectHandler;
+var $promiseStatus;
+var $promiseValue;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=(%CreateGlobalPrivateOwnSymbol("Promise#status"));
+var b=(%CreateGlobalPrivateOwnSymbol("Promise#value"));
+var c=(%CreateGlobalPrivateOwnSymbol("Promise#onResolve"));
+var d=(%CreateGlobalPrivateOwnSymbol("Promise#onReject"));
+var e=(%CreateGlobalPrivateOwnSymbol("Promise#raw"));
+var g=%PromiseHasHandlerSymbol();
+var h=0;
+var i=function Promise(j){
+if(j===e)return;
+if(!%_IsConstructCall())throw MakeTypeError('not_a_promise',[this]);
+if(!(%_ClassOf(j)==='Function'))
+throw MakeTypeError('resolver_not_a_function',[j]);
+var k=PromiseInit(this);
+try{
+%DebugPushPromise(k,Promise);
+j(function(l){PromiseResolve(k,l)},
+function(m){PromiseReject(k,m)});
+}catch(e){
+PromiseReject(k,e);
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseSet(k,n,o,q,r){
+(k[a]=n);
+(k[b]=o);
+(k[c]=q);
+(k[d]=r);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:k,status:n,value:o});
+}
+return k;
+}
+function PromiseCreateAndSet(n,o){
+var k=new i(e);
+if((%_DebugIsActive()!=0))PromiseSet(k,0,(void 0));
+return PromiseSet(k,n,o);
+}
+function PromiseInit(k){
+return PromiseSet(
+k,0,(void 0),new InternalArray,new InternalArray)
+}
+function PromiseDone(k,n,o,t){
+if((k[a])===0){
+var u=(k[t]);
+if(u.length)PromiseEnqueue(o,u,n);
+PromiseSet(k,n,o);
+}
+}
+function PromiseCoerce(w,l){
+if(!IsPromise(l)&&(%_IsSpecObject(l))){
+var z;
+try{
+z=l.then;
+}catch(m){
+return %_CallFunction(w,m,PromiseRejected);
+}
+if((%_ClassOf(z)==='Function')){
+var A=%_CallFunction(w,PromiseDeferred);
+try{
+%_CallFunction(l,A.resolve,A.reject,z);
+}catch(m){
+A.reject(m);
+}
+return A.promise;
+}
+}
+return l;
+}
+function PromiseHandle(o,B,A){
+try{
+%DebugPushPromise(A.promise,PromiseHandle);
+if((%_DebugIsActive()!=0&&%DebugCallbackSupportsStepping(B)))%DebugPrepareStepInIfStepping(B);
+var C=B(o);
+if(C===A.promise)
+throw MakeTypeError('promise_cyclic',[C]);
+else if(IsPromise(C))
+%_CallFunction(C,A.resolve,A.reject,PromiseChain);
+else
+A.resolve(C);
+}catch(exception){
+try{A.reject(exception);}catch(e){}
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseEnqueue(o,u,n){
+var D,E,G=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(G){
+%DebugAsyncTaskEvent({type:"willHandle",id:D,name:E});
+}
+for(var H=0;H<u.length;H+=2){
+PromiseHandle(o,u[H],u[H+1])
+}
+if(G){
+%DebugAsyncTaskEvent({type:"didHandle",id:D,name:E});
+}
+});
+if(G){
+D=++h;
+E=n>0?"Promise.resolve":"Promise.reject";
+%DebugAsyncTaskEvent({type:"enqueue",id:D,name:E});
+}
+}
+function PromiseIdResolveHandler(l){return l}
+function PromiseIdRejectHandler(m){throw m}
+function PromiseNopResolver(){}
+function IsPromise(l){
+return(%_IsSpecObject(l))&&(!(l[a]===(void 0)));
+}
+function PromiseCreate(){
+return new i(PromiseNopResolver)
+}
+function PromiseResolve(k,l){
+PromiseDone(k,+1,l,c)
+}
+function PromiseReject(k,m){
+if((k[a])==0){
+var I=(%_DebugIsActive()!=0);
+if(I||!(!(k[g]===(void 0)))){
+%PromiseRejectEvent(k,m,I);
+}
+}
+PromiseDone(k,-1,m,d)
+}
+function PromiseDeferred(){
+if(this===i){
+var k=PromiseInit(new i(e));
+return{
+promise:k,
+resolve:function(l){PromiseResolve(k,l)},
+reject:function(m){PromiseReject(k,m)}
+};
+}else{
+var C={};
+C.promise=new this(function(J,K){
+C.resolve=J;
+C.reject=K;
+})
+return C;
+}
+}
+function PromiseResolved(l){
+if(this===i){
+return PromiseCreateAndSet(+1,l);
+}else{
+return new this(function(J,K){J(l)});
+}
+}
+function PromiseRejected(m){
+var k;
+if(this===i){
+k=PromiseCreateAndSet(-1,m);
+%PromiseRejectEvent(k,m,false);
+}else{
+k=new this(function(J,K){K(m)});
+}
+return k;
+}
+function PromiseChain(q,r){
+q=(q===(void 0))?PromiseIdResolveHandler:q;
+r=(r===(void 0))?PromiseIdRejectHandler:r;
+var A=%_CallFunction(this.constructor,PromiseDeferred);
+switch((this[a])){
+case(void 0):
+throw MakeTypeError('not_a_promise',[this]);
+case 0:
+(this[c]).push(q,A);
+(this[d]).push(r,A);
+break;
+case+1:
+PromiseEnqueue((this[b]),
+[q,A],
++1);
+break;
+case-1:
+if(!(!(this[g]===(void 0)))){
+%PromiseRevokeReject(this);
+}
+PromiseEnqueue((this[b]),
+[r,A],
+-1);
+break;
+}
+(this[g]=true);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:A.promise,parentPromise:this});
+}
+return A.promise;
+}
+function PromiseCatch(r){
+return this.then((void 0),r);
+}
+function PromiseThen(q,r){
+q=(%_ClassOf(q)==='Function')?q
+:PromiseIdResolveHandler;
+r=(%_ClassOf(r)==='Function')?r
+:PromiseIdRejectHandler;
+var L=this;
+var w=this.constructor;
+return %_CallFunction(
+this,
+function(l){
+l=PromiseCoerce(w,l);
+if(l===L){
+if((%_DebugIsActive()!=0&&%DebugCallbackSupportsStepping(r)))%DebugPrepareStepInIfStepping(r);
+return r(MakeTypeError('promise_cyclic',[l]));
+}else if(IsPromise(l)){
+return l.then(q,r);
+}else{
+if((%_DebugIsActive()!=0&&%DebugCallbackSupportsStepping(q)))%DebugPrepareStepInIfStepping(q);
+return q(l);
+}
+},
+r,
+PromiseChain
+);
+}
+function PromiseCast(l){
+return IsPromise(l)?l:new this(function(J){J(l)});
+}
+function PromiseAll(M){
+var A=%_CallFunction(this,PromiseDeferred);
+var N=[];
+try{
+var P=0;
+var H=0;
+for(var o of M){
+this.resolve(o).then(
+(function(H){
+return function(l){
+N[H]=l;
+if(--P===0)A.resolve(N);
+}
+})(H),
+function(m){A.reject(m);});
+++H;
+++P;
+}
+if(P===0){
+A.resolve(N);
+}
+}catch(e){
+A.reject(e)
+}
+return A.promise;
+}
+function PromiseRace(M){
+var A=%_CallFunction(this,PromiseDeferred);
+try{
+for(var o of M){
+this.resolve(o).then(
+function(l){A.resolve(l)},
+function(m){A.reject(m)});
+}
+}catch(e){
+A.reject(e)
+}
+return A.promise;
+}
+function PromiseHasUserDefinedRejectHandlerRecursive(k){
+var Q=(k[d]);
+if((Q===(void 0)))return false;
+for(var H=0;H<Q.length;H+=2){
+if(Q[H]!=PromiseIdRejectHandler)return true;
+if(PromiseHasUserDefinedRejectHandlerRecursive(Q[H+1].promise)){
+return true;
+}
+}
+return false;
+}
+function PromiseHasUserDefinedRejectHandler(){
+return PromiseHasUserDefinedRejectHandlerRecursive(this);
+};
+%AddNamedProperty(global,'Promise',i,2);
+%AddNamedProperty(i.prototype,symbolToStringTag,"Promise",
+2|1);
+InstallFunctions(i,2,[
+"defer",PromiseDeferred,
+"accept",PromiseResolved,
+"reject",PromiseRejected,
+"all",PromiseAll,
+"race",PromiseRace,
+"resolve",PromiseCast
+]);
+InstallFunctions(i.prototype,2,[
+"chain",PromiseChain,
+"then",PromiseThen,
+"catch",PromiseCatch
+]);
+$promiseCreate=PromiseCreate;
+$promiseResolve=PromiseResolve;
+$promiseReject=PromiseReject;
+$promiseChain=PromiseChain;
+$promiseCatch=PromiseCatch;
+$promiseThen=PromiseThen;
+$promiseHasUserDefinedRejectHandler=PromiseHasUserDefinedRejectHandler;
+$promiseStatus=a;
+$promiseValue=b;
+})();
+
+ messagesN¼\ 1
+var kMessages={
+constructor_is_generator:["Class constructor may not be a generator"],
+constructor_is_accessor:["Class constructor may not be an accessor"],
+unexpected_token:["Unexpected token ","%0"],
+unexpected_token_number:["Unexpected number"],
+unexpected_token_string:["Unexpected string"],
+unexpected_token_identifier:["Unexpected identifier"],
+unexpected_reserved:["Unexpected reserved word"],
+unexpected_strict_reserved:["Unexpected strict mode reserved word"],
+unexpected_eos:["Unexpected end of input"],
+unexpected_template_string:["Unexpected template string"],
+malformed_regexp:["Invalid regular expression: /","%0","/: ","%1"],
+malformed_regexp_flags:["Invalid regular expression flags"],
+unterminated_regexp:["Invalid regular expression: missing /"],
+unterminated_template:["Unterminated template literal"],
+unterminated_template_expr:["Missing } in template expression"],
+unterminated_arg_list:["missing ) after argument list"],
+regexp_flags:["Cannot supply flags when constructing one RegExp from another"],
+multiple_defaults_in_switch:["More than one default clause in switch statement"],
+newline_after_throw:["Illegal newline after throw"],
+label_redeclaration:["Label '","%0","' has already been declared"],
+var_redeclaration:["Identifier '","%0","' has already been declared"],
+duplicate_template_property:["Object template has duplicate property '","%0","'"],
+no_catch_or_finally:["Missing catch or finally after try"],
+unknown_label:["Undefined label '","%0","'"],
+uncaught_exception:["Uncaught ","%0"],
+undefined_method:["Object ","%1"," has no method '","%0","'"],
+not_defined:["%0"," is not defined"],
+non_method:["'super' is referenced from non-method"],
+unsupported_super:["Unsupported reference to 'super'"],
+non_object_property_load:["Cannot read property '","%0","' of ","%1"],
+non_object_property_store:["Cannot set property '","%0","' of ","%1"],
+illegal_invocation:["Illegal invocation"],
+no_setter_in_callback:["Cannot set property ","%0"," of ","%1"," which has only a getter"],
+flags_getter_non_object:["RegExp.prototype.flags getter called on non-object ","%0"],
+reduce_no_initial:["Reduce of empty array with no initial value"],
+value_and_accessor:["Invalid property. A property cannot both have accessors and be writable or have a value, ","%0"],
+proto_object_or_null:["Object prototype may only be an Object or null: ","%0"],
+non_extensible_proto:["%0"," is not extensible"],
+handler_non_object:["Proxy.","%0"," called with non-object as handler"],
+proto_non_object:["Proxy.","%0"," called with non-object as prototype"],
+trap_function_expected:["Proxy.","%0"," called with non-function for '","%1","' trap"],
+proxy_repeated_prop_name:["Trap '","%1","' returned repeated property name '","%2","'"],
+invalid_weakmap_key:["Invalid value used as weak map key"],
+invalid_weakset_value:["Invalid value used in weak set"],
+not_date_object:["this is not a Date object."],
+observe_non_object:["Object.","%0"," cannot ","%0"," non-object"],
+observe_non_function:["Object.","%0"," cannot deliver to non-function"],
+observe_callback_frozen:["Object.observe cannot deliver to a frozen function object"],
+observe_invalid_accept:["Third argument to Object.observe must be an array of strings."],
+observe_type_non_string:["Invalid changeRecord with non-string 'type' property"],
+observe_perform_non_string:["Invalid non-string changeType"],
+observe_perform_non_function:["Cannot perform non-function"],
+observe_notify_non_notifier:["notify called on non-notifier object"],
+observe_global_proxy:["%0"," cannot be called on the global proxy object"],
+not_typed_array:["this is not a typed array."],
+invalid_argument:["invalid_argument"],
+data_view_not_array_buffer:["First argument to DataView constructor must be an ArrayBuffer"],
+constructor_not_function:["Constructor ","%0"," requires 'new'"],
+not_a_symbol:["%0"," is not a symbol"],
+not_a_promise:["%0"," is not a promise"],
+resolver_not_a_function:["Promise resolver ","%0"," is not a function"],
+promise_cyclic:["Chaining cycle detected for promise ","%0"],
+array_functions_on_frozen:["Cannot modify frozen array elements"],
+array_functions_change_sealed:["Cannot add/remove sealed array elements"],
+first_argument_not_regexp:["First argument to ","%0"," must not be a regular expression"],
+iterator_result_not_an_object:["Iterator result ","%0"," is not an object"],
+iterator_value_not_an_object:["Iterator value ","%0"," is not an entry object"],
+invalid_array_length:["Invalid array length"],
+invalid_array_buffer_length:["Invalid array buffer length"],
+invalid_string_length:["Invalid string length"],
+invalid_typed_array_offset:["Start offset is too large:"],
+invalid_typed_array_length:["Invalid typed array length"],
+invalid_typed_array_alignment:["%0"," of ","%1"," should be a multiple of ","%2"],
+typed_array_set_source_too_large:
+["Source is too large"],
+typed_array_set_negative_offset:
+["Start offset is negative"],
+invalid_data_view_offset:["Start offset is outside the bounds of the buffer"],
+invalid_data_view_length:["Invalid data view length"],
+invalid_data_view_accessor_offset:
+["Offset is outside the bounds of the DataView"],
+invalid_time_value:["Invalid time value"],
+invalid_count_value:["Invalid count value"],
+invalid_code_point:["Invalid code point ","%0"],
+invalid_lhs_in_assignment:["Invalid left-hand side in assignment"],
+invalid_lhs_in_for:["Invalid left-hand side in for-loop"],
+invalid_lhs_in_postfix_op:["Invalid left-hand side expression in postfix operation"],
+invalid_lhs_in_prefix_op:["Invalid left-hand side expression in prefix operation"],
+not_isvar:["builtin %IS_VAR: not a variable"],
+single_function_literal:["Single function literal required"],
+invalid_regexp_flags:["Invalid flags supplied to RegExp constructor '","%0","'"],
+invalid_regexp:["Invalid RegExp pattern /","%0","/"],
+illegal_break:["Illegal break statement"],
+illegal_continue:["Illegal continue statement"],
+illegal_return:["Illegal return statement"],
+error_loading_debugger:["Error loading debugger"],
+circular_structure:["Converting circular structure to JSON"],
+called_on_null_or_undefined:["%0"," called on null or undefined"],
+array_indexof_not_defined:["Array.getIndexOf: Argument undefined"],
+object_not_extensible:["Can't add property ","%0",", object is not extensible"],
+illegal_access:["Illegal access"],
+static_prototype:["Classes may not have static property named prototype"],
+strict_mode_with:["Strict mode code may not include a with statement"],
+strict_eval_arguments:["Unexpected eval or arguments in strict mode"],
+too_many_arguments:["Too many arguments in function call (only 65535 allowed)"],
+too_many_parameters:["Too many parameters in function definition (only 65535 allowed)"],
+too_many_variables:["Too many variables declared (only 4194303 allowed)"],
+strict_param_dupe:["Strict mode function may not have duplicate parameter names"],
+strict_octal_literal:["Octal literals are not allowed in strict mode."],
+template_octal_literal:["Octal literals are not allowed in template strings."],
+strict_delete:["Delete of an unqualified identifier in strict mode."],
+strict_delete_property:["Cannot delete property '","%0","' of ","%1"],
+strict_function:["In strict mode code, functions can only be declared at top level or immediately within another function."],
+strict_read_only_property:["Cannot assign to read only property '","%0","' of ","%1"],
+strict_cannot_assign:["Cannot assign to read only '","%0","' in strict mode"],
+restricted_function_properties:["'caller' and 'arguments' are restricted function properties and cannot be accessed in this context."],
+strict_poison_pill:["'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them"],
+strict_caller:["Illegal access to a strict mode caller function."],
+strong_ellision:["In strong mode, arrays with holes are deprecated, use maps instead"],
+strong_arguments:["In strong mode, 'arguments' is deprecated, use '...args' instead"],
+strong_undefined:["In strong mode, binding or assigning to 'undefined' is deprecated"],
+strong_direct_eval:["In strong mode, direct calls to eval are deprecated"],
+strong_switch_fallthrough:["In strong mode, switch fall-through is deprecated, terminate each case with 'break', 'continue', 'return' or 'throw'"],
+strong_equal:["In strong mode, '==' and '!=' are deprecated, use '===' and '!==' instead"],
+strong_delete:["In strong mode, 'delete' is deprecated, use maps or sets instead"],
+strong_var:["In strong mode, 'var' is deprecated, use 'let' or 'const' instead"],
+strong_for_in:["In strong mode, 'for'-'in' loops are deprecated, use 'for'-'of' instead"],
+strong_empty:["In strong mode, empty sub-statements are deprecated, make them explicit with '{}' instead"],
+strong_use_before_declaration:["In strong mode, declaring variable '","%0","' before its use is required"],
+strong_unbound_global:["In strong mode, using an undeclared global variable '","%0","' is not allowed"],
+strong_super_call_missing:["In strong mode, invoking the super constructor in a subclass is required"],
+strong_super_call_duplicate:["In strong mode, invoking the super constructor multiple times is deprecated"],
+strong_super_call_misplaced:["In strong mode, the super constructor must be invoked before any assignment to 'this'"],
+strong_constructor_super:["In strong mode, 'super' can only be used to invoke the super constructor, and cannot be nested inside another statement or expression"],
+strong_constructor_this:["In strong mode, 'this' can only be used to initialize properties, and cannot be nested inside another statement or expression"],
+strong_constructor_return_value:["In strong mode, returning a value from a constructor is deprecated"],
+strong_constructor_return_misplaced:["In strong mode, returning from a constructor before its super constructor invocation or all assignments to 'this' is deprecated"],
+sloppy_lexical:["Block-scoped declarations (let, const, function, class) not yet supported outside strict mode"],
+malformed_arrow_function_parameter_list:["Malformed arrow function parameter list"],
+cant_prevent_ext_external_array_elements:["Cannot prevent extension of an object with external array elements"],
+redef_external_array_element:["Cannot redefine a property of an object with external array elements"],
+const_assign:["Assignment to constant variable."],
+module_export_undefined:["Export '","%0","' is not defined in module"],
+duplicate_export:["Duplicate export of '","%0","'"],
+unexpected_super:["'super' keyword unexpected here"],
+extends_value_not_a_function:["Class extends value ","%0"," is not a function or null"],
+prototype_parent_not_an_object:["Class extends value does not have valid prototype property ","%0"],
+duplicate_constructor:["A class may only have one constructor"],
+super_constructor_call:["A 'super' constructor call may only appear as the first statement of a function, and its arguments may not access 'this'. Other forms are not yet supported."],
+duplicate_proto:["Duplicate __proto__ fields are not allowed in object literals"],
+param_after_rest:["Rest parameter must be last formal parameter"],
+constructor_noncallable:["Class constructors cannot be invoked without 'new'"],
+array_not_subclassable:["Subclassing Arrays is not currently supported."],
+for_in_loop_initializer:["for-in loop variable declaration may not have an initializer."],
+for_of_loop_initializer:["for-of loop variable declaration may not have an initializer."],
+for_inof_loop_multi_bindings:["Invalid left-hand side in ","%0"," loop: Must have a single binding."],
+bad_getter_arity:["Getter must not have any formal parameters."],
+bad_setter_arity:["Setter must have exactly one formal parameter."],
+this_formal_parameter:["'this' is not a valid formal parameter name"],
+duplicate_arrow_function_formal_parameter:["Arrow function may not have duplicate parameter names"]
+};
+function FormatString(a,b){
+var c="";
+var d=0;
+for(var e=0;e<a.length;e++){
+var g=a[e];
+if(g.length==2&&%_StringCharCodeAt(g,0)==0x25){
+var d=(%_StringCharCodeAt(g,1)-0x30)>>>0;
+if(d<4){
+try{
+g=NoSideEffectToString(b[d]);
+}catch(e){
+if(%IsJSModule(b[d]))
+g="module";
+else if((%_IsSpecObject(b[d])))
+g="object";
+else
+g="#<error>";
+}
+}
+}
+c+=g;
+}
+return c;
+}
+function NoSideEffectToString(a){
+if((typeof(a)==='string'))return a;
+if((typeof(a)==='number'))return %_NumberToString(a);
+if((typeof(a)==='boolean'))return a?'true':'false';
+if((a===(void 0)))return'undefined';
+if((a===null))return'null';
+if((%_IsFunction(a))){
+var b=%_CallFunction(a,FunctionToString);
+if(b.length>128){
+b=%_SubString(b,0,111)+"...<omitted>..."+
+%_SubString(b,b.length-2,b.length);
+}
+return b;
+}
+if((typeof(a)==='symbol'))return %_CallFunction(a,$symbolToString);
+if((%_IsObject(a))
+&&%GetDataProperty(a,"toString")===ObjectToString){
+var c=%GetDataProperty(a,"constructor");
+if(typeof c=="function"){
+var d=c.name;
+if((typeof(d)==='string')&&d!==""){
+return"#<"+d+">";
+}
+}
+}
+if(CanBeSafelyTreatedAsAnErrorObject(a)){
+return %_CallFunction(a,ErrorToString);
+}
+return %_CallFunction(a,NoSideEffectsObjectToString);
+}
+function CanBeSafelyTreatedAsAnErrorObject(a){
+switch(%_ClassOf(a)){
+case'Error':
+case'EvalError':
+case'RangeError':
+case'ReferenceError':
+case'SyntaxError':
+case'TypeError':
+case'URIError':
+return true;
+}
+var b=%GetDataProperty(a,"toString");
+return a instanceof $Error&&b===ErrorToString;
+}
+function ToStringCheckErrorObject(a){
+if(CanBeSafelyTreatedAsAnErrorObject(a)){
+return %_CallFunction(a,ErrorToString);
+}else{
+return ToString(a);
+}
+}
+function ToDetailString(a){
+if(a!=null&&(%_IsObject(a))&&a.toString===ObjectToString){
+var b=a.constructor;
+if(typeof b=="function"){
+var c=b.name;
+if((typeof(c)==='string')&&c!==""){
+return"#<"+c+">";
+}
+}
+}
+return ToStringCheckErrorObject(a);
+}
+function MakeGenericError(a,b,c,d,e){
+if((c===(void 0))&&(typeof(b)==='string'))c=[];
+return new a(FormatMessage(b,c,d,e));
+}
+%FunctionSetInstanceClassName(Script,'Script');
+%AddNamedProperty(Script.prototype,'constructor',Script,
+2|4|1);
+%SetCode(Script,function(a){
+throw new $Error("Not supported");
+});
+function FormatMessage(a,b,c,d){
+if((typeof(a)==='number')){
+var b=NoSideEffectToString(b);
+var c=NoSideEffectToString(c);
+var d=NoSideEffectToString(d);
+try{
+return %FormatMessageString(a,b,c,d);
+}catch(e){
+return"";
+}
+}
+var e=kMessages[a];
+if(!e)return"<unknown message "+a+">";
+return FormatString(e,b);
+}
+function GetLineNumber(a){
+var b=%MessageGetStartPosition(a);
+if(b==-1)return 0;
+var c=%MessageGetScript(a);
+var d=c.locationFromPosition(b,true);
+if(d==null)return 0;
+return d.line+1;
+}
+function GetSourceLine(a){
+var b=%MessageGetScript(a);
+var c=%MessageGetStartPosition(a);
+var d=b.locationFromPosition(c,true);
+if(d==null)return"";
+return d.sourceText();
+}
+function MakeError(a,b,c,d){
+return MakeGenericError($Error,a,b,c,d);
+}
+function MakeTypeError(a,b,c,d){
+return MakeGenericError($TypeError,a,b,c,d);
+}
+function MakeRangeError(a,b,c,d){
+return MakeGenericError($RangeError,a,b,c,d);
+}
+function MakeSyntaxError(a,b,c,d){
+return MakeGenericError($SyntaxError,a,b,c,d);
+}
+function MakeReferenceError(a,b,c,d){
+return MakeGenericError($ReferenceError,a,b,c,d);
+}
+function MakeEvalError(a,b,c,d){
+return MakeGenericError($EvalError,a,b,c,d);
+}
+function MakeTypeErrorEmbedded(a,b){
+return MakeGenericError($TypeError,a,[b]);
+}
+function MakeSyntaxErrorEmbedded(a,b){
+return MakeGenericError($SyntaxError,a,[b]);
+}
+function MakeReferenceErrorEmbedded(a,b){
+return MakeGenericError($ReferenceError,a,[b]);
+}
+function ScriptLineFromPosition(a){
+var b=0;
+var c=this.lineCount()-1;
+var d=this.line_ends;
+if(a>d[c]){
+return-1;
+}
+if(a<=d[0]){
+return 0;
+}
+while(c>=1){
+var e=(b+c)>>1;
+if(a>d[e]){
+b=e+1;
+}else if(a<=d[e-1]){
+c=e-1;
+}else{
+return e;
+}
+}
+return-1;
+}
+function ScriptLocationFromPosition(position,
+include_resource_offset){
+var a=this.lineFromPosition(position);
+if(a==-1)return null;
+var b=this.line_ends;
+var c=a==0?0:b[a-1]+1;
+var d=b[a];
+if(d>0&&%_CallFunction(this.source,d-1,$stringCharAt)=='\r'){
+d--;
+}
+var e=position-c;
+if(include_resource_offset){
+a+=this.line_offset;
+if(a==this.line_offset){
+e+=this.column_offset;
+}
+}
+return new SourceLocation(this,position,a,e,c,d);
+}
+function ScriptLocationFromLine(a,b,c){
+var d=0;
+if(!(a===(void 0))){
+d=a-this.line_offset;
+}
+var e=b||0;
+if(d==0){
+e-=this.column_offset;
+}
+var g=c||0;
+if(d<0||e<0||g<0)return null;
+if(d==0){
+return this.locationFromPosition(g+e,false);
+}else{
+var h=this.lineFromPosition(g);
+if(h==-1||h+d>=this.lineCount()){
+return null;
+}
+return this.locationFromPosition(
+this.line_ends[h+d-1]+1+e);
+}
+}
+function ScriptSourceSlice(a,b){
+var c=(a===(void 0))?this.line_offset
+:a;
+var d=(b===(void 0))?this.line_offset+this.lineCount()
+:b;
+c-=this.line_offset;
+d-=this.line_offset;
+if(c<0)c=0;
+if(d>this.lineCount())d=this.lineCount();
+if(c>=this.lineCount()||
+d<0||
+c>d){
+return null;
+}
+var e=this.line_ends;
+var g=c==0?0:e[c-1]+1;
+var h=d==0?0:e[d-1]+1;
+return new SourceSlice(this,
+c+this.line_offset,
+d+this.line_offset,
+g,h);
+}
+function ScriptSourceLine(a){
+var b=0;
+if(!(a===(void 0))){
+b=a-this.line_offset;
+}
+if(b<0||this.lineCount()<=b){
+return null;
+}
+var c=this.line_ends;
+var d=b==0?0:c[b-1]+1;
+var e=c[b];
+return %_CallFunction(this.source,d,e,$stringSubstring);
+}
+function ScriptLineCount(){
+return this.line_ends.length;
+}
+function ScriptNameOrSourceURL(){
+if(this.source_url)return this.source_url;
+return this.name;
+}
+SetUpLockedPrototype(Script,[
+"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
+]
+);
+function SourceLocation(a,b,c,d,e,g){
+this.script=a;
+this.position=b;
+this.line=c;
+this.column=d;
+this.start=e;
+this.end=g;
+}
+function SourceLocationSourceText(){
+return %_CallFunction(this.script.source,
+this.start,
+this.end,
+$stringSubstring);
+}
+SetUpLockedPrototype(SourceLocation,
+["script","position","line","column","start","end"],
+["sourceText",SourceLocationSourceText]
+);
+function SourceSlice(a,b,c,d,e){
+this.script=a;
+this.from_line=b;
+this.to_line=c;
+this.from_position=d;
+this.to_position=e;
+}
+function SourceSliceSourceText(){
+return %_CallFunction(this.script.source,
+this.from_position,
+this.to_position,
+$stringSubstring);
+}
+SetUpLockedPrototype(SourceSlice,
+["script","from_line","to_line","from_position","to_position"],
+["sourceText",SourceSliceSourceText]
+);
+function GetPositionInLine(a){
+var b=%MessageGetScript(a);
+var c=%MessageGetStartPosition(a);
+var d=b.locationFromPosition(c,false);
+if(d==null)return-1;
+return c-d.start;
+}
+function GetStackTraceLine(a,b,c,d){
+return new CallSite(a,b,c,false).toString();
+}
+var CallSiteReceiverKey=(%CreatePrivateOwnSymbol("CallSite#receiver"));
+var CallSiteFunctionKey=(%CreatePrivateOwnSymbol("CallSite#function"));
+var CallSitePositionKey=(%CreatePrivateOwnSymbol("CallSite#position"));
+var CallSiteStrictModeKey=(%CreatePrivateOwnSymbol("CallSite#strict_mode"));
+function CallSite(a,b,c,d){
+(this[CallSiteReceiverKey]=a);
+(this[CallSiteFunctionKey]=b);
+(this[CallSitePositionKey]=c);
+(this[CallSiteStrictModeKey]=d);
+}
+function CallSiteGetThis(){
+return(this[CallSiteStrictModeKey])
+?(void 0):(this[CallSiteReceiverKey]);
+}
+function CallSiteGetTypeName(){
+return GetTypeName((this[CallSiteReceiverKey]),false);
+}
+function CallSiteIsToplevel(){
+if((this[CallSiteReceiverKey])==null){
+return true;
+}
+return(%_ClassOf((this[CallSiteReceiverKey]))==='global');
+}
+function CallSiteIsEval(){
+var a=%FunctionGetScript((this[CallSiteFunctionKey]));
+return a&&a.compilation_type==1;
+}
+function CallSiteGetEvalOrigin(){
+var a=%FunctionGetScript((this[CallSiteFunctionKey]));
+return FormatEvalOrigin(a);
+}
+function CallSiteGetScriptNameOrSourceURL(){
+var a=%FunctionGetScript((this[CallSiteFunctionKey]));
+return a?a.nameOrSourceURL():null;
+}
+function CallSiteGetFunction(){
+return(this[CallSiteStrictModeKey])
+?(void 0):(this[CallSiteFunctionKey]);
+}
+function CallSiteGetFunctionName(){
+var a=(this[CallSiteFunctionKey]);
+var b=%FunctionGetDebugName(a);
+if(b){
+return b;
+}
+var c=%FunctionGetScript(a);
+if(c&&c.compilation_type==1){
+return"eval";
+}
+return null;
+}
+function CallSiteGetMethodName(){
+var a=(this[CallSiteReceiverKey]);
+var b=(this[CallSiteFunctionKey]);
+var c=b.name;
+if(c&&a&&
+(%_CallFunction(a,c,ObjectLookupGetter)===b||
+%_CallFunction(a,c,ObjectLookupSetter)===b||
+((%_IsObject(a))&&%GetDataProperty(a,c)===b))){
+return c;
+}
+var d=null;
+for(var e in a){
+if(%_CallFunction(a,e,ObjectLookupGetter)===b||
+%_CallFunction(a,e,ObjectLookupSetter)===b||
+((%_IsObject(a))&&%GetDataProperty(a,e)===b)){
+if(d){
+return null;
+}
+d=e;
+}
+}
+if(d){
+return d;
+}
+return null;
+}
+function CallSiteGetFileName(){
+var a=%FunctionGetScript((this[CallSiteFunctionKey]));
+return a?a.name:null;
+}
+function CallSiteGetLineNumber(){
+if((this[CallSitePositionKey])==-1){
+return null;
+}
+var a=%FunctionGetScript((this[CallSiteFunctionKey]));
+var b=null;
+if(a){
+b=a.locationFromPosition(
+(this[CallSitePositionKey]),true);
+}
+return b?b.line+1:null;
+}
+function CallSiteGetColumnNumber(){
+if((this[CallSitePositionKey])==-1){
+return null;
+}
+var a=%FunctionGetScript((this[CallSiteFunctionKey]));
+var b=null;
+if(a){
+b=a.locationFromPosition(
+(this[CallSitePositionKey]),true);
+}
+return b?b.column+1:null;
+}
+function CallSiteIsNative(){
+var a=%FunctionGetScript((this[CallSiteFunctionKey]));
+return a?(a.type==0):false;
+}
+function CallSiteGetPosition(){
+return(this[CallSitePositionKey]);
+}
+function CallSiteIsConstructor(){
+var a=(this[CallSiteReceiverKey]);
+var b=(a!=null&&(%_IsObject(a)))
+?%GetDataProperty(a,"constructor"):null;
+if(!b)return false;
+return(this[CallSiteFunctionKey])===b;
+}
+function CallSiteToString(){
+var a;
+var b="";
+if(this.isNative()){
+b="native";
+}else{
+a=this.getScriptNameOrSourceURL();
+if(!a&&this.isEval()){
+b=this.getEvalOrigin();
+b+=", ";
+}
+if(a){
+b+=a;
+}else{
+b+="<anonymous>";
+}
+var c=this.getLineNumber();
+if(c!=null){
+b+=":"+c;
+var d=this.getColumnNumber();
+if(d){
+b+=":"+d;
+}
+}
+}
+var e="";
+var g=this.getFunctionName();
+var h=true;
+var i=this.isConstructor();
+var j=!(this.isToplevel()||i);
+if(j){
+var k=GetTypeName((this[CallSiteReceiverKey]),true);
+var l=this.getMethodName();
+if(g){
+if(k&&
+%_CallFunction(g,k,$stringIndexOf)!=0){
+e+=k+".";
+}
+e+=g;
+if(l&&
+(%_CallFunction(g,"."+l,$stringIndexOf)!=
+g.length-l.length-1)){
+e+=" [as "+l+"]";
+}
+}else{
+e+=k+"."+(l||"<anonymous>");
+}
+}else if(i){
+e+="new "+(g||"<anonymous>");
+}else if(g){
+e+=g;
+}else{
+e+=b;
+h=false;
+}
+if(h){
+e+=" ("+b+")";
+}
+return e;
+}
+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(a){
+var b=a.nameOrSourceURL();
+if(b){
+return b;
+}
+var c="eval at ";
+if(a.eval_from_function_name){
+c+=a.eval_from_function_name;
+}else{
+c+="<anonymous>";
+}
+var d=a.eval_from_script;
+if(d){
+if(d.compilation_type==1){
+c+=" ("+FormatEvalOrigin(d)+")";
+}else{
+if(d.name){
+c+=" ("+d.name;
+var e=d.locationFromPosition(
+a.eval_from_script_position,true);
+if(e){
+c+=":"+(e.line+1);
+c+=":"+(e.column+1);
+}
+c+=")";
+}else{
+c+=" (unknown source)";
+}
+}
+}
+return c;
+}
+function FormatErrorString(a){
+try{
+return %_CallFunction(a,ErrorToString);
+}catch(e){
+try{
+return"<error: "+e+">";
+}catch(ee){
+return"<error>";
+}
+}
+}
+function GetStackFrames(a){
+var b=new InternalArray();
+var c=a[0];
+for(var d=1;d<a.length;d+=4){
+var e=a[d];
+var g=a[d+1];
+var h=a[d+2];
+var i=a[d+3];
+var j=%FunctionGetPositionForOffset(h,i);
+c--;
+b.push(new CallSite(e,g,j,(c<0)));
+}
+return b;
+}
+var formatting_custom_stack_trace=false;
+function FormatStackTrace(a,b){
+var c=GetStackFrames(b);
+if((%_IsFunction($Error.prepareStackTrace))&&!formatting_custom_stack_trace){
+var d=[];
+%MoveArrayContents(c,d);
+formatting_custom_stack_trace=true;
+var e=(void 0);
+try{
+e=$Error.prepareStackTrace(a,d);
+}catch(e){
+throw e;
+}finally{
+formatting_custom_stack_trace=false;
+}
+return e;
+}
+var g=new InternalArray();
+g.push(FormatErrorString(a));
+for(var h=0;h<c.length;h++){
+var i=c[h];
+var j;
+try{
+j=i.toString();
+}catch(e){
+try{
+j="<error: "+e+">";
+}catch(ee){
+j="<error>";
+}
+}
+g.push(" at "+j);
+}
+return %_CallFunction(g,"\n",$arrayJoin);
+}
+function GetTypeName(a,b){
+var c=a.constructor;
+if(!c){
+return b?null:
+%_CallFunction(a,NoSideEffectsObjectToString);
+}
+var d=c.name;
+if(!d){
+return b?null:
+%_CallFunction(a,NoSideEffectsObjectToString);
+}
+return d;
+}
+var stack_trace_symbol;
+var formatted_stack_trace_symbol=(%CreatePrivateOwnSymbol("formatted stack trace"));
+var StackTraceGetter=function(){
+var a=(void 0);
+var b=this;
+while(b){
+var a=
+(b[formatted_stack_trace_symbol]);
+if((a===(void 0))){
+var c=(b[stack_trace_symbol]);
+if((c===(void 0))){
+b=%_GetPrototype(b);
+continue;
+}
+a=FormatStackTrace(b,c);
+(b[stack_trace_symbol]=(void 0));
+(b[formatted_stack_trace_symbol]=a);
+}
+return a;
+}
+return(void 0);
+};
+var StackTraceSetter=function(a){
+if((%HasOwnProperty(this,stack_trace_symbol))){
+(this[stack_trace_symbol]=(void 0));
+(this[formatted_stack_trace_symbol]=a);
+}
+};
+var captureStackTrace=function captureStackTrace(a,b){
+ObjectDefineProperty(a,'stack',{get:StackTraceGetter,
+set:StackTraceSetter,
+configurable:true});
+%CollectStackTrace(a,b?b:captureStackTrace);
+}
+function SetUpError(){
+var a=function(b){
+var c=b.name;
+%AddNamedProperty(global,c,b,2);
+%AddNamedProperty(builtins,'$'+c,b,
+2|4|1);
+if(c=='Error'){
+var d=function(){};
+%FunctionSetPrototype(d,$Object.prototype);
+%FunctionSetInstanceClassName(d,'Error');
+%FunctionSetPrototype(b,new d());
+}else{
+%FunctionSetPrototype(b,new $Error());
+%InternalSetPrototype(b,$Error);
+}
+%FunctionSetInstanceClassName(b,'Error');
+%AddNamedProperty(b.prototype,'constructor',b,2);
+%AddNamedProperty(b.prototype,'name',c,2);
+%SetCode(b,function(e){
+if(%_IsConstructCall()){
+try{captureStackTrace(this,b);}catch(e){}
+if(!(e===(void 0))){
+%AddNamedProperty(this,'message',ToString(e),2);
+}
+}else{
+return new b(e);
+}
+});
+%SetNativeFlag(b);
+};
+a(function Error(){});
+a(function TypeError(){});
+a(function RangeError(){});
+a(function SyntaxError(){});
+a(function ReferenceError(){});
+a(function EvalError(){});
+a(function URIError(){});
+}
+SetUpError();
+$Error.captureStackTrace=captureStackTrace;
+%AddNamedProperty($Error.prototype,'message','',2);
+var visited_errors=new InternalArray();
+var cyclic_error_marker=new $Object();
+function GetPropertyWithoutInvokingMonkeyGetters(a,b){
+var c=a;
+while(c&&!%HasOwnProperty(c,b)){
+c=%_GetPrototype(c);
+}
+if((c===null))return(void 0);
+if(!(%_IsObject(c)))return a[b];
+var d=%GetOwnProperty(c,b);
+if(d&&d[0]){
+var e=b==="name";
+if(c===$ReferenceError.prototype)
+return e?"ReferenceError":(void 0);
+if(c===$SyntaxError.prototype)
+return e?"SyntaxError":(void 0);
+if(c===$TypeError.prototype)
+return e?"TypeError":(void 0);
+}
+return a[b];
+}
+function ErrorToStringDetectCycle(a){
+if(!%PushIfAbsent(visited_errors,a))throw cyclic_error_marker;
+try{
+var b=GetPropertyWithoutInvokingMonkeyGetters(a,"name");
+b=(b===(void 0))?"Error":((typeof(%IS_VAR(b))==='string')?b:NonStringToString(b));
+var c=GetPropertyWithoutInvokingMonkeyGetters(a,"message");
+c=(c===(void 0))?"":((typeof(%IS_VAR(c))==='string')?c:NonStringToString(c));
+if(b==="")return c;
+if(c==="")return b;
+return b+": "+c;
+}finally{
+visited_errors.length=visited_errors.length-1;
+}
+}
+function ErrorToString(){
+if(!(%_IsSpecObject(this))){
+throw MakeTypeError(3,"Error.prototype.toString");
+}
+try{
+return ErrorToStringDetectCycle(this);
+}catch(e){
+if(e===cyclic_error_marker){
+return'';
+}
+throw e;
+}
+}
+InstallFunctions($Error.prototype,2,['toString',ErrorToString]);
+function SetUpStackOverflowBoilerplate(){
+var a=MakeRangeError(39);
+%DefineAccessorPropertyUnchecked(
+a,'stack',StackTraceGetter,StackTraceSetter,2);
+return a;
+}
+var kStackOverflowBoilerplate=SetUpStackOverflowBoilerplate();
+
+\10json5;
+var $jsonSerializeAdapter;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.JSON;
+function Revive(b,c,d){
+var e=b[c];
+if((%_IsObject(e))){
+if((%_IsArray(e))){
+var g=e.length;
+for(var h=0;h<g;h++){
+var i=Revive(e,%_NumberToString(h),d);
+e[h]=i;
+}
+}else{
+for(var j in e){
+if(%_CallFunction(e,j,ObjectHasOwnProperty)){
+var i=Revive(e,j,d);
+if((i===(void 0))){
+delete e[j];
+}else{
+e[j]=i;
+}
+}
+}
+}
+}
+return %_CallFunction(b,c,e,d);
+}
+function JSONParse(k,d){
+var l=%ParseJson(((typeof(%IS_VAR(k))==='string')?k:NonStringToString(k)));
+if((%_ClassOf(d)==='Function')){
+return Revive({'':l},'',d);
+}else{
+return l;
+}
+}
+function SerializeArray(m,n,o,q,r){
+if(!%PushIfAbsent(o,m)){
+throw MakeTypeError('circular_structure',[]);
+}
+var t=q;
+q+=r;
+var u=new InternalArray();
+var w=m.length;
+for(var h=0;h<w;h++){
+var z=JSONSerialize(%_NumberToString(h),m,n,o,
+q,r);
+if((z===(void 0))){
+z="null";
+}
+u.push(z);
+}
+var A;
+if(r==""){
+A="["+u.join(",")+"]";
+}else if(u.length>0){
+var B=",\n"+q;
+A="[\n"+q+u.join(B)+"\n"+
+t+"]";
+}else{
+A="[]";
+}
+o.pop();
+return A;
+}
+function SerializeObject(m,n,o,q,r){
+if(!%PushIfAbsent(o,m)){
+throw MakeTypeError('circular_structure',[]);
+}
+var t=q;
+q+=r;
+var u=new InternalArray();
+if((%_IsArray(n))){
+var g=n.length;
+for(var h=0;h<g;h++){
+if(%_CallFunction(n,h,ObjectHasOwnProperty)){
+var j=n[h];
+var z=JSONSerialize(j,m,n,o,q,r);
+if(!(z===(void 0))){
+var C=%QuoteJSONString(j)+":";
+if(r!="")C+=" ";
+C+=z;
+u.push(C);
+}
+}
+}
+}else{
+for(var j in m){
+if(%_CallFunction(m,j,ObjectHasOwnProperty)){
+var z=JSONSerialize(j,m,n,o,q,r);
+if(!(z===(void 0))){
+var C=%QuoteJSONString(j)+":";
+if(r!="")C+=" ";
+C+=z;
+u.push(C);
+}
+}
+}
+}
+var A;
+if(r==""){
+A="{"+u.join(",")+"}";
+}else if(u.length>0){
+var B=",\n"+q;
+A="{\n"+q+u.join(B)+"\n"+
+t+"}";
+}else{
+A="{}";
+}
+o.pop();
+return A;
+}
+function JSONSerialize(D,b,n,o,q,r){
+var m=b[D];
+if((%_IsSpecObject(m))){
+var E=m.toJSON;
+if((%_ClassOf(E)==='Function')){
+m=%_CallFunction(m,D,E);
+}
+}
+if((%_ClassOf(n)==='Function')){
+m=%_CallFunction(b,D,m,n);
+}
+if((typeof(m)==='string')){
+return %QuoteJSONString(m);
+}else if((typeof(m)==='number')){
+return((%_IsSmi(%IS_VAR(m))||m-m==0)?%_NumberToString(m):"null");
+}else if((typeof(m)==='boolean')){
+return m?"true":"false";
+}else if((m===null)){
+return"null";
+}else if((%_IsSpecObject(m))&&!(typeof m=="function")){
+if((%_IsArray(m))){
+return SerializeArray(m,n,o,q,r);
+}else if((%_ClassOf(m)==='Number')){
+m=ToNumber(m);
+return((%_IsSmi(%IS_VAR(m))||m-m==0)?%_NumberToString(m):"null");
+}else if((%_ClassOf(m)==='String')){
+return %QuoteJSONString(ToString(m));
+}else if((%_ClassOf(m)==='Boolean')){
+return %_ValueOf(m)?"true":"false";
+}else{
+return SerializeObject(m,n,o,q,r);
+}
+}
+return(void 0);
+}
+function JSONStringify(m,n,G){
+if(%_ArgumentsLength()==1){
+return %BasicJSONStringify(m);
+}
+if((%_IsObject(G))){
+if((%_ClassOf(G)==='Number')){
+G=ToNumber(G);
+}else if((%_ClassOf(G)==='String')){
+G=ToString(G);
+}
+}
+var r;
+if((typeof(G)==='number')){
+G=$max(0,$min(ToInteger(G),10));
+r=%_SubString(" ",0,G);
+}else if((typeof(G)==='string')){
+if(G.length>10){
+r=%_SubString(G,0,10);
+}else{
+r=G;
+}
+}else{
+r="";
+}
+if((%_IsArray(n))){
+var H=new InternalArray();
+var I={__proto__:null};
+var J={};
+var g=n.length;
+for(var h=0;h<g;h++){
+var K=n[h];
+if((%_ClassOf(K)==='String')){
+K=ToString(K);
+}else{
+if((%_ClassOf(K)==='Number'))K=ToNumber(K);
+if((typeof(K)==='number'))K=%_NumberToString(K);
+}
+if((typeof(K)==='string')&&I[K]!=J){
+H.push(K);
+I[K]=J;
+}
+}
+n=H;
+}
+return JSONSerialize('',{'':m},n,new InternalArray(),"",r);
+}
+%AddNamedProperty(a,symbolToStringTag,"JSON",1|2);
+InstallFunctions(a,2,[
+"parse",JSONParse,
+"stringify",JSONStringify
+]);
+$jsonSerializeAdapter=function(D,L){
+var b={};
+b[D]=L;
+return JSONSerialize(D,b,(void 0),new InternalArray(),"","");
+}
+})();
+
+8array-iteratorEB
+var $iteratorCreateResultObject;
+var $arrayValues;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Array;
+var b=global.Object;
+var c=global.Uint8Array;
+
+var d=global.Int8Array;
+
+var e=global.Uint16Array;
+
+var g=global.Int16Array;
+
+var h=global.Uint32Array;
+
+var i=global.Int32Array;
+
+var j=global.Float32Array;
+
+var k=global.Float64Array;
+
+var l=global.Uint8ClampedArray;
+
+
+var m=(%CreateGlobalPrivateOwnSymbol("ArrayIterator#object"));
+var n=(%CreateGlobalPrivateOwnSymbol("ArrayIterator#next"));
+var o=(%CreateGlobalPrivateOwnSymbol("ArrayIterator#kind"));
+function ArrayIterator(){}
+function CreateArrayIterator(q,r){
+var t=ToObject(q);
+var u=new ArrayIterator;
+(u[m]=t);
+(u[n]=0);
+(u[o]=r);
+return u;
+}
+function CreateIteratorResultObject(w,z){
+return{value:w,done:z};
+}
+function ArrayIteratorIterator(){
+return this;
+}
+function ArrayIteratorNext(){
+var u=ToObject(this);
+if(!(!(u[n]===(void 0)))){
+throw MakeTypeError(8,
+'Array Iterator.prototype.next',this);
+}
+var q=(u[m]);
+if((q===(void 0))){
+return CreateIteratorResultObject((void 0),true);
+}
+var A=(u[n]);
+var B=(u[o]);
+var C=(q.length>>>0);
+if(A>=C){
+(u[m]=(void 0));
+return CreateIteratorResultObject((void 0),true);
+}
+(u[n]=A+1);
+if(B==2){
+return CreateIteratorResultObject(q[A],false);
+}
+if(B==3){
+return CreateIteratorResultObject([A,q[A]],false);
+}
+return CreateIteratorResultObject(A,false);
+}
+function ArrayEntries(){
+return CreateArrayIterator(this,3);
+}
+function ArrayValues(){
+return CreateArrayIterator(this,2);
+}
+function ArrayKeys(){
+return CreateArrayIterator(this,1);
+}
+%FunctionSetPrototype(ArrayIterator,new b());
+%FunctionSetInstanceClassName(ArrayIterator,'Array Iterator');
+InstallFunctions(ArrayIterator.prototype,2,[
+'next',ArrayIteratorNext
+]);
+%FunctionSetName(ArrayIteratorIterator,'[Symbol.iterator]');
+%AddNamedProperty(ArrayIterator.prototype,symbolIterator,
+ArrayIteratorIterator,2);
+%AddNamedProperty(ArrayIterator.prototype,symbolToStringTag,
+"Array Iterator",1|2);
+InstallFunctions(a.prototype,2,[
+'entries',ArrayEntries,
+'keys',ArrayKeys
+]);
+%AddNamedProperty(a.prototype,symbolIterator,ArrayValues,
+2);
+%AddNamedProperty(c.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(c.prototype,'values',ArrayValues,2);
+%AddNamedProperty(c.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(c.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(d.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(d.prototype,'values',ArrayValues,2);
+%AddNamedProperty(d.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(d.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(e.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(e.prototype,'values',ArrayValues,2);
+%AddNamedProperty(e.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(e.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(g.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(g.prototype,'values',ArrayValues,2);
+%AddNamedProperty(g.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(g.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(h.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(h.prototype,'values',ArrayValues,2);
+%AddNamedProperty(h.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(h.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(i.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(i.prototype,'values',ArrayValues,2);
+%AddNamedProperty(i.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(i.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(j.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(j.prototype,'values',ArrayValues,2);
+%AddNamedProperty(j.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(j.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(k.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(k.prototype,'values',ArrayValues,2);
+%AddNamedProperty(k.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(k.prototype,symbolIterator,ArrayValues,
+2);
+
+%AddNamedProperty(l.prototype,'entries',ArrayEntries,2);
+%AddNamedProperty(l.prototype,'values',ArrayValues,2);
+%AddNamedProperty(l.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(l.prototype,symbolIterator,ArrayValues,
+2);
+
+
+$iteratorCreateResultObject=CreateIteratorResultObject;
+$arrayValues=ArrayValues;
+})();
+
+<string-iterator}\1a
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Object;
+var b=global.String;
+var c=
+(%CreateGlobalPrivateOwnSymbol("StringIterator#iteratedString"));
+var d=(%CreateGlobalPrivateOwnSymbol("StringIterator#next"));
+function StringIterator(){}
+function CreateStringIterator(e){
+var g=((typeof(%IS_VAR(e))==='string')?e:NonStringToString(e));
+var h=new StringIterator;
+(h[c]=g);
+(h[d]=0);
+return h;
+}
+function StringIteratorIterator(){
+return this;
+}
+function StringIteratorNext(){
+var h=ToObject(this);
+if(!(!(h[d]===(void 0)))){
+throw MakeTypeError(8,
+'String Iterator.prototype.next');
+}
+var g=(h[c]);
+if((g===(void 0))){
+return $iteratorCreateResultObject((void 0),true);
+}
+var i=(h[d]);
+var j=(g.length>>>0);
+if(i>=j){
+(h[c]=(void 0));
+return $iteratorCreateResultObject((void 0),true);
+}
+var k=%_StringCharCodeAt(g,i);
+var l=%_StringCharFromCode(k);
+i++;
+if(k>=0xD800&&k<=0xDBFF&&i<j){
+var m=%_StringCharCodeAt(g,i);
+if(m>=0xDC00&&m<=0xDFFF){
+l+=%_StringCharFromCode(m);
+i++;
+}
+}
+(h[d]=i);
+return $iteratorCreateResultObject(l,false);
+}
+function StringPrototypeIterator(){
+return CreateStringIterator(this);
+}
+%FunctionSetPrototype(StringIterator,new a());
+%FunctionSetInstanceClassName(StringIterator,'String Iterator');
+InstallFunctions(StringIterator.prototype,2,[
+'next',StringIteratorNext
+]);
+%FunctionSetName(StringIteratorIterator,'[Symbol.iterator]');
+%AddNamedProperty(StringIterator.prototype,symbolIterator,
+StringIteratorIterator,2);
+%AddNamedProperty(StringIterator.prototype,symbolToStringTag,
+"String Iterator",1|2);
+%FunctionSetName(StringPrototypeIterator,'[Symbol.iterator]');
+%AddNamedProperty(b.prototype,symbolIterator,
+StringPrototypeIterator,2);
+})();
+
+$templatesÕ\r
+var $getTemplateCallSite;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=new global.Map;
+var b=global.Map.prototype.get;
+var c=global.Map.prototype.set;
+function SameCallSiteElements(d,e){
+var g=d.length;
+var e=e.raw;
+if(g!==e.length)return false;
+for(var h=0;h<g;++h){
+if(d[h]!==e[h])return false;
+}
+return true;
+}
+function GetCachedCallSite(i,j){
+var k=%_CallFunction(a,j,b);
+if((k===(void 0)))return;
+var g=k.length;
+for(var h=0;h<g;++h){
+if(SameCallSiteElements(i,k[h]))return k[h];
+}
+}
+function SetCachedCallSite(i,j){
+var k=%_CallFunction(a,j,b);
+var l;
+if((k===(void 0))){
+l=new InternalArray(1);
+l[0]=i;
+%_CallFunction(a,j,l,c);
+}else{
+k.push(i);
+}
+return i;
+}
+$getTemplateCallSite=function(i,d,j){
+var m=GetCachedCallSite(d,j);
+if(!(m===(void 0)))return m;
+%AddNamedProperty(i,"raw",%ObjectFreeze(d),
+1|2|4);
+return SetCachedCallSite(%ObjectFreeze(i),j);
+}
+})();
+
+\10i18n\12Ý\ 1
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Boolean;
+var b=global.Date;
+var c=global.Number;
+var d=global.RegExp;
+var e=global.String;
+var g=global.undefined;
+var h={};
+%AddNamedProperty(global,"Intl",h,2);
+var i=['collator',
+'numberformat',
+'dateformat',
+'breakiterator'];
+var j=['NFC',
+'NFD',
+'NFKC',
+'NFKD'];
+var k={
+'collator':g,
+'numberformat':g,
+'dateformat':g,
+'breakiterator':g
+};
+var l=g;
+var m=g;
+function GetUnicodeExtensionRE(){
+if(m===g){
+m=new d('-u(-[a-z0-9]{2,8})+','g');
+}
+return m;
+}
+var n=g;
+function GetAnyExtensionRE(){
+if(n===g){
+n=new d('-[a-z0-9]{1}-.*','g');
+}
+return n;
+}
+var o=g;
+function GetQuotedStringRE(){
+if(o===g){
+o=new d("'[^']+'",'g');
+}
+return o;
+}
+var q=g;
+function GetServiceRE(){
+if(q===g){
+q=
+new d('^(collator|numberformat|dateformat|breakiterator)$');
+}
+return q;
+}
+var r=g;
+function GetLanguageTagRE(){
+if(r===g){
+BuildLanguageTagREs();
+}
+return r;
+}
+var t=g;
+function GetLanguageVariantRE(){
+if(t===g){
+BuildLanguageTagREs();
+}
+return t;
+}
+var u=g;
+function GetLanguageSingletonRE(){
+if(u===g){
+BuildLanguageTagREs();
+}
+return u;
+}
+var w=g;
+function GetTimezoneNameCheckRE(){
+if(w===g){
+w=
+new d('^([A-Za-z]+)/([A-Za-z]+)(?:_([A-Za-z]+))*$');
+}
+return w;
+}
+var z={
+'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 A={
+'kn':{'property':'numeric','type':'boolean'},
+'kf':{'property':'caseFirst','type':'string',
+'values':['false','lower','upper']}
+};
+var B={
+'nu':{'property':g,'type':'string'}
+};
+var C={
+'ca':{'property':g,'type':'string'},
+'nu':{'property':g,'type':'string'}
+};
+var D=[
+'big5han','dict','direct','ducet','gb2312','phonebk','phonetic',
+'pinyin','reformed','searchjl','stroke','trad','unihan','zhuyin'
+];
+var E=
+'Function object that\'s not a constructor was created with new';
+function addBoundMethod(G,H,I,J){
+function getter(){
+if(!%IsInitializedIntlObject(this)){
+throw new $TypeError('Method '+H+' called on a '+
+'non-object or on a wrong type of object.');
+}
+var K='__bound'+H+'__';
+if(this[K]===g){
+var L=this;
+var M;
+if(J===g||J===2){
+M=function(N,P){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+return I(L,N,P);
+}
+}else if(J===1){
+M=function(N){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+return I(L,N);
+}
+}else{
+M=function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if(%_ArgumentsLength()>0){
+return I(L,%_Arguments(0));
+}else{
+return I(L);
+}
+}
+}
+%FunctionSetName(M,K);
+%FunctionRemovePrototype(M);
+%SetNativeFlag(M);
+this[K]=M;
+}
+return this[K];
+}
+%FunctionSetName(getter,H);
+%FunctionRemovePrototype(getter);
+%SetNativeFlag(getter);
+ObjectDefineProperty(G.prototype,H,{
+get:getter,
+enumerable:false,
+configurable:true
+});
+}
+function supportedLocalesOf(Q,R,S){
+if((Q.match(GetServiceRE())===null)){
+throw new $Error('Internal error, wrong service type: '+Q);
+}
+if(S===g){
+S={};
+}else{
+S=ToObject(S);
+}
+var T=S.localeMatcher;
+if(T!==g){
+T=e(T);
+if(T!=='lookup'&&T!=='best fit'){
+throw new $RangeError('Illegal value for localeMatcher:'+T);
+}
+}else{
+T='best fit';
+}
+var U=initializeLocaleList(R);
+if(k[Q]===g){
+k[Q]=getAvailableLocalesOf(Q);
+}
+if(T==='best fit'){
+return initializeLocaleList(bestFitSupportedLocalesOf(
+U,k[Q]));
+}
+return initializeLocaleList(lookupSupportedLocalesOf(
+U,k[Q]));
+}
+function lookupSupportedLocalesOf(U,W){
+var X=[];
+for(var Y=0;Y<U.length;++Y){
+var Z=U[Y].replace(GetUnicodeExtensionRE(),'');
+do{
+if(W[Z]!==g){
+X.push(U[Y]);
+break;
+}
+var aa=Z.lastIndexOf('-');
+if(aa===-1){
+break;
+}
+Z=Z.substring(0,aa);
+}while(true);
+}
+return X;
+}
+function bestFitSupportedLocalesOf(U,W){
+return lookupSupportedLocalesOf(U,W);
+}
+function getGetOption(S,ab){
+if(S===g){
+throw new $Error('Internal '+ab+' error. '+
+'Default options are missing.');
+}
+var ac=function getOption(ad,ae,af,ag){
+if(S[ad]!==g){
+var ah=S[ad];
+switch(ae){
+case'boolean':
+ah=a(ah);
+break;
+case'string':
+ah=e(ah);
+break;
+case'number':
+ah=c(ah);
+break;
+default:
+throw new $Error('Internal error. Wrong value type.');
+}
+if(af!==g&&af.indexOf(ah)===-1){
+throw new $RangeError('Value '+ah+' out of range for '+ab+
+' options property '+ad);
+}
+return ah;
+}
+return ag;
+}
+return ac;
+}
+function resolveLocale(Q,U,S){
+U=initializeLocaleList(U);
+var ac=getGetOption(S,Q);
+var T=ac('localeMatcher','string',
+['lookup','best fit'],'best fit');
+var ai;
+if(T==='lookup'){
+ai=lookupMatcher(Q,U);
+}else{
+ai=bestFitMatcher(Q,U);
+}
+return ai;
+}
+function lookupMatcher(Q,U){
+if((Q.match(GetServiceRE())===null)){
+throw new $Error('Internal error, wrong service type: '+Q);
+}
+if(k[Q]===g){
+k[Q]=getAvailableLocalesOf(Q);
+}
+for(var Y=0;Y<U.length;++Y){
+var Z=U[Y].replace(GetAnyExtensionRE(),'');
+do{
+if(k[Q][Z]!==g){
+var aj=U[Y].match(GetUnicodeExtensionRE());
+var ak=(aj===null)?'':aj[0];
+return{'locale':Z,'extension':ak,'position':Y};
+}
+var aa=Z.lastIndexOf('-');
+if(aa===-1){
+break;
+}
+Z=Z.substring(0,aa);
+}while(true);
+}
+if(l===g){
+l=%GetDefaultICULocale();
+}
+return{'locale':l,'extension':'','position':-1};
+}
+function bestFitMatcher(Q,U){
+return lookupMatcher(Q,U);
+}
+function parseExtension(ak){
+var al=ak.split('-');
+if(al.length<=2||
+(al[0]!==''&&al[1]!=='u')){
+return{};
+}
+var am={};
+var an=g;
+for(var Y=2;Y<al.length;++Y){
+var J=al[Y].length;
+var ao=al[Y];
+if(J===2){
+am[ao]=g;
+an=ao;
+}else if(J>=3&&J<=8&&an!==g){
+am[an]=ao;
+an=g;
+}else{
+return{};
+}
+}
+return am;
+}
+function setOptions(ap,am,aq,ac,ar){
+var ak='';
+var as=function updateExtension(at,ah){
+return'-'+at+'-'+e(ah);
+}
+var au=function updateProperty(ad,ae,ah){
+if(ae==='boolean'&&(typeof ah==='string')){
+ah=(ah==='true')?true:false;
+}
+if(ad!==g){
+defineWEProperty(ar,ad,ah);
+}
+}
+for(var at in aq){
+if(aq.hasOwnProperty(at)){
+var ah=g;
+var av=aq[at];
+if(av.property!==g){
+ah=ac(av.property,av.type,av.values);
+}
+if(ah!==g){
+au(av.property,av.type,ah);
+ak+=as(at,ah);
+continue;
+}
+if(am.hasOwnProperty(at)){
+ah=am[at];
+if(ah!==g){
+au(av.property,av.type,ah);
+ak+=as(at,ah);
+}else if(av.type==='boolean'){
+au(av.property,av.type,true);
+ak+=as(at,true);
+}
+}
+}
+}
+return ak===''?'':'-u'+ak;
+}
+function freezeArray(aw){
+aw.forEach(function(ao,ax){
+ObjectDefineProperty(aw,ax,{value:ao,
+configurable:false,
+writable:false,
+enumerable:true});
+});
+ObjectDefineProperty(aw,'length',{value:aw.length,
+writable:false});
+return aw;
+}
+function getOptimalLanguageTag(ay,ai){
+if(ay===ai){
+return ay;
+}
+var R=%GetLanguageTagVariants([ay,ai]);
+if(R[0].maximized!==R[1].maximized){
+return ai;
+}
+var az=new d('^'+R[1].base);
+return ai.replace(az,R[0].base);
+}
+function getAvailableLocalesOf(Q){
+var aA=%AvailableLocalesOf(Q);
+for(var Y in aA){
+if(aA.hasOwnProperty(Y)){
+var aB=Y.match(/^([a-z]{2,3})-([A-Z][a-z]{3})-([A-Z]{2})$/);
+if(aB!==null){
+aA[aB[1]+'-'+aB[3]]=null;
+}
+}
+}
+return aA;
+}
+function defineWEProperty(aC,ad,ah){
+ObjectDefineProperty(aC,ad,
+{value:ah,writable:true,enumerable:true});
+}
+function addWEPropertyIfDefined(aC,ad,ah){
+if(ah!==g){
+defineWEProperty(aC,ad,ah);
+}
+}
+function defineWECProperty(aC,ad,ah){
+ObjectDefineProperty(aC,ad,
+{value:ah,
+writable:true,
+enumerable:true,
+configurable:true});
+}
+function addWECPropertyIfDefined(aC,ad,ah){
+if(ah!==g){
+defineWECProperty(aC,ad,ah);
+}
+}
+function toTitleCaseWord(aD){
+return aD.substr(0,1).toUpperCase()+aD.substr(1).toLowerCase();
+}
+function canonicalizeLanguageTag(aE){
+if(typeof aE!=='string'&&typeof aE!=='object'||
+(aE===null)){
+throw new $TypeError('Language ID should be string or object.');
+}
+var aF=e(aE);
+if(isValidLanguageTag(aF)===false){
+throw new $RangeError('Invalid language tag: '+aF);
+}
+var aG=%CanonicalizeLanguageTag(aF);
+if(aG==='invalid-tag'){
+throw new $RangeError('Invalid language tag: '+aF);
+}
+return aG;
+}
+function initializeLocaleList(R){
+var aH=[];
+if(R===g){
+aH=[];
+}else{
+if(typeof R==='string'){
+aH.push(canonicalizeLanguageTag(R));
+return freezeArray(aH);
+}
+var aI=ToObject(R);
+var aJ=aI.length>>>0;
+for(var aK=0;aK<aJ;aK++){
+if(aK in aI){
+var ah=aI[aK];
+var aG=canonicalizeLanguageTag(ah);
+if(aH.indexOf(aG)===-1){
+aH.push(aG);
+}
+}
+}
+}
+return freezeArray(aH);
+}
+function isValidLanguageTag(Z){
+if(GetLanguageTagRE().test(Z)===false){
+return false;
+}
+if(Z.indexOf('x-')===0){
+return true;
+}
+Z=Z.split(/-x-/)[0];
+var aL=[];
+var aM=[];
+var aB=Z.split(/-/);
+for(var Y=1;Y<aB.length;Y++){
+var ah=aB[Y];
+if(GetLanguageVariantRE().test(ah)===true&&aM.length===0){
+if(aL.indexOf(ah)===-1){
+aL.push(ah);
+}else{
+return false;
+}
+}
+if(GetLanguageSingletonRE().test(ah)===true){
+if(aM.indexOf(ah)===-1){
+aM.push(ah);
+}else{
+return false;
+}
+}
+}
+return true;
+}
+function BuildLanguageTagREs(){
+var aN='[a-zA-Z]';
+var aO='[0-9]';
+var aP='('+aN+'|'+aO+')';
+var aQ='(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|'+
+'zh-min|zh-min-nan|zh-xiang)';
+var aR='(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 aS='('+aR+'|'+aQ+')';
+var aT='(x(-'+aP+'{1,8})+)';
+var aU='('+aO+'|[A-WY-Za-wy-z])';
+u=new d('^'+aU+'$','i');
+var ak='('+aU+'(-'+aP+'{2,8})+)';
+var aV='('+aP+'{5,8}|('+aO+aP+'{3}))';
+t=new d('^'+aV+'$','i');
+var aW='('+aN+'{2}|'+aO+'{3})';
+var aX='('+aN+'{4})';
+var aY='('+aN+'{3}(-'+aN+'{3}){0,2})';
+var aZ='('+aN+'{2,3}(-'+aY+')?|'+aN+'{4}|'+
+aN+'{5,8})';
+var ba=aZ+'(-'+aX+')?(-'+aW+')?(-'+
+aV+')*(-'+ak+')*(-'+aT+')?';
+var bb=
+'^('+ba+'|'+aT+'|'+aS+')$';
+r=new d(bb,'i');
+}
+function initializeCollator(bc,R,S){
+if(%IsInitializedIntlObject(bc)){
+throw new $TypeError('Trying to re-initialize Collator object.');
+}
+if(S===g){
+S={};
+}
+var ac=getGetOption(S,'collator');
+var bd={};
+defineWEProperty(bd,'usage',ac(
+'usage','string',['sort','search'],'sort'));
+var be=ac('sensitivity','string',
+['base','accent','case','variant']);
+if(be===g&&bd.usage==='sort'){
+be='variant';
+}
+defineWEProperty(bd,'sensitivity',be);
+defineWEProperty(bd,'ignorePunctuation',ac(
+'ignorePunctuation','boolean',g,false));
+var Z=resolveLocale('collator',R,S);
+var am=parseExtension(Z.extension);
+setOptions(
+S,am,A,ac,bd);
+var bf='default';
+var ak='';
+if(am.hasOwnProperty('co')&&bd.usage==='sort'){
+if(D.indexOf(am.co)!==-1){
+ak='-u-co-'+am.co;
+bf=am.co;
+}
+}else if(bd.usage==='search'){
+ak='-u-co-search';
+}
+defineWEProperty(bd,'collation',bf);
+var bg=Z.locale+ak;
+var ai=ObjectDefineProperties({},{
+caseFirst:{writable:true},
+collation:{value:bd.collation,writable:true},
+ignorePunctuation:{writable:true},
+locale:{writable:true},
+numeric:{writable:true},
+requestedLocale:{value:bg,writable:true},
+sensitivity:{writable:true},
+strength:{writable:true},
+usage:{value:bd.usage,writable:true}
+});
+var bh=%CreateCollator(bg,
+bd,
+ai);
+%MarkAsInitializedIntlObjectOfType(bc,'collator',bh);
+ObjectDefineProperty(bc,'resolved',{value:ai});
+return bc;
+}
+%AddNamedProperty(h,'Collator',function(){
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+if(!this||this===h){
+return new h.Collator(R,S);
+}
+return initializeCollator(ToObject(this),R,S);
+},
+2
+);
+%AddNamedProperty(h.Collator.prototype,'resolvedOptions',function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if(!%IsInitializedIntlObjectOfType(this,'collator')){
+throw new $TypeError('resolvedOptions method called on a non-object '+
+'or on a object that is not Intl.Collator.');
+}
+var bi=this;
+var Z=getOptimalLanguageTag(bi.resolved.requestedLocale,
+bi.resolved.locale);
+return{
+locale:Z,
+usage:bi.resolved.usage,
+sensitivity:bi.resolved.sensitivity,
+ignorePunctuation:bi.resolved.ignorePunctuation,
+numeric:bi.resolved.numeric,
+caseFirst:bi.resolved.caseFirst,
+collation:bi.resolved.collation
+};
+},
+2
+);
+%FunctionSetName(h.Collator.prototype.resolvedOptions,'resolvedOptions');
+%FunctionRemovePrototype(h.Collator.prototype.resolvedOptions);
+%SetNativeFlag(h.Collator.prototype.resolvedOptions);
+%AddNamedProperty(h.Collator,'supportedLocalesOf',function(R){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+return supportedLocalesOf('collator',R,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(h.Collator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(h.Collator.supportedLocalesOf);
+%SetNativeFlag(h.Collator.supportedLocalesOf);
+function compare(bc,N,P){
+return %InternalCompare(%GetImplFromInitializedIntlObject(bc),
+e(N),e(P));
+};
+addBoundMethod(h.Collator,'compare',compare,2);
+function isWellFormedCurrencyCode(bj){
+return typeof bj=="string"&&
+bj.length==3&&
+bj.match(/[^A-Za-z]/)==null;
+}
+function getNumberOption(S,ad,bk,bl,bm){
+var ah=S[ad];
+if(ah!==g){
+ah=c(ah);
+if($isNaN(ah)||ah<bk||ah>bl){
+throw new $RangeError(ad+' value is out of range.');
+}
+return $floor(ah);
+}
+return bm;
+}
+function initializeNumberFormat(bn,R,S){
+if(%IsInitializedIntlObject(bn)){
+throw new $TypeError('Trying to re-initialize NumberFormat object.');
+}
+if(S===g){
+S={};
+}
+var ac=getGetOption(S,'numberformat');
+var Z=resolveLocale('numberformat',R,S);
+var bd={};
+defineWEProperty(bd,'style',ac(
+'style','string',['decimal','percent','currency'],'decimal'));
+var bj=ac('currency','string');
+if(bj!==g&&!isWellFormedCurrencyCode(bj)){
+throw new $RangeError('Invalid currency code: '+bj);
+}
+if(bd.style==='currency'&&bj===g){
+throw new $TypeError('Currency code is required with currency style.');
+}
+var bo=ac(
+'currencyDisplay','string',['code','symbol','name'],'symbol');
+if(bd.style==='currency'){
+defineWEProperty(bd,'currency',bj.toUpperCase());
+defineWEProperty(bd,'currencyDisplay',bo);
+}
+var bp=getNumberOption(S,'minimumIntegerDigits',1,21,1);
+defineWEProperty(bd,'minimumIntegerDigits',bp);
+var bq=getNumberOption(S,'minimumFractionDigits',0,20,0);
+defineWEProperty(bd,'minimumFractionDigits',bq);
+var br=getNumberOption(S,'maximumFractionDigits',bq,20,3);
+defineWEProperty(bd,'maximumFractionDigits',br);
+var bs=S['minimumSignificantDigits'];
+var bt=S['maximumSignificantDigits'];
+if(bs!==g||bt!==g){
+bs=getNumberOption(S,'minimumSignificantDigits',1,21,0);
+defineWEProperty(bd,'minimumSignificantDigits',bs);
+bt=getNumberOption(S,'maximumSignificantDigits',bs,21,21);
+defineWEProperty(bd,'maximumSignificantDigits',bt);
+}
+defineWEProperty(bd,'useGrouping',ac(
+'useGrouping','boolean',g,true));
+var am=parseExtension(Z.extension);
+var ak=setOptions(S,am,B,
+ac,bd);
+var bg=Z.locale+ak;
+var ai=ObjectDefineProperties({},{
+currency:{writable:true},
+currencyDisplay:{writable:true},
+locale:{writable:true},
+maximumFractionDigits:{writable:true},
+minimumFractionDigits:{writable:true},
+minimumIntegerDigits:{writable:true},
+numberingSystem:{writable:true},
+requestedLocale:{value:bg,writable:true},
+style:{value:bd.style,writable:true},
+useGrouping:{writable:true}
+});
+if(bd.hasOwnProperty('minimumSignificantDigits')){
+defineWEProperty(ai,'minimumSignificantDigits',g);
+}
+if(bd.hasOwnProperty('maximumSignificantDigits')){
+defineWEProperty(ai,'maximumSignificantDigits',g);
+}
+var bu=%CreateNumberFormat(bg,
+bd,
+ai);
+if(bd.style==='currency'){
+ObjectDefineProperty(ai,'currencyDisplay',{value:bo,
+writable:true});
+}
+%MarkAsInitializedIntlObjectOfType(bn,'numberformat',bu);
+ObjectDefineProperty(bn,'resolved',{value:ai});
+return bn;
+}
+%AddNamedProperty(h,'NumberFormat',function(){
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+if(!this||this===h){
+return new h.NumberFormat(R,S);
+}
+return initializeNumberFormat(ToObject(this),R,S);
+},
+2
+);
+%AddNamedProperty(h.NumberFormat.prototype,'resolvedOptions',function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if(!%IsInitializedIntlObjectOfType(this,'numberformat')){
+throw new $TypeError('resolvedOptions method called on a non-object'+
+' or on a object that is not Intl.NumberFormat.');
+}
+var bv=this;
+var Z=getOptimalLanguageTag(bv.resolved.requestedLocale,
+bv.resolved.locale);
+var bw={
+locale:Z,
+numberingSystem:bv.resolved.numberingSystem,
+style:bv.resolved.style,
+useGrouping:bv.resolved.useGrouping,
+minimumIntegerDigits:bv.resolved.minimumIntegerDigits,
+minimumFractionDigits:bv.resolved.minimumFractionDigits,
+maximumFractionDigits:bv.resolved.maximumFractionDigits,
+};
+if(bw.style==='currency'){
+defineWECProperty(bw,'currency',bv.resolved.currency);
+defineWECProperty(bw,'currencyDisplay',
+bv.resolved.currencyDisplay);
+}
+if(bv.resolved.hasOwnProperty('minimumSignificantDigits')){
+defineWECProperty(bw,'minimumSignificantDigits',
+bv.resolved.minimumSignificantDigits);
+}
+if(bv.resolved.hasOwnProperty('maximumSignificantDigits')){
+defineWECProperty(bw,'maximumSignificantDigits',
+bv.resolved.maximumSignificantDigits);
+}
+return bw;
+},
+2
+);
+%FunctionSetName(h.NumberFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(h.NumberFormat.prototype.resolvedOptions);
+%SetNativeFlag(h.NumberFormat.prototype.resolvedOptions);
+%AddNamedProperty(h.NumberFormat,'supportedLocalesOf',function(R){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+return supportedLocalesOf('numberformat',R,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(h.NumberFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(h.NumberFormat.supportedLocalesOf);
+%SetNativeFlag(h.NumberFormat.supportedLocalesOf);
+function formatNumber(bu,ah){
+var bx=c(ah)+0;
+return %InternalNumberFormat(%GetImplFromInitializedIntlObject(bu),
+bx);
+}
+function parseNumber(bu,ah){
+return %InternalNumberParse(%GetImplFromInitializedIntlObject(bu),
+e(ah));
+}
+addBoundMethod(h.NumberFormat,'format',formatNumber,1);
+addBoundMethod(h.NumberFormat,'v8Parse',parseNumber,1);
+function toLDMLString(S){
+var ac=getGetOption(S,'dateformat');
+var by='';
+var bz=ac('weekday','string',['narrow','short','long']);
+by+=appendToLDMLString(
+bz,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
+bz=ac('era','string',['narrow','short','long']);
+by+=appendToLDMLString(
+bz,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
+bz=ac('year','string',['2-digit','numeric']);
+by+=appendToLDMLString(bz,{'2-digit':'yy','numeric':'y'});
+bz=ac('month','string',
+['2-digit','numeric','narrow','short','long']);
+by+=appendToLDMLString(bz,{'2-digit':'MM','numeric':'M',
+'narrow':'MMMMM','short':'MMM','long':'MMMM'});
+bz=ac('day','string',['2-digit','numeric']);
+by+=appendToLDMLString(
+bz,{'2-digit':'dd','numeric':'d'});
+var bA=ac('hour12','boolean');
+bz=ac('hour','string',['2-digit','numeric']);
+if(bA===g){
+by+=appendToLDMLString(bz,{'2-digit':'jj','numeric':'j'});
+}else if(bA===true){
+by+=appendToLDMLString(bz,{'2-digit':'hh','numeric':'h'});
+}else{
+by+=appendToLDMLString(bz,{'2-digit':'HH','numeric':'H'});
+}
+bz=ac('minute','string',['2-digit','numeric']);
+by+=appendToLDMLString(bz,{'2-digit':'mm','numeric':'m'});
+bz=ac('second','string',['2-digit','numeric']);
+by+=appendToLDMLString(bz,{'2-digit':'ss','numeric':'s'});
+bz=ac('timeZoneName','string',['short','long']);
+by+=appendToLDMLString(bz,{short:'z',long:'zzzz'});
+return by;
+}
+function appendToLDMLString(bz,bB){
+if(bz!==g){
+return bB[bz];
+}else{
+return'';
+}
+}
+function fromLDMLString(by){
+by=by.replace(GetQuotedStringRE(),'');
+var S={};
+var bC=by.match(/E{3,5}/g);
+S=appendToDateTimeObject(
+S,'weekday',bC,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
+bC=by.match(/G{3,5}/g);
+S=appendToDateTimeObject(
+S,'era',bC,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
+bC=by.match(/y{1,2}/g);
+S=appendToDateTimeObject(
+S,'year',bC,{y:'numeric',yy:'2-digit'});
+bC=by.match(/M{1,5}/g);
+S=appendToDateTimeObject(S,'month',bC,{MM:'2-digit',
+M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
+bC=by.match(/L{1,5}/g);
+S=appendToDateTimeObject(S,'month',bC,{LL:'2-digit',
+L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
+bC=by.match(/d{1,2}/g);
+S=appendToDateTimeObject(
+S,'day',bC,{d:'numeric',dd:'2-digit'});
+bC=by.match(/h{1,2}/g);
+if(bC!==null){
+S['hour12']=true;
+}
+S=appendToDateTimeObject(
+S,'hour',bC,{h:'numeric',hh:'2-digit'});
+bC=by.match(/H{1,2}/g);
+if(bC!==null){
+S['hour12']=false;
+}
+S=appendToDateTimeObject(
+S,'hour',bC,{H:'numeric',HH:'2-digit'});
+bC=by.match(/m{1,2}/g);
+S=appendToDateTimeObject(
+S,'minute',bC,{m:'numeric',mm:'2-digit'});
+bC=by.match(/s{1,2}/g);
+S=appendToDateTimeObject(
+S,'second',bC,{s:'numeric',ss:'2-digit'});
+bC=by.match(/z|zzzz/g);
+S=appendToDateTimeObject(
+S,'timeZoneName',bC,{z:'short',zzzz:'long'});
+return S;
+}
+function appendToDateTimeObject(S,bz,bC,bB){
+if((bC===null)){
+if(!S.hasOwnProperty(bz)){
+defineWEProperty(S,bz,g);
+}
+return S;
+}
+var ad=bC[0];
+defineWEProperty(S,bz,bB[ad]);
+return S;
+}
+function toDateTimeOptions(S,bD,bE){
+if(S===g){
+S={};
+}else{
+S=((%_IsSpecObject(%IS_VAR(S)))?S:ToObject(S));
+}
+var bF=true;
+if((bD==='date'||bD==='any')&&
+(S.weekday!==g||S.year!==g||
+S.month!==g||S.day!==g)){
+bF=false;
+}
+if((bD==='time'||bD==='any')&&
+(S.hour!==g||S.minute!==g||
+S.second!==g)){
+bF=false;
+}
+if(bF&&(bE==='date'||bE==='all')){
+ObjectDefineProperty(S,'year',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+ObjectDefineProperty(S,'month',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+ObjectDefineProperty(S,'day',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+if(bF&&(bE==='time'||bE==='all')){
+ObjectDefineProperty(S,'hour',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+ObjectDefineProperty(S,'minute',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+ObjectDefineProperty(S,'second',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+return S;
+}
+function initializeDateTimeFormat(bG,R,S){
+if(%IsInitializedIntlObject(bG)){
+throw new $TypeError('Trying to re-initialize DateTimeFormat object.');
+}
+if(S===g){
+S={};
+}
+var Z=resolveLocale('dateformat',R,S);
+S=toDateTimeOptions(S,'any','date');
+var ac=getGetOption(S,'dateformat');
+var T=ac('formatMatcher','string',
+['basic','best fit'],'best fit');
+var by=toLDMLString(S);
+var bH=canonicalizeTimeZoneID(S.timeZone);
+var bd={};
+var am=parseExtension(Z.extension);
+var ak=setOptions(S,am,C,
+ac,bd);
+var bg=Z.locale+ak;
+var ai=ObjectDefineProperties({},{
+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},
+pattern:{writable:true},
+requestedLocale:{value:bg,writable:true},
+second:{writable:true},
+timeZone:{writable:true},
+timeZoneName:{writable:true},
+tz:{value:bH,writable:true},
+weekday:{writable:true},
+year:{writable:true}
+});
+var bu=%CreateDateTimeFormat(
+bg,{skeleton:by,timeZone:bH},ai);
+if(bH!==g&&bH!==ai.timeZone){
+throw new $RangeError('Unsupported time zone specified '+bH);
+}
+%MarkAsInitializedIntlObjectOfType(bG,'dateformat',bu);
+ObjectDefineProperty(bG,'resolved',{value:ai});
+return bG;
+}
+%AddNamedProperty(h,'DateTimeFormat',function(){
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+if(!this||this===h){
+return new h.DateTimeFormat(R,S);
+}
+return initializeDateTimeFormat(ToObject(this),R,S);
+},
+2
+);
+%AddNamedProperty(h.DateTimeFormat.prototype,'resolvedOptions',function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if(!%IsInitializedIntlObjectOfType(this,'dateformat')){
+throw new $TypeError('resolvedOptions method called on a non-object or '+
+'on a object that is not Intl.DateTimeFormat.');
+}
+var bv=this;
+var bI=fromLDMLString(bv.resolved.pattern);
+var bJ=z[bv.resolved.calendar];
+if(bJ===g){
+bJ=bv.resolved.calendar;
+}
+var Z=getOptimalLanguageTag(bv.resolved.requestedLocale,
+bv.resolved.locale);
+var bw={
+locale:Z,
+numberingSystem:bv.resolved.numberingSystem,
+calendar:bJ,
+timeZone:bv.resolved.timeZone
+};
+addWECPropertyIfDefined(bw,'timeZoneName',bI.timeZoneName);
+addWECPropertyIfDefined(bw,'era',bI.era);
+addWECPropertyIfDefined(bw,'year',bI.year);
+addWECPropertyIfDefined(bw,'month',bI.month);
+addWECPropertyIfDefined(bw,'day',bI.day);
+addWECPropertyIfDefined(bw,'weekday',bI.weekday);
+addWECPropertyIfDefined(bw,'hour12',bI.hour12);
+addWECPropertyIfDefined(bw,'hour',bI.hour);
+addWECPropertyIfDefined(bw,'minute',bI.minute);
+addWECPropertyIfDefined(bw,'second',bI.second);
+return bw;
+},
+2
+);
+%FunctionSetName(h.DateTimeFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(h.DateTimeFormat.prototype.resolvedOptions);
+%SetNativeFlag(h.DateTimeFormat.prototype.resolvedOptions);
+%AddNamedProperty(h.DateTimeFormat,'supportedLocalesOf',function(R){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+return supportedLocalesOf('dateformat',R,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(h.DateTimeFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(h.DateTimeFormat.supportedLocalesOf);
+%SetNativeFlag(h.DateTimeFormat.supportedLocalesOf);
+function formatDate(bu,bK){
+var bL;
+if(bK===g){
+bL=b.now();
+}else{
+bL=c(bK);
+}
+if(!$isFinite(bL)){
+throw new $RangeError('Provided date is not in valid range.');
+}
+return %InternalDateFormat(%GetImplFromInitializedIntlObject(bu),
+new b(bL));
+}
+function parseDate(bu,ah){
+return %InternalDateParse(%GetImplFromInitializedIntlObject(bu),
+e(ah));
+}
+addBoundMethod(h.DateTimeFormat,'format',formatDate,0);
+addBoundMethod(h.DateTimeFormat,'v8Parse',parseDate,1);
+function canonicalizeTimeZoneID(bM){
+if(bM===g){
+return bM;
+}
+var bN=bM.toUpperCase();
+if(bN==='UTC'||bN==='GMT'||
+bN==='ETC/UTC'||bN==='ETC/GMT'){
+return'UTC';
+}
+var bC=GetTimezoneNameCheckRE().exec(bM);
+if((bC===null)){
+throw new $RangeError('Expected Area/Location for time zone, got '+bM);
+}
+var bw=toTitleCaseWord(bC[1])+'/'+toTitleCaseWord(bC[2]);
+var Y=3;
+while(bC[Y]!==g&&Y<bC.length){
+bw=bw+'_'+toTitleCaseWord(bC[Y]);
+Y++;
+}
+return bw;
+}
+function initializeBreakIterator(bO,R,S){
+if(%IsInitializedIntlObject(bO)){
+throw new $TypeError('Trying to re-initialize v8BreakIterator object.');
+}
+if(S===g){
+S={};
+}
+var ac=getGetOption(S,'breakiterator');
+var bd={};
+defineWEProperty(bd,'type',ac(
+'type','string',['character','word','sentence','line'],'word'));
+var Z=resolveLocale('breakiterator',R,S);
+var ai=ObjectDefineProperties({},{
+requestedLocale:{value:Z.locale,writable:true},
+type:{value:bd.type,writable:true},
+locale:{writable:true}
+});
+var bP=%CreateBreakIterator(Z.locale,
+bd,
+ai);
+%MarkAsInitializedIntlObjectOfType(bO,'breakiterator',
+bP);
+ObjectDefineProperty(bO,'resolved',{value:ai});
+return bO;
+}
+%AddNamedProperty(h,'v8BreakIterator',function(){
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+if(!this||this===h){
+return new h.v8BreakIterator(R,S);
+}
+return initializeBreakIterator(ToObject(this),R,S);
+},
+2
+);
+%AddNamedProperty(h.v8BreakIterator.prototype,'resolvedOptions',
+function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if(!%IsInitializedIntlObjectOfType(this,'breakiterator')){
+throw new $TypeError('resolvedOptions method called on a non-object or '+
+'on a object that is not Intl.v8BreakIterator.');
+}
+var bQ=this;
+var Z=getOptimalLanguageTag(bQ.resolved.requestedLocale,
+bQ.resolved.locale);
+return{
+locale:Z,
+type:bQ.resolved.type
+};
+},
+2
+);
+%FunctionSetName(h.v8BreakIterator.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(h.v8BreakIterator.prototype.resolvedOptions);
+%SetNativeFlag(h.v8BreakIterator.prototype.resolvedOptions);
+%AddNamedProperty(h.v8BreakIterator,'supportedLocalesOf',
+function(R){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+return supportedLocalesOf('breakiterator',R,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(h.v8BreakIterator.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(h.v8BreakIterator.supportedLocalesOf);
+%SetNativeFlag(h.v8BreakIterator.supportedLocalesOf);
+function adoptText(bO,bR){
+%BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(bO),
+e(bR));
+}
+function first(bO){
+return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(bO));
+}
+function next(bO){
+return %BreakIteratorNext(%GetImplFromInitializedIntlObject(bO));
+}
+function current(bO){
+return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(bO));
+}
+function breakType(bO){
+return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(bO));
+}
+addBoundMethod(h.v8BreakIterator,'adoptText',adoptText,1);
+addBoundMethod(h.v8BreakIterator,'first',first,0);
+addBoundMethod(h.v8BreakIterator,'next',next,0);
+addBoundMethod(h.v8BreakIterator,'current',current,0);
+addBoundMethod(h.v8BreakIterator,'breakType',breakType,0);
+var bS={
+'collator':h.Collator,
+'numberformat':h.NumberFormat,
+'dateformatall':h.DateTimeFormat,
+'dateformatdate':h.DateTimeFormat,
+'dateformattime':h.DateTimeFormat
+};
+var bT={
+'collator':g,
+'numberformat':g,
+'dateformatall':g,
+'dateformatdate':g,
+'dateformattime':g,
+};
+function cachedOrNewService(Q,R,S,bE){
+var bU=(bE===g)?S:bE;
+if(R===g&&S===g){
+if(bT[Q]===g){
+bT[Q]=new bS[Q](R,bU);
+}
+return bT[Q];
+}
+return new bS[Q](R,bU);
+}
+OverrideFunction(e.prototype,'localeCompare',function(L){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if((this==null)){
+throw new $TypeError('Method invoked on undefined or null value.');
+}
+var R=%_Arguments(1);
+var S=%_Arguments(2);
+var bc=cachedOrNewService('collator',R,S);
+return compare(bc,this,L);
+}
+);
+OverrideFunction(e.prototype,'normalize',function(L){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["String.prototype.normalize"]);
+var bV=e(%_Arguments(0)||'NFC');
+var bW=j.indexOf(bV);
+if(bW===-1){
+throw new $RangeError('The normalization form should be one of '
++j.join(', ')+'.');
+}
+return %StringNormalize(this,bW);
+}
+);
+OverrideFunction(c.prototype,'toLocaleString',function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+if(!(this instanceof c)&&typeof(this)!=='number'){
+throw new $TypeError('Method invoked on an object that is not Number.');
+}
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+var bn=cachedOrNewService('numberformat',R,S);
+return formatNumber(bn,this);
+}
+);
+function toLocaleDateTime(bX,R,S,bD,bE,Q){
+if(!(bX instanceof b)){
+throw new $TypeError('Method invoked on an object that is not Date.');
+}
+if($isNaN(bX)){
+return'Invalid Date';
+}
+var bd=toDateTimeOptions(S,bD,bE);
+var bG=
+cachedOrNewService(Q,R,S,bd);
+return formatDate(bG,bX);
+}
+OverrideFunction(b.prototype,'toLocaleString',function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+return toLocaleDateTime(
+this,R,S,'any','all','dateformatall');
+}
+);
+OverrideFunction(b.prototype,'toLocaleDateString',function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+return toLocaleDateTime(
+this,R,S,'date','date','dateformatdate');
+}
+);
+OverrideFunction(b.prototype,'toLocaleTimeString',function(){
+if(%_IsConstructCall()){
+throw new $TypeError(E);
+}
+var R=%_Arguments(0);
+var S=%_Arguments(1);
+return toLocaleDateTime(
+this,R,S,'time','time','dateformattime');
+}
+);
+})();
+
+\0$\14proxyé8
+var $proxyDelegateCallAndConstruct;
+var $proxyDerivedGetTrap;
+var $proxyDerivedHasTrap;
+var $proxyDerivedHasOwnTrap;
+var $proxyDerivedKeysTrap;
+var $proxyDerivedSetTrap;
+var $proxyEnumerate;
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Function;
+var b=global.Object;
+function ProxyCreate(c,d){
+if(!(%_IsSpecObject(c)))
+throw MakeTypeError("handler_non_object",["create"])
+if((d===(void 0)))
+d=null
+else if(!((%_IsSpecObject(d))||(d===null)))
+throw MakeTypeError("proto_non_object",["create"])
+return %CreateJSProxy(c,d)
+}
+function ProxyCreateFunction(c,e,f){
+if(!(%_IsSpecObject(c)))
+throw MakeTypeError("handler_non_object",["create"])
+if(!(%_ClassOf(e)==='Function'))
+throw MakeTypeError("trap_function_expected",["createFunction","call"])
+if((f===(void 0))){
+f=DerivedConstructTrap(e)
+}else if((%_ClassOf(f)==='Function')){
+var g=f
+f=function(){
+return %Apply(g,(void 0),arguments,0,%_ArgumentsLength());
+}
+}else{
+throw MakeTypeError("trap_function_expected",
+["createFunction","construct"])
+}
+return %CreateJSFunctionProxy(
+c,e,f,a.prototype)
+}
+function DerivedConstructTrap(e){
+return function(){
+var d=this.prototype
+if(!(%_IsSpecObject(d)))d=b.prototype
+var h={__proto__:d};
+var i=%Apply(e,h,arguments,0,%_ArgumentsLength());
+return(%_IsSpecObject(i))?i:h
+}
+}
+function DelegateCallAndConstruct(e,f){
+return function(){
+return %Apply(%_IsConstructCall()?f:e,
+this,arguments,0,%_ArgumentsLength())
+}
+}
+function DerivedGetTrap(j,k){
+var l=this.getPropertyDescriptor(k)
+if((l===(void 0))){return l}
+if('value'in l){
+return l.value
+}else{
+if((l.get===(void 0))){return l.get}
+return %_CallFunction(j,l.get)
+}
+}
+function DerivedSetTrap(j,k,m){
+var l=this.getOwnPropertyDescriptor(k)
+if(l){
+if('writable'in l){
+if(l.writable){
+l.value=m
+this.defineProperty(k,l)
+return true
+}else{
+return false
+}
+}else{
+if(l.set){
+%_CallFunction(j,m,l.set)
+return true
+}else{
+return false
+}
+}
+}
+l=this.getPropertyDescriptor(k)
+if(l){
+if('writable'in l){
+if(l.writable){
+}else{
+return false
+}
+}else{
+if(l.set){
+%_CallFunction(j,m,l.set)
+return true
+}else{
+return false
+}
+}
+}
+this.defineProperty(k,{
+value:m,
+writable:true,
+enumerable:true,
+configurable:true});
+return true;
+}
+function DerivedHasTrap(k){
+return!!this.getPropertyDescriptor(k)
+}
+function DerivedHasOwnTrap(k){
+return!!this.getOwnPropertyDescriptor(k)
+}
+function DerivedKeysTrap(){
+var n=this.getOwnPropertyNames()
+var o=[]
+for(var p=0,count=0;p<n.length;++p){
+var k=n[p]
+if((typeof(k)==='symbol'))continue
+var l=this.getOwnPropertyDescriptor(((typeof(%IS_VAR(k))==='string')?k:NonStringToString(k)))
+if(!(l===(void 0))&&l.enumerable){
+o[count++]=n[p]
+}
+}
+return o
+}
+function DerivedEnumerateTrap(){
+var n=this.getPropertyNames()
+var o=[]
+for(var p=0,count=0;p<n.length;++p){
+var k=n[p]
+if((typeof(k)==='symbol'))continue
+var l=this.getPropertyDescriptor(((typeof(%IS_VAR(k))==='string')?k:NonStringToString(k)))
+if(!(l===(void 0))){
+if(!l.configurable){
+throw MakeTypeError(28,
+this,k,"getPropertyDescriptor")
+}
+if(l.enumerable)o[count++]=n[p]
+}
+}
+return o
+}
+function ProxyEnumerate(q){
+var c=%GetHandler(q)
+if((c.enumerate===(void 0))){
+return %Apply(DerivedEnumerateTrap,c,[],0,0)
+}else{
+return ToNameArray(c.enumerate(),"enumerate",false)
+}
+}
+var r=new b();
+%AddNamedProperty(global,"Proxy",r,2);
+InstallFunctions(r,2,[
+"create",ProxyCreate,
+"createFunction",ProxyCreateFunction
+])
+$proxyDelegateCallAndConstruct=DelegateCallAndConstruct;
+$proxyDerivedGetTrap=DerivedGetTrap;
+$proxyDerivedHasTrap=DerivedHasTrap;
+$proxyDerivedHasOwnTrap=DerivedHasOwnTrap;
+$proxyDerivedKeysTrap=DerivedKeysTrap;
+$proxyDerivedSetTrap=DerivedSetTrap;
+$proxyEnumerate=ProxyEnumerate;
+})();
+
+$generator½\1d
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Function;
+function GeneratorObjectNext(b){
+if(!(%_ClassOf(this)==='Generator')){
+throw MakeTypeError(8,
+'[Generator].prototype.next',this);
+}
+var c=%GeneratorGetContinuation(this);
+if(c>0){
+if((%_DebugIsActive()!=0))%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,b);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(c==0){
+return{value:void 0,done:true};
+}else{
+throw MakeTypeError(6);
+}
+}
+function GeneratorObjectThrow(d){
+if(!(%_ClassOf(this)==='Generator')){
+throw MakeTypeError(8,
+'[Generator].prototype.throw',this);
+}
+var c=%GeneratorGetContinuation(this);
+if(c>0){
+try{
+return %_GeneratorThrow(this,d);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(c==0){
+throw d;
+}else{
+throw MakeTypeError(6);
+}
+}
+function GeneratorObjectIterator(){
+return this;
+}
+function GeneratorFunctionConstructor(e){
+var f=NewFunctionString(arguments,'function*');
+var g=%GlobalProxy(global);
+var h=%_CallFunction(g,%CompileString(f,true));
+%FunctionMarkNameShouldPrintAsAnonymous(h);
+return h;
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var i=GeneratorFunctionPrototype.prototype;
+InstallFunctions(i,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%FunctionSetName(GeneratorObjectIterator,'[Symbol.iterator]');
+%AddNamedProperty(i,symbolIterator,
+GeneratorObjectIterator,2|4|1);
+%AddNamedProperty(i,"constructor",
+GeneratorFunctionPrototype,2|1);
+%AddNamedProperty(i,
+symbolToStringTag,"Generator",2|1);
+%InternalSetPrototype(GeneratorFunctionPrototype,a.prototype);
+%AddNamedProperty(GeneratorFunctionPrototype,
+symbolToStringTag,"GeneratorFunction",2|1);
+%AddNamedProperty(GeneratorFunctionPrototype,"constructor",
+GeneratorFunction,2|1);
+%InternalSetPrototype(GeneratorFunction,a);
+%SetCode(GeneratorFunction,GeneratorFunctionConstructor);
+})();
+
+4harmony-arrayA2
+(function(){
+'use strict';
+%CheckIsBootstrapping();
+var a=global.Array;
+var b=global.Symbol;
+function ArrayFind(c){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.find"]);
+var d=ToObject(this);
+var e=ToInteger(d.length);
+if(!(%_ClassOf(c)==='Function')){
+throw MakeTypeError(2,c);
+}
+var f;
+if(%_ArgumentsLength()>1){
+f=%_Arguments(1);
+}
+var g=false;
+if((f==null)){
+f=%GetDefaultReceiver(c)||f;
+}else{
+g=(!(%_IsSpecObject(f))&&%IsSloppyModeFunction(c));
+}
+for(var h=0;h<e;h++){
+if(h in d){
+var i=d[h];
+var j=g?ToObject(f):f;
+if(%_CallFunction(j,i,h,d,c)){
+return i;
+}
+}
+}
+return;
+}
+function ArrayFindIndex(c){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.findIndex"]);
+var d=ToObject(this);
+var e=ToInteger(d.length);
+if(!(%_ClassOf(c)==='Function')){
+throw MakeTypeError(2,c);
+}
+var f;
+if(%_ArgumentsLength()>1){
+f=%_Arguments(1);
+}
+var g=false;
+if((f==null)){
+f=%GetDefaultReceiver(c)||f;
+}else{
+g=(!(%_IsSpecObject(f))&&%IsSloppyModeFunction(c));
+}
+for(var h=0;h<e;h++){
+if(h in d){
+var i=d[h];
+var j=g?ToObject(f):f;
+if(%_CallFunction(j,i,h,d,c)){
+return h;
+}
+}
+}
+return-1;
+}
+function ArrayFill(k){
+if((this==null)&&!(%_IsUndetectableObject(this)))throw MakeTypeError('called_on_null_or_undefined',["Array.prototype.fill"]);
+var d=ToObject(this);
+var e=(d.length>>>0);
+var h=0;
+var l=e;
+if(%_ArgumentsLength()>1){
+h=%_Arguments(1);
+h=(h===(void 0))?0:(%_IsSmi(%IS_VAR(h))?h:%NumberToInteger(ToNumber(h)));
+if(%_ArgumentsLength()>2){
+l=%_Arguments(2);
+l=(l===(void 0))?e:(%_IsSmi(%IS_VAR(l))?l:%NumberToInteger(ToNumber(l)));
+}
+}
+if(h<0){
+h+=e;
+if(h<0)h=0;
+}else{
+if(h>e)h=e;
+}
+if(l<0){
+l+=e;
+if(l<0)l=0;
+}else{
+if(l>e)l=e;
+}
+if((l-h)>0&&ObjectIsFrozen(d)){
+throw MakeTypeError("array_functions_on_frozen",
+["Array.prototype.fill"]);
+}
+for(;h<l;h++)
+d[h]=k;
+return d;
+}
+function ArrayFrom(m,n,o){
+var p=ToObject(m);
+var q=!(n===(void 0));
+if(q){
+if(!(%_ClassOf(n)==='Function')){
+throw MakeTypeError(2,n);
+}else if((o==null)){
+o=%GetDefaultReceiver(n)||o;
+}else if(!(%_IsSpecObject(o))&&%IsSloppyModeFunction(n)){
+o=ToObject(o);
+}
+}
+var r=GetMethod(p,symbolIterator);
+var s;
+var t;
+var u;
+var v;
+if(!(r===(void 0))){
+t=%IsConstructor(this)?new this():[];
+var w=GetIterator(p,r);
+s=0;
+while(true){
+var x=w.next();
+if(!(%_IsObject(x))){
+throw MakeTypeError("iterator_result_not_an_object",[x]);
+}
+if(x.done){
+t.length=s;
+return t;
+}
+v=x.value;
+if(q){
+u=%_CallFunction(o,v,s,n);
+}else{
+u=v;
+}
+%AddElement(t,s++,u,0);
+}
+}else{
+var y=ToLength(p.length);
+t=%IsConstructor(this)?new this(y):new $Array(y);
+for(s=0;s<y;++s){
+v=p[s];
+if(q){
+u=%_CallFunction(o,v,s,n);
+}else{
+u=v;
+}
+%AddElement(t,s,u,0);
+}
+t.length=s;
+return t;
+}
+}
+function ArrayOf(){
+var e=%_ArgumentsLength();
+var z=this;
+var d=%IsConstructor(z)?new z(e):[];
+for(var h=0;h<e;h++){
+%AddElement(d,h,%_Arguments(h),0);
+}
+d.length=e;
+return d;
+}
+InstallConstants(b,[
+"isConcatSpreadable",symbolIsConcatSpreadable
+]);
+%FunctionSetLength(ArrayFrom,1);
+InstallFunctions(a,2,[
+"from",ArrayFrom,
+"of",ArrayOf
+]);
+InstallFunctions(a.prototype,2,[
+"find",ArrayFind,
+"findIndex",ArrayFindIndex,
+"fill",ArrayFill
+]);
+})();
+
+Xharmony-array-includesí\ 6
+(function(){
+'use strict';
+%CheckIsBootstrapping();
+var a=global.Array;
+function ArrayIncludes(b,c){
+var d=ToObject(this);
+var e=ToLength(d.length);
+if(e===0){
+return false;
+}
+var f=ToInteger(c);
+var g;
+if(f>=0){
+g=f;
+}else{
+g=e+f;
+if(g<0){
+g=0;
+}
+}
+while(g<e){
+var h=d[g];
+if(SameValueZero(b,h)){
+return true;
+}
+++g;
+}
+return false;
+}
+%FunctionSetLength(ArrayIncludes,1);
+InstallFunctions(a.prototype,2,[
+"includes",ArrayIncludes
+]);
+})();
+
+@harmony-tostring)\ 2
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+var a=global.Symbol;
+InstallConstants(a,[
+"toStringTag",symbolToStringTag
+]);
+})();
+
+Hharmony-typedarrayi~
+(function(){
+"use strict";
+%CheckIsBootstrapping();
+function Uint8ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Uint8ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Int8ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Int8ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Uint16ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Uint16ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Int16ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Int16ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Uint32ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Uint32ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Int32ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Int32ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Float32ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Float32ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Float64ArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Float64ArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+function Uint8ClampedArrayForEach(a){
+if(!%IsTypedArray(this)){
+throw MakeTypeError('not_typed_array',[]);
+}
+if(!(%_ClassOf(a)==='Function'))throw MakeTypeError(2,a);
+var b=%_TypedArrayGetLength(this);
+var c;
+if(%_ArgumentsLength()>1){
+c=%_Arguments(1);
+}
+var d=false;
+if((c==null)){
+c=%GetDefaultReceiver(a)||c;
+}else{
+d=(!(%_IsSpecObject(c))&&%IsSloppyModeFunction(a));
+}
+var e=(%_DebugIsActive()!=0)&&%DebugCallbackSupportsStepping(a);
+for(var f=0;f<b;f++){
+var g=this[f];
+if(e)%DebugPrepareStepInIfStepping(a);
+var h=d?ToObject(c):c;
+%_CallFunction(h,((%_IsSpecObject(%IS_VAR(g)))?g:ToObject(g)),f,this,a);
+}
+}
+function Uint8ClampedArrayOf(){
+var b=%_ArgumentsLength();
+var i=new this(b);
+for(var f=0;f<b;f++){
+i[f]=%_Arguments(f);
+}
+return i;
+}
+
+
+InstallFunctions(global.Uint8Array,2|4|1,[
+"of",Uint8ArrayOf
+]);
+InstallFunctions(global.Uint8Array.prototype,2,[
+"forEach",Uint8ArrayForEach
+]);
+
+InstallFunctions(global.Int8Array,2|4|1,[
+"of",Int8ArrayOf
+]);
+InstallFunctions(global.Int8Array.prototype,2,[
+"forEach",Int8ArrayForEach
+]);
+
+InstallFunctions(global.Uint16Array,2|4|1,[
+"of",Uint16ArrayOf
+]);
+InstallFunctions(global.Uint16Array.prototype,2,[
+"forEach",Uint16ArrayForEach
+]);
+
+InstallFunctions(global.Int16Array,2|4|1,[
+"of",Int16ArrayOf
+]);
+InstallFunctions(global.Int16Array.prototype,2,[
+"forEach",Int16ArrayForEach
+]);
+
+InstallFunctions(global.Uint32Array,2|4|1,[
+"of",Uint32ArrayOf
+]);
+InstallFunctions(global.Uint32Array.prototype,2,[
+"forEach",Uint32ArrayForEach
+]);
+
+InstallFunctions(global.Int32Array,2|4|1,[
+"of",Int32ArrayOf
+]);
+InstallFunctions(global.Int32Array.prototype,2,[
+"forEach",Int32ArrayForEach
+]);
+
+InstallFunctions(global.Float32Array,2|4|1,[
+"of",Float32ArrayOf
+]);
+InstallFunctions(global.Float32Array.prototype,2,[
+"forEach",Float32ArrayForEach
+]);
+
+InstallFunctions(global.Float64Array,2|4|1,[
+"of",Float64ArrayOf
+]);
+InstallFunctions(global.Float64Array.prototype,2,[
+"forEach",Float64ArrayForEach
+]);
+
+InstallFunctions(global.Uint8ClampedArray,2|4|1,[
+"of",Uint8ClampedArrayOf
+]);
+InstallFunctions(global.Uint8ClampedArray.prototype,2,[
+"forEach",Uint8ClampedArrayForEach
+]);
+
+
+})();
+
+8harmony-regexp5\a
+(function(){
+'use strict';
+%CheckIsBootstrapping();
+var a=global.RegExp;
+function RegExpGetFlags(){
+if(!(%_IsSpecObject(this))){
+throw MakeTypeError('flags_getter_non_object',
+[%ToString(this)]);
+}
+var b='';
+if(this.global)b+='g';
+if(this.ignoreCase)b+='i';
+if(this.multiline)b+='m';
+if(this.unicode)b+='u';
+if(this.sticky)b+='y';
+return b;
+}
+%DefineAccessorPropertyUnchecked(a.prototype,'flags',
+RegExpGetFlags,null,2);
+%SetNativeFlag(RegExpGetFlags);
+})();
+
+<harmony-reflect\89\ 2
+(function(){
+'use strict';
+%CheckIsBootstrapping();
+var a=global.Reflect;
+InstallFunctions(a,2,[
+"apply",$reflectApply,
+"construct",$reflectConstruct
+]);
+})();
+
+8harmony-spread}\a
+var $spreadArguments;
+var $spreadIterable;
+(function(){
+'use strict';
+function SpreadArguments(){
+var a=%_ArgumentsLength();
+var b=new InternalArray();
+for(var c=0;c<a;++c){
+var d=%_Arguments(c);
+var e=d.length;
+for(var f=0;f<e;++f){
+b.push(d[f]);
+}
+}
+return b;
+}
+function SpreadIterable(g){
+if((g==null)){
+throw MakeTypeError(15,g);
+}
+var b=new InternalArray();
+for(var h of g){
+b.push(h);
+}
+return b;
+}
+$spreadArguments=SpreadArguments;
+$spreadIterable=SpreadIterable;
+})();
+