SNT

brython.js (732739B)

---

 // brython.js brython.info
 // version [3, 8, 0, 'final', 0]
 // implementation [3, 8, 10, 'final', 0]
 // version compiled from commented, indented source files at
 // github.com/brython-dev/brython
 var __BRYTHON__=__BRYTHON__ ||{}
 try{
 eval("async function* f(){}")}catch(err){console.warn("Your browser is not fully supported. If you are using "+
 "Microsoft Edge, please upgrade to the latest version")}
 ;(function($B){
 $B.isWebWorker=('undefined' !==typeof WorkerGlobalScope)&&
 ("function"===typeof importScripts)&&
 (navigator instanceof WorkerNavigator)
 $B.isNode=(typeof process !=='undefined')&&(process.release.name==='node')
 var _window
 if($B.isNode){_window={location:{href:'',origin:'',pathname:''},navigator:{userLanguage:''}}}else{
 _window=self}
 var href=_window.location.href
 $B.protocol=href.split(':')[0]
 $B.BigInt=_window.BigInt
 var $path
 if($B.brython_path===undefined){
 var this_url;
 if($B.isWebWorker){this_url=_window.location.href;
 if(this_url.startsWith("blob:")){this_url=this_url.substr(5)}}else{var scripts=document.getElementsByTagName('script')
 this_url=scripts[scripts.length-1].src}
 var elts=this_url.split('/')
 elts.pop()
 $path=$B.brython_path=elts.join('/')+'/'}else{if(! $B.brython_path.endsWith("/")){$B.brython_path+="/"}
 $path=$B.brython_path}
 var path=_window.location.origin+_window.location.pathname,path_elts=path.split("/")
 path_elts.pop()
 var $script_dir=$B.script_dir=path_elts.join("/")
 $B.__ARGV=[]
 $B.webworkers={}
 $B.$py_module_path={}
 $B.file_cache={}
 $B.$py_src={}
 $B.path=[$path+'Lib',$path+'libs',$script_dir,$path+'Lib/site-packages']
 $B.async_enabled=false
 if($B.async_enabled){$B.block={}}
 $B.imported={}
 $B.precompiled={}
 $B.frames_stack=[]
 $B.builtins={}
 $B.builtins_scope={id:'__builtins__',module:'__builtins__',binding:{}}
 $B.builtin_funcs={}
 $B.builtin_classes=[]
 $B.__getattr__=function(attr){return this[attr]}
 $B.__setattr__=function(attr,value){
 if(['debug','stdout','stderr'].indexOf(attr)>-1){$B[attr]=value}
 else{throw $B.builtins.AttributeError.$factory(
 '__BRYTHON__ object has no attribute '+attr)}}
 $B.language=_window.navigator.userLanguage ||_window.navigator.language
 $B.locale="C" 
 if($B.isWebWorker){$B.charset="utf-8"}else{
 $B.charset=document.characterSet ||document.inputEncoding ||"utf-8"}
 $B.max_int=Math.pow(2,53)-1
 $B.min_int=-$B.max_int
 $B.$py_next_hash=Math.pow(2,53)-1
 $B.$py_UUID=0
 $B.lambda_magic=Math.random().toString(36).substr(2,8)
 $B.set_func_names=function(klass,module){if(klass.$infos){var name=klass.$infos.__name__
 klass.$infos.__module__=module
 klass.$infos.__qualname__=name}else{var name=klass.__name__
 klass.$infos={__name__:name,__module__:module,__qualname__:name}}
 klass.__module__=module
 for(var attr in klass){if(typeof klass[attr]=='function'){klass[attr].$infos={__doc__:klass[attr].__doc__ ||"",__module__:module,__qualname__ :name+'.'+attr,__name__:attr}
 if(klass[attr].$type=="classmethod"){klass[attr].__class__=$B.method}}}}
 var has_storage=typeof(Storage)!=="undefined"
 if(has_storage){$B.has_local_storage=false
 try{if(localStorage){$B.local_storage=localStorage
 $B.has_local_storage=true}}catch(err){}
 $B.has_session_storage=false
 try{if(sessionStorage){$B.session_storage=sessionStorage
 $B.has_session_storage=true}}catch(err){}}else{$B.has_local_storage=false
 $B.has_session_storage=false}
 $B.globals=function(){
 return $B.frames_stack[$B.frames_stack.length-1][3]}
 $B.scripts={}
 $B.$options={}
 $B.update_VFS=function(scripts){$B.VFS=$B.VFS ||{}
 var vfs_timestamp=scripts.$timestamp
 if(vfs_timestamp !==undefined){delete scripts.$timestamp}
 for(var script in scripts){if($B.VFS.hasOwnProperty(script)){console.warn("Virtual File System: duplicate entry "+script)}
 $B.VFS[script]=scripts[script]
 $B.VFS[script].timestamp=vfs_timestamp}}
 $B.add_files=function(files){
 $B.files=$B.files ||{}
 for(var file in files){$B.files[file]=files[file]}}
 $B.python_to_js=function(src,script_id){$B.meta_path=$B.$meta_path.slice()
 if(!$B.use_VFS){$B.meta_path.shift()}
 if(script_id===undefined){script_id="__main__"}
 var root=__BRYTHON__.py2js(src,script_id,script_id),js=root.to_js()
 js="(function() {\n var $locals_"+script_id+" = {}\n"+js+"\n}())"
 return js}
 _window.py=function(src){
 var root=$B.py2js(src[0],"script","script"),js=root.to_js()
 $B.set_import_paths()
 new Function("$locals_script",js)({})}})(__BRYTHON__)
 ;
 __BRYTHON__.implementation=[3,8,10,'final',0]
 __BRYTHON__.__MAGIC__="3.8.10"
 __BRYTHON__.version_info=[3,8,0,'final',0]
 __BRYTHON__.compiled_date="2020-12-22 19:11:55.764534"
 __BRYTHON__.timestamp=1608660715764
 __BRYTHON__.builtin_module_names=["_aio","_ajax","_base64","_binascii","_io_classes","_json","_jsre","_locale","_multiprocessing","_posixsubprocess","_profile","_sre_utils","_string","_strptime","_svg","_warnings","_webcomponent","_webworker","_zlib_utils","array","builtins","dis","hashlib","long_int","marshal","math","modulefinder","posix","random","unicodedata"]
 ;
 
 ;(function($B){Number.isInteger=Number.isInteger ||function(value){return typeof value==='number' &&
 isFinite(value)&&
 Math.floor(value)===value};
 Number.isSafeInteger=Number.isSafeInteger ||function(value){return Number.isInteger(value)&& Math.abs(value)<=Number.MAX_SAFE_INTEGER;};
 var js,$pos,res,$op
 var _b_=$B.builtins
 var _window
 if($B.isNode){_window={location:{href:'',origin:'',pathname:''}}}else{
 _window=self}
 $B.parser={}
 var clone=$B.clone=function(obj){var res={}
 for(var attr in obj){res[attr]=obj[attr]}
 return res}
 $B.last=function(table){if(table===undefined){console.log($B.frames_stack.slice())}
 return table[table.length-1]}
 $B.list2obj=function(list,value){var res={},i=list.length
 if(value===undefined){value=true}
 while(i--> 0){res[list[i]]=value}
 return res}
 $B.op2method={operations:{"**":"pow","//":"floordiv","<<":"lshift",">>":"rshift","+":"add","-":"sub","*":"mul","/":"truediv","%":"mod","@":"matmul" },augmented_assigns:{"//=":"ifloordiv",">>=":"irshift","<<=":"ilshift","**=":"ipow","+=":"iadd","-=":"isub","*=":"imul","/=":"itruediv","%=":"imod","&=":"iand","|=":"ior","^=":"ixor","@=":"imatmul"},binary:{"&":"and","|":"or","~":"invert","^":"xor"},comparisons:{"<":"lt",">":"gt","<=":"le",">=":"ge","==":"eq","!=":"ne"},boolean:{"or":"or","and":"and","in":"in","not":"not","is":"is","not_in":"not_in","is_not":"is_not" },subset:function(){var res={},keys=[]
 if(arguments[0]=="all"){keys=Object.keys($B.op2method)
 keys.splice(keys.indexOf("subset"),1)}else{for(var i=0,len=arguments.length;i < len;i++){keys.push(arguments[i])}}
 for(var i=0,len=keys.length;i < len;i++){var key=keys[i],ops=$B.op2method[key]
 if(ops===undefined){throw Error(key)}
 for(var attr in ops){res[attr]=ops[attr]}}
 return res}}
 var $operators=$B.op2method.subset("all")
 var $augmented_assigns=$B.augmented_assigns=$B.op2method.augmented_assigns
 var noassign=$B.list2obj(['True','False','None','__debug__'])
 var $op_order=[['or'],['and'],['not'],['in','not_in'],['<','<=','>','>=','!=','==','is','is_not'],['|'],['^'],['&'],['>>','<<'],['+'],['-'],['*','@','/','//','%'],['unary_neg','unary_inv','unary_pos'],['**']
 ]
 var $op_weight={},$weight=1
 $op_order.forEach(function(_tmp){_tmp.forEach(function(item){$op_weight[item]=$weight})
 $weight++})
 var $loop_num=0
 var create_temp_name=$B.parser.create_temp_name=function(prefix){var _prefix=prefix ||'$temp'
 return _prefix+$loop_num++;}
 var replace_node=$B.parser.replace_node=function(replace_what,replace_with){var parent=replace_what.parent
 var pos=get_rank_in_parent(replace_what)
 parent.children[pos]=replace_with
 replace_with.parent=parent
 replace_with.bindings=replace_what.bindings}
 var get_rank_in_parent=$B.parser.get_rank_in_parent=function(node){return node.parent.children.indexOf(node)}
 var add_identnode=$B.parser.add_identnode=function(parent,insert_at,name,val){var new_node=new $Node()
 new_node.parent=parent
 new_node.locals=parent.locals
 new_node.module=parent.module
 var new_ctx=new $NodeCtx(new_node)
 var expr_ctx=new $ExprCtx(new_ctx,'id',true)
 var idctx=new $IdCtx(expr_ctx,name)
 var assign=new $AssignCtx(expr_ctx)
 if(insert_at===-1)
 parent.add(new_node)
 else
 parent.insert(insert_at,new_node)
 assign.tree[1]=val
 return new_node}
 var chained_comp_num=0
 var $_SyntaxError=$B.parser.$_SyntaxError=function(C,msg,indent){
 var ctx_node=C
 while(ctx_node.type !=='node'){ctx_node=ctx_node.parent}
 var tree_node=ctx_node.node,root=tree_node
 while(root.parent !==undefined){root=root.parent}
 var module=tree_node.module,src=root.src,line_num=tree_node.line_num
 if(src){line_num=src.substr(0,$pos).split("\n").length}
 if(root.line_info){line_num=root.line_info}
 if(indent===undefined ||typeof indent !="number"){if(Array.isArray(msg)){$B.$SyntaxError(module,msg[0],src,$pos,line_num,root)}
 if(msg==="Triple string end not found"){
 $B.$SyntaxError(module,'invalid syntax : triple string end not found',src,$pos,line_num,root)}
 var message='invalid syntax'
 if(!(msg.startsWith("token "))){message+=' ('+msg+')'}
 $B.$SyntaxError(module,message,src,$pos,line_num,root)}else{throw $B.$IndentationError(module,msg,src,$pos,line_num,root)}}
 function SyntaxWarning(C,msg){var node=$get_node(C),module=$get_module(C),src=module.src,lines=src.split("\n"),message=`Module ${module.module}line ${node.line_num}:${msg}\n`+
 '    '+lines[node.line_num-1]
 $B.$getattr($B.stderr,"write")(message)}
 function check_assignment(C){var ctx=C,forbidden=['assert','del','import','raise','return']
 while(ctx){if(forbidden.indexOf(ctx.type)>-1){$_SyntaxError(C,'invalid syntax - assign')}else if(ctx.type=="expr" &&
 ctx.tree[0].type=="op"){if($B.op2method.comparisons[ctx.tree[0].op]!==undefined){$_SyntaxError(C,["cannot assign to comparison"])}else{$_SyntaxError(C,["cannot assign to operator"])}}
 ctx=ctx.parent}}
 var $Node=$B.parser.$Node=function(type){this.type=type
 this.children=[]}
 $Node.prototype.add=function(child){
 this.children[this.children.length]=child
 child.parent=this
 child.module=this.module}
 $Node.prototype.insert=function(pos,child){
 this.children.splice(pos,0,child)
 child.parent=this
 child.module=this.module}
 $Node.prototype.toString=function(){return "<object 'Node'>"}
 $Node.prototype.show=function(indent){
 var res=''
 if(this.type==='module'){this.children.forEach(function(child){res+=child.show(indent)})
 return res}
 indent=indent ||0
 res+=' '.repeat(indent)
 res+=this.C
 if(this.children.length > 0){res+='{'}
 res+='\n'
 this.children.forEach(function(child){res+='['+i+'] '+child.show(indent+4)})
 if(this.children.length > 0){res+=' '.repeat(indent)
 res+='}\n'}
 return res}
 $Node.prototype.to_js=function(indent){
 if(this.js !==undefined){return this.js}
 this.res=[]
 this.unbound=[]
 if(this.type==='module'){this.children.forEach(function(child){this.res.push(child.to_js())},this)
 this.js=this.res.join('')
 return this.js}
 indent=indent ||0
 var ctx_js=this.C.to_js()
 if(ctx_js){
 this.res.push(' '.repeat(indent))
 this.res.push(ctx_js)
 if(this.children.length > 0){this.res.push('{')}
 this.res.push('\n')
 this.children.forEach(function(child){this.res.push(child.to_js(indent+4))},this)
 if(this.children.length > 0){this.res.push(' '.repeat(indent))
 this.res.push('}\n')}}
 this.js=this.res.join('')
 return this.js}
 $Node.prototype.transform=function(rank){
 if(this.has_await){this.parent.insert(rank,$NodeJS("var save_stack = $B.save_stack()"))
 this.parent.insert(rank+2,$NodeJS("$B.restore_stack(save_stack, $locals)"))
 this.has_await=false 
 return 1}
 if(this.has_yield && ! this.has_yield.transformed){
 var parent=this.parent
 if(this.has_yield.from){var new_node=new $Node()
 var new_ctx=new $NodeCtx(new_node)
 var new_expr=new $ExprCtx(new_ctx,'js',false)
 var _id=new $RawJSCtx(new_expr,`var _i${this.has_yield.from_num}`)
 var assign=new $AssignCtx(new_expr)
 var right=new $ExprCtx(assign)
 right.tree=this.has_yield.tree
 parent.insert(rank,new_node)
 var pnode=$get_node(this.has_yield)
 var n=this.has_yield.from_num
 var replace_with=`$B.$import("sys",[],{})
 _i${n}=_b_.iter(_i${n})
 var $failed${n}=false
 try{var _y${n}=_b_.next(_i${n})}catch(_e){$B.set_exc(_e)
 $failed${n}=true
 $B.pmframe=$B.last($B.frames_stack)
 _e=$B.exception(_e)
 if(_e.__class__===_b_.StopIteration){var _r${n}=$B.$getattr(_e,"value")}else{throw _e}}
 if(! $failed${n}){while(true){var $failed1${n}=false
 try{$B.leave_frame({$locals})
 var _s${n}=yield _y${n}
 $B.frames_stack.push($top_frame)}catch(_e){if(_e.__class__===_b_.GeneratorExit){var $failed2${n}=false
 try{var _m${n}=$B.$geatttr(_i${n},"close")}catch(_e1){$failed2${n}=true
 if(_e1.__class__ !==_b_.AttributeError){throw _e1}}
 if(! $failed2${n}){$B.$call(_m${n})()}
 throw _e}else if($B.is_exc(_e,[_b_.BaseException])){var _x=$B.$call($B.$getattr($locals.sys,"exc_info"))()
 var $failed3${n}=false
 try{var _m${n}=$B.$getattr(_i${n},"throw")}catch(err){$failed3${n}=true
 if($B.is_exc(err,[_b_.AttributeError])){throw err}}
 if(! $failed3${n}){try{_y${n}=$B.$call(_m${n}).apply(null,_b_.list.$factory(_x${n}))}catch(err){if($B.$is_exc(err,[_b_.StopIteration])){_r${n}=$B.$getattr(err,"value")
 break}
 throw err}}}}
 if(! $failed1${n}){try{if(_s${n}===_b_.None){_y${n}=_b_.next(_i${n})}else{_y${n}=$B.$call($B.$getattr(_i${n},"send"))(_s${n})}}catch(err){if($B.is_exc(err,[_b_.StopIteration])){_r${n}=$B.$getattr(err,"value")
 break}
 throw err}}}}`
 parent.insert(rank+1,$NodeJS(replace_with))
 return 3}
 parent.children.splice(rank,1)
 if(this.has_yield.tree[0].type==='abstract_expr'){new_node=$NodeJS("var result = _b_.None")}else{var new_node=new $Node()
 var new_ctx=new $NodeCtx(new_node)
 var new_expr=new $ExprCtx(new_ctx,'js',false)
 var _id=new $RawJSCtx(new_expr,'var result')
 var assign=new $AssignCtx(new_expr)
 assign.tree[1]=this.has_yield.tree[0]
 _id.parent=assign}
 new_node.line_num=this.line_num
 parent.insert(rank,new_node)
 var try_node=new $NodeJS("try")
 try_node.add($NodeJS("$B.leave_frame({$locals})"))
 try_node.add(this)
 parent.insert(rank+1,try_node)
 this.has_yield.to_js=function(){return 'yield result'}
 this.has_yield.transformed=true
 var i=0
 while(i < try_node.children.length){var offset=try_node.children[i].transform(i)
 if(offset===undefined){offset=1}
 i+=offset}
 var catch_node=$NodeJS(`catch(err${this.line_num})`)
 catch_node.add($NodeJS("$B.frames_stack.push($top_frame)"))
 catch_node.add($NodeJS(`throw err${this.line_num}`))
 parent.insert(rank+2,catch_node)
 parent.insert(rank+3,$NodeJS("$B.frames_stack.push($top_frame)"))
 return 2}
 if(this.type==='module'){
 this.__doc__=$get_docstring(this)
 var i=0
 while(i < this.children.length){var offset=this.children[i].transform(i)
 if(offset===undefined){offset=1}
 i+=offset}}else{var elt=this.C.tree[0],ctx_offset
 if(elt===undefined){console.log(this)}
 if(elt.transform !==undefined){ctx_offset=elt.transform(this,rank)}
 var i=0
 while(i < this.children.length){var offset=this.children[i].transform(i)
 if(offset===undefined){offset=1}
 i+=offset}
 if(ctx_offset===undefined){ctx_offset=1}
 return ctx_offset}}
 $Node.prototype.clone=function(){var res=new $Node(this.type)
 for(var attr in this){res[attr]=this[attr]}
 return res}
 $Node.prototype.clone_tree=function(){var res=new $Node(this.type)
 for(var attr in this){res[attr]=this[attr]}
 res.children=[]
 for(var i=0,len=this.children.length;i < len;i++){res.add(this.children[i].clone_tree())}
 return res}
 var $AbstractExprCtx=$B.parser.$AbstractExprCtx=function(C,with_commas){this.type='abstract_expr'
 this.with_commas=with_commas
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $AbstractExprCtx.prototype.toString=function(){return '(abstract_expr '+this.with_commas+') '+this.tree}
 $AbstractExprCtx.prototype.transition=function(token,value){var C=this
 var packed=C.packed,is_await=C.is_await,assign=C.assign
 if(! assign){switch(token){case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 case 'yield':
 C.parent.tree.pop()
 var commas=C.with_commas
 C=C.parent
 C.packed=packed
 C.is_await=is_await
 if(assign){console.log("set assign to parent",C)
 C.assign=assign}}}
 switch(token){case 'await':
 return new $AwaitCtx(C)
 case 'id':
 return new $IdCtx(new $ExprCtx(C,'id',commas),value)
 case 'str':
 return new $StringCtx(new $ExprCtx(C,'str',commas),value)
 case 'bytes':
 return new $StringCtx(new $ExprCtx(C,'bytes',commas),value)
 case 'int':
 return new $NumberCtx('int',new $ExprCtx(C,'int',commas),value)
 case 'float':
 return new $NumberCtx('float',new $ExprCtx(C,'float',commas),value)
 case 'imaginary':
 return new $NumberCtx('imaginary',new $ExprCtx(C,'imaginary',commas),value)
 case '(':
 return new $ListOrTupleCtx(
 new $ExprCtx(C,'tuple',commas),'tuple')
 case '[':
 return new $ListOrTupleCtx(
 new $ExprCtx(C,'list',commas),'list')
 case '{':
 return new $DictOrSetCtx(
 new $ExprCtx(C,'dict_or_set',commas))
 case '.':
 return new $EllipsisCtx(
 new $ExprCtx(C,'ellipsis',commas))
 case 'not':
 if(C.type=='op' && C.op=='is'){
 C.op='is_not'
 return C}
 return new $NotCtx(new $ExprCtx(C,'not',commas))
 case 'lambda':
 return new $LambdaCtx(new $ExprCtx(C,'lambda',commas))
 case 'op':
 var tg=value
 switch(tg){case '*':
 C.parent.tree.pop()
 var commas=C.with_commas
 C=C.parent
 return new $PackedCtx(
 new $ExprCtx(C,'expr',commas))
 case '-':
 case '~':
 case '+':
 C.parent.tree.pop()
 var left=new $UnaryCtx(C.parent,tg)
 if(tg=='-'){var op_expr=new $OpCtx(left,'unary_neg')}else if(tg=='+'){var op_expr=new $OpCtx(left,'unary_pos')}else{var op_expr=new $OpCtx(left,'unary_inv')}
 return new $AbstractExprCtx(op_expr,false)
 case 'not':
 C.parent.tree.pop()
 var commas=C.with_commas
 C=C.parent
 return new $NotCtx(
 new $ExprCtx(C,'not',commas))}
 $_SyntaxError(C,'token '+token+' after '+
 C)
 case '=':
 $_SyntaxError(C,'token '+token+' after '+
 C)
 case 'yield':
 return new $AbstractExprCtx(new $YieldCtx(C),true)
 case ':':
 if(C.parent.type=="sub" ||
 (C.parent.type=="list_or_tuple" &&
 C.parent.parent.type=="sub")){return new $AbstractExprCtx(new $SliceCtx(C.parent),false)}
 return $transition(C.parent,token,value)
 case ')':
 case ',':
 switch(C.parent.type){case 'list_or_tuple':
 case 'slice':
 case 'call_arg':
 case 'op':
 case 'yield':
 break
 case 'annotation':
 $_SyntaxError(C,"empty annotation")
 default:
 $_SyntaxError(C,token)}}
 return $transition(C.parent,token,value)}
 $AbstractExprCtx.prototype.to_js=function(){this.js_processed=true
 if(this.type==='list')return '['+$to_js(this.tree)+']'
 return $to_js(this.tree)}
 var $AliasCtx=$B.parser.$AliasCtx=function(C){
 this.type='ctx_manager_alias'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length-1].alias=this}
 $AliasCtx.prototype.transition=function(token,value){var C=this
 switch(token){case ',':
 case ':':
 C.parent.set_alias(C.tree[0].tree[0])
 return $transition(C.parent,token,value)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 var $AnnotationCtx=$B.parser.$AnnotationCtx=function(C){
 this.type='annotation'
 this.parent=C
 this.tree=[]
 C.annotation=this
 var scope=$get_scope(C)
 if(scope.binding.__annotations__===undefined){
 scope.binding.__annotations__=true
 C.create_annotations=true}
 if(scope.ntype=="def" && C.tree && C.tree.length > 0 &&
 C.tree[0].type=="id"){var name=C.tree[0].value
 if(scope.globals && scope.globals.has(name)>-1){$_SyntaxError(C,["annotated name '"+name+
 "' can't be global"])}
 scope.annotations=scope.annotations ||new Set()
 scope.annotations.add(name)
 if(! C.$in_parens){scope.binding=scope.binding ||{}
 scope.binding[name]=true}}}
 $AnnotationCtx.prototype.toString=function(){return '(annotation) '+this.tree}
 $AnnotationCtx.prototype.transition=function(token,value){var C=this
 if(token=="eol" && C.tree.length==1 &&
 C.tree[0].tree.length==0){$_SyntaxError(C,"empty annotation")}else if(token==':' && C.parent.type !="def"){$_SyntaxError(C,"more than one annotation")}else if(token=="augm_assign"){$_SyntaxError(C,"augmented assign as annotation")}else if(token=="op"){$_SyntaxError(C,"operator as annotation")}
 return $transition(C.parent,token)}
 $AnnotationCtx.prototype.to_js=function(){return $to_js(this.tree)}
 var $AssertCtx=$B.parser.$AssertCtx=function(C){
 this.type='assert'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $AssertCtx.prototype.toString=function(){return '(assert) '+this.tree}
 $AssertCtx.prototype.transition=function(token,value){var C=this
 if(token==","){if(this.tree.length > 1){$_SyntaxError(C,"too many commas after assert")}
 return new $AbstractExprCtx(this,false)}
 if(token=='eol'){return $transition(C.parent,token)}
 $_SyntaxError(C,token)}
 $AssertCtx.prototype.transform=function(node,rank){if(this.tree.length > 1){
 var condition=this.tree[0]
 var message=this.tree[1]}else{var condition=this.tree[0]
 var message=null}
 if(this.tree[0].type=="expr" && this.tree[0].name=="tuple" &&
 this.tree[0].tree[0].tree.length > 1){SyntaxWarning(this,"assertion is always true, perhaps "+
 "remove parentheses?")}
 var new_ctx=new $ConditionCtx(node.C,'if')
 var not_ctx=new $NotCtx(new_ctx)
 not_ctx.tree=[condition]
 node.C=new_ctx
 var new_node=new $Node()
 var js='throw _b_.AssertionError.$factory()'
 if(message !==null){js='throw _b_.AssertionError.$factory(_b_.str.$factory('+
 message.to_js()+'))'}
 new $NodeJSCtx(new_node,js)
 node.add(new_node)}
 var $AssignCtx=$B.parser.$AssignCtx=function(C,expression){
 check_assignment(C)
 if(C.type=="expr" && C.tree[0].type=="lambda"){$_SyntaxError(C,["cannot assign to lambda"])}
 this.type='assign'
 if(expression=='expression'){this.expression=true
 console.log("parent of assign expr",C.parent)}
 C.parent.tree.pop()
 C.parent.tree[C.parent.tree.length]=this
 this.parent=C.parent
 this.tree=[C]
 var scope=$get_scope(this)
 if(C.type=='expr' && C.tree[0].type=='call'){$_SyntaxError(C,["cannot assign to function call "])}else if(C.type=='list_or_tuple' ||
 (C.type=='expr' && C.tree[0].type=='list_or_tuple')){if(C.type=='expr'){C=C.tree[0]}
 C.bind_ids(scope)}else if(C.type=='assign'){C.tree.forEach(function(elt){var assigned=elt.tree[0]
 if(assigned.type=='id'){$bind(assigned.value,scope,this)}},this)}else{var assigned=C.tree[0]
 if(assigned && assigned.type=='id'){if(noassign[assigned.value]===true){$_SyntaxError(C,["cannot assign to keyword"])}
 assigned.bound=true
 if(!scope.globals ||!scope.globals.has(assigned.value)){
 var node=$get_node(this)
 node.bound_before=Object.keys(scope.binding)
 $bind(assigned.value,scope,this)}else{
 var module=$get_module(C)
 assigned.global_module=module.module
 $bind(assigned.value,module,this)}}else if(["str","int","float","complex"].indexOf(assigned.type)>-1){$_SyntaxError(C,["cannot assign to literal"])}else if(assigned.type=="unary"){$_SyntaxError(C,["cannot assign to operator"])}}}
 $AssignCtx.prototype.guess_type=function(){return}
 $AssignCtx.prototype.toString=function(){return '(assign) '+this.tree[0]+'='+this.tree[1]}
 $AssignCtx.prototype.transition=function(token,value){var C=this
 if(token=='eol'){if(C.tree[1].type=='abstract_expr'){$_SyntaxError(C,'token '+token+' after '+
 C)}
 C.guess_type()
 return $transition(C.parent,'eol')}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $AssignCtx.prototype.transform=function(node,rank){
 var scope=$get_scope(this)
 var left=this.tree[0],right=this.tree[1],assigned=[]
 while(left.type=='assign'){assigned.push(left.tree[1])
 left=left.tree[0]}
 if(assigned.length > 0){assigned.push(left)
 var ctx=node.C
 ctx.tree=[]
 var nleft=new $RawJSCtx(ctx,'var $temp'+$loop_num)
 nleft.tree=ctx.tree
 var nassign=new $AssignCtx(nleft)
 nassign.tree[1]=right
 assigned.forEach(function(elt){if(elt.type=="expr" && elt.tree[0].type=="list_or_tuple" &&
 elt.tree[0].real=="tuple" &&
 elt.tree[0].tree.length==1){
 elt=elt.tree[0].tree[0]}
 var new_node=new $Node(),node_ctx=new $NodeCtx(new_node)
 new_node.locals=node.locals
 new_node.line_num=node.line_num
 node.parent.insert(rank+1,new_node)
 elt.parent=node_ctx
 var assign=new $AssignCtx(elt)
 new $RawJSCtx(assign,'$temp'+$loop_num)})
 $loop_num++
 this.tree[0]=left
 return}
 var left_items=null
 switch(left.type){case 'expr':
 if(left.tree.length > 1){left_items=left.tree}else if(left.tree[0].type=='list_or_tuple' ||
 left.tree[0].type=='target_list'){left_items=left.tree[0].tree}else if(left.tree[0].type=='id'){
 var name=left.tree[0].value
 if(scope.globals && scope.globals.has(name)){}else{left.tree[0].bound=true}}
 break
 case 'target_list':
 case 'list_or_tuple':
 left_items=left.tree}
 var right=this.tree[1]
 if(left_items===null){if(left.tree[0].bound){if(right.type=="expr" && right.name=="int"){node.bindings=node.bindings ||{}
 node.bindings[left.tree[0].value]="int"}}
 return}
 var right_items=null
 if(right.type=='list' ||right.type=='tuple'||
 (right.type=='expr' && right.tree.length > 1)){right_items=right.tree}
 if(right_items !==null){
 if(right_items.length > left_items.length){throw Error('ValueError : too many values to unpack (expected '+
 left_items.length+')')}else if(right_items.length < left_items.length){throw Error('ValueError : need more than '+
 right_items.length+' to unpack')}
 var new_nodes=[],pos=0
 var new_node=new $Node()
 new_node.line_num=node.line_num
 new $NodeJSCtx(new_node,'void(0)')
 new_nodes[pos++]=new_node
 var $var='$temp'+$loop_num
 var new_node=new $Node()
 new_node.line_num=node.line_num
 new $NodeJSCtx(new_node,'var '+$var+' = [], $pos = 0')
 new_nodes[pos++]=new_node
 right_items.forEach(function(right_item){var js=$var+'[$pos++] = '+right_item.to_js()
 var new_node=new $Node()
 new_node.line_num=node.line_num
 new $NodeJSCtx(new_node,js)
 new_nodes[pos++]=new_node})
 var this_node=$get_node(this)
 left_items.forEach(function(left_item){var new_node=new $Node()
 new_node.id=this_node.module
 new_node.locals=this_node.locals
 new_node.line_num=node.line_num
 var C=new $NodeCtx(new_node)
 left_item.parent=C
 var assign=new $AssignCtx(left_item,false)
 assign.tree[1]=new $JSCode($var+'['+i+']')
 new_nodes[pos++]=new_node},this)
 node.parent.children.splice(rank,1)
 for(var i=new_nodes.length-1;i >=0;i--){node.parent.insert(rank,new_nodes[i])}
 $loop_num++}else{
 node.parent.children.splice(rank,1)
 var rname=create_temp_name('$right')
 var rlname=create_temp_name('$rlist');
 var new_node=$NodeJS('var '+rname+' = '+
 '$B.$getattr($B.$iter('+right.to_js()+
 '), "__next__");')
 new_node.line_num=node.line_num 
 node.parent.insert(rank++,new_node)
 node.parent.insert(rank++,$NodeJS('var '+rlname+'=[], $pos=0;'+
 'while(1){'+
 'try{'+
 rlname+'[$pos++] = '+rname+'()'+
 '}catch(err){'+
 'break'+
 '}'+
 '}')
 )
 var packed=null
 var min_length=left_items.length
 for(var i=0;i < left_items.length;i++){var expr=left_items[i]
 if(expr.type=='packed' ||
 (expr.type=='expr' && expr.tree[0].type=='packed')){packed=i
 min_length--
 break}}
 node.parent.insert(rank++,$NodeJS('if('+rlname+'.length<'+min_length+'){'+
 'throw _b_.ValueError.$factory('+
 '"need more than " +'+rlname+
 '.length + " value" + ('+rlname+
 '.length > 1 ?'+' "s" : "") + " to unpack")}'
 )
 )
 if(packed==null){node.parent.insert(rank++,$NodeJS('if('+rlname+'.length>'+min_length+'){'+
 'throw _b_.ValueError.$factory('+
 '"too many values to unpack '+
 '(expected '+left_items.length+')"'+
 ')'+
 '}')
 )}
 left_items.forEach(function(left_item,i){var new_node=new $Node()
 new_node.id=scope.id
 new_node.line_num=node.line_num
 node.parent.insert(rank++,new_node)
 var C=new $NodeCtx(new_node)
 left_item.parent=C
 var assign=new $AssignCtx(left_item,false)
 var js=rlname
 if(packed==null ||i < packed){js+='['+i+']'}else if(i==packed){js+='.slice('+i+','+rlname+'.length-'+
 (left_items.length-i-1)+')'}else{js+='['+rlname+'.length-'+(left_items.length-i)+']'}
 assign.tree[1]=new $JSCode(js)})
 $loop_num++}}
 $AssignCtx.prototype.to_js=function(){this.js_processed=true
 if(this.parent.type=='call'){
 return '{$nat:"kw",name:'+this.tree[0].to_js()+
 ',value:'+this.tree[1].to_js()+'}'}
 var left=this.tree[0]
 while(left.type=='expr' && ! left.assign){left=left.tree[0]}
 var right=this.tree[1]
 if(left.type=='attribute' ||left.type=='sub'){
 var right_js=right.to_js()
 var res='',rvar='',$var='$temp'+$loop_num
 if(right.type=='expr' && right.tree[0]!==undefined &&
 right.tree[0].type=='call' &&
 ('eval'==right.tree[0].func.value ||
 'exec'==right.tree[0].func.value)){res+='var '+$var+' = '+right_js+';\n'
 rvar=$var}else if(right.type=='expr' && right.tree[0]!==undefined &&
 right.tree[0].type=='sub'){res+='var '+$var+' = '+right_js+';\n'
 rvar=$var}else{rvar=right_js}
 if(left.type=='attribute'){
 $loop_num++
 left.func='setattr'
 var left_to_js=left.to_js()
 left.func='getattr'
 if(left.assign_self){return res+left_to_js[0]+rvar+left_to_js[1]+rvar+')'}
 res+=left_to_js
 res=res.substr(0,res.length-1)
 return res+','+rvar+');_b_.None;'}
 if(left.type=='sub'){
 var seq=left.value.to_js(),temp='$temp'+$loop_num,type
 if(left.value.type=='id'){type=$get_node(this).locals[left.value.value]}
 $loop_num++
 var res='var '+temp+' = '+seq+'\n'
 if(type !=='list'){res+='if(Array.isArray('+temp+') && !'+
 temp+'.__class__){'}
 if(left.tree.length==1){res+='$B.set_list_key('+temp+','+
 (left.tree[0].to_js()+'' ||'null')+','+
 right.to_js()+')'}else if(left.tree.length==2){res+='$B.set_list_slice('+temp+','+
 (left.tree[0].to_js()+'' ||'null')+','+
 (left.tree[1].to_js()+'' ||'null')+','+
 right.to_js()+')'}else if(left.tree.length==3){res+='$B.set_list_slice_step('+temp+','+
 (left.tree[0].to_js()+'' ||'null')+','+
 (left.tree[1].to_js()+'' ||'null')+','+
 (left.tree[2].to_js()+'' ||'null')+','+
 right.to_js()+')'}
 if(type=='list'){return res}
 res+='\n}else{'
 if(left.tree.length==1){res+='$B.$setitem('+left.value.to_js()+
 ','+left.tree[0].to_js()+','+right_js+')};_b_.None;'}else{left.func='setitem' 
 res+=left.to_js()
 res=res.substr(0,res.length-1)
 left.func='getitem' 
 res+=','+right_js+')};_b_.None;'}
 return res}}
 return left.to_js()+' = '+right.to_js()}
 var $AsyncCtx=$B.parser.$AsyncCtx=function(C){
 this.type='async'
 this.parent=C
 C.async=true}
 $AsyncCtx.prototype.toString=function(){return '(async)'}
 $AsyncCtx.prototype.transition=function(token,value){var C=this
 if(token=="def"){return $transition(C.parent,token,value)}else if(token=="for" ||token=="with"){var ntype=$get_scope(C).ntype
 if(ntype !=="def" && ntype !="generator"){$_SyntaxError(C,["'async "+token+
 "' outside async function"])}
 var ctx=$transition(C.parent,token,value)
 ctx.parent.async=true 
 return ctx}
 $_SyntaxError(C,'token '+token+' after '+C)}
 var $AttrCtx=$B.parser.$AttrCtx=function(C){
 this.type='attribute'
 this.value=C.tree[0]
 this.parent=C
 C.tree.pop()
 C.tree[C.tree.length]=this
 this.tree=[]
 this.func='getattr' }
 $AttrCtx.prototype.toString=function(){return '(attr) '+this.value+'.'+this.name}
 $AttrCtx.prototype.transition=function(token,value){var C=this
 if(token==='id'){var name=value
 if(noassign[name]===true){$_SyntaxError(C,["cannot assign to "+name])}
 name=$mangle(name,C)
 C.name=name
 return C.parent}
 $_SyntaxError(C,token)}
 $AttrCtx.prototype.to_js=function(){this.js_processed=true
 var js=this.value.to_js()
 if(this.func=="setattr" && this.value.type=="id"){var scope=$get_scope(this),parent=scope.parent
 if(scope.ntype=="def"){if(parent.ntype=="class"){var params=scope.C.tree[0].positional_list
 if(this.value.value==params[0]&& parent.C &&
 parent.C.tree[0].args===undefined){
 this.assign_self=true
 return[js+".__class__ && "+js+".__dict__ && !"+
 js+".__class__.$has_setattr && ! "+js+
 ".$is_class ? _b_.dict.$setitem("+js+
 ".__dict__, '"+this.name+
 "', ",") : $B.$setattr("+js+
 ', "'+this.name+'", ']}}}}
 if(this.func=='setattr'){
 return '$B.$setattr('+js+',"'+this.name+'")'}else{return '$B.$getattr('+js+',"'+this.name+'")'}}
 var $AugmentedAssignCtx=$B.parser.$AugmentedAssignCtx=function(C,op){
 check_assignment(C)
 this.type='augm_assign'
 this.C=C
 this.parent=C.parent
 C.parent.tree.pop()
 C.parent.tree[C.parent.tree.length]=this
 this.op=op
 this.tree=[C]
 var scope=this.scope=$get_scope(this)
 if(C.type=='expr'){var assigned=C.tree[0]
 if(assigned.type=='id'){var name=assigned.value
 if(noassign[name]===true){$_SyntaxError(C,["cannot assign to keyword"])}else if((scope.ntype=='def' ||scope.ntype=='generator')&&
 (scope.binding[name]===undefined)){if(scope.globals===undefined ||
 ! scope.globals.has(name)){
 assigned.unbound=true}}}else if(['str','int','float','complex'].indexOf(assigned.type)>-1){$_SyntaxError(C,["cannot assign to literal"])}}
 $get_node(this).bound_before=Object.keys(scope.binding)
 this.module=scope.module}
 $AugmentedAssignCtx.prototype.toString=function(){return '(augm assign) '+this.tree}
 $AugmentedAssignCtx.prototype.transition=function(token,value){var C=this
 if(token=='eol'){if(C.tree[1].type=='abstract_expr'){$_SyntaxError(C,'token '+token+' after '+
 C)}
 return $transition(C.parent,'eol')}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $AugmentedAssignCtx.prototype.transform=function(node,rank){var C=this.C,op=this.op,func='__'+$operators[op]+'__',offset=0,parent=node.parent,line_num=node.line_num,lnum_set=false
 parent.children.splice(rank,1)
 var left_is_id=(this.tree[0].type=='expr' &&
 this.tree[0].tree[0].type=='id')
 if(left_is_id){var left_bound_to_int=
 this.tree[0].tree[0].bindingType(this.scope)=="int"
 this.tree[0].tree[0].augm_assign=true
 if($B.debug > 0){var check_node=$NodeJS('if('+this.tree[0].to_js()+
 ' === undefined){throw _b_.NameError.$factory("name \'' +
                 this.tree[0].tree[0].value + '\' is not defined")}')
 node.parent.insert(rank,check_node)
 offset++}
 var left_id=this.tree[0].tree[0].value,was_bound=this.scope.binding[left_id]!==undefined,left_id_unbound=this.tree[0].tree[0].unbound}
 var right_is_int=(this.tree[1].type=='expr' &&
 this.tree[1].tree[0].type=='int')
 if(right_is_int){var value=this.tree[1].tree[0].value,to_int=parseInt(value[1],value[0])
 right_is_int=(to_int > $B.min_int)&&(to_int < $B.max_int)}
 var right=right_is_int ? this.tree[1].tree[0].to_js():'$temp'
 if(!right_is_int){
 var new_node=new $Node()
 new_node.line_num=line_num
 lnum_set=true
 new $NodeJSCtx(new_node,'var $temp,$left;')
 parent.insert(rank,new_node)
 offset++
 var new_node=new $Node()
 new_node.id=this.scope.id
 var new_ctx=new $NodeCtx(new_node)
 var new_expr=new $ExprCtx(new_ctx,'js',false)
 var _id=new $RawJSCtx(new_expr,'$temp')
 var assign=new $AssignCtx(new_expr)
 assign.tree[1]=this.tree[1]
 _id.parent=assign
 parent.insert(rank+offset,new_node)
 offset++}
 var prefix='',in_class=false
 switch(op){case '+=':
 case '-=':
 case '*=':
 case '/=':
 if(left_is_id){var scope=this.scope,global_ns='$local_'+scope.module.replace(/\./g,'_')
 switch(scope.ntype){case 'module':
 prefix=global_ns
 break
 case 'def':
 case 'generator':
 if(scope.globals &&
 scope.globals.has(C.tree[0].value)){prefix=global_ns}else{prefix='$locals'}
 break
 case 'class':
 var new_node=new $Node()
 if(!lnum_set){new_node.line_num=line_num
 lnum_set=true}
 new $NodeJSCtx(new_node,'var $left = '+
 C.to_js())
 parent.insert(rank+offset,new_node)
 in_class=true
 offset++}}}
 var left=C.tree[0].to_js()
 if(C.tree[0].type=="id"){var binding_scope=C.tree[0].firstBindingScopeId(),left_value=C.tree[0].value
 if(binding_scope){left="$locals_"+binding_scope.replace(/\./g,'_')+
 '["'+left_value+'"]'}else{left='$locals["'+left_value+'"]'}}
 if(left_bound_to_int && right_is_int &&
 op !="//="){
 parent.insert(rank+offset,$NodeJS(left+" "+op+" "+right))
 return offset++}
 prefix=prefix && !C.tree[0].unknown_binding && !left_id_unbound
 var op1=op.charAt(0)
 if(prefix){var left1=in_class ? '$left' :left
 var new_node=new $Node()
 if(!lnum_set){new_node.line_num=line_num;lnum_set=true}
 js=right_is_int ? 'if(' :'if(typeof $temp.valueOf() == "number" && '
 js+=left1+'.constructor === Number'
 js+=' && Number.isSafeInteger('+left+op1+right+')){'+
 (right_is_int ? '(' :'(typeof $temp == "number" && ')+
 'typeof '+left1+' == "number") ? '
 js+=left+op+right
 js+=' : '+left+' = new Number('+left+op1+
 (right_is_int ? right :right+'.valueOf()')+')}'
 new $NodeJSCtx(new_node,js)
 parent.insert(rank+offset,new_node)
 offset++}
 var aaops={'+=':'add','-=':'sub','*=':'mul'}
 if(C.tree[0].type=='sub' &&
 ('+='==op ||'-='==op ||'*='==op)&&
 C.tree[0].tree.length==1){var js1='$B.augm_item_'+aaops[op]+'('+
 C.tree[0].value.to_js()+','+
 C.tree[0].tree[0].to_js()+','+right+');_b_.None;'
 var new_node=new $Node()
 if(!lnum_set){new_node.line_num=line_num;lnum_set=true}
 new $NodeJSCtx(new_node,js1)
 parent.insert(rank+offset,new_node)
 offset++
 return}
 var new_node=new $Node()
 if(!lnum_set){new_node.line_num=line_num;lnum_set=true}
 var js=''
 if(prefix){js+='else '}
 js+='if(! _b_.hasattr('+C.to_js()+',"'+func+'"))'
 new $NodeJSCtx(new_node,js)
 parent.insert(rank+offset,new_node)
 offset++
 var aa1=new $Node()
 aa1.id=this.scope.id
 aa1.line_num=node.line_num
 new_node.add(aa1)
 var ctx1=new $NodeCtx(aa1)
 var expr1=new $ExprCtx(ctx1,'clone',false)
 if(left_id_unbound){new $RawJSCtx(expr1,left)}else{expr1.tree=C.tree
 expr1.tree.forEach(function(elt){elt.parent=expr1})}
 var assign1=new $AssignCtx(expr1)
 var new_op=new $OpCtx(expr1,op.substr(0,op.length-1))
 new_op.parent=assign1
 new $RawJSCtx(new_op,right)
 assign1.tree.push(new_op)
 expr1.parent.tree.pop()
 expr1.parent.tree.push(assign1)
 var else_node=$NodeJS("else")
 parent.insert(rank+offset,else_node)
 var aa2=new $Node()
 aa2.line_num=node.line_num
 else_node.add(aa2)
 var ctx2=new $NodeCtx(aa2)
 var expr2=new $ExprCtx(ctx2,'clone',false)
 if(left_id_unbound){var js=left
 if(! binding_scope){js='$B.$local_search("'+left_value+'");'+left}
 new $RawJSCtx(expr2,js)}else{expr2.tree=C.tree
 expr2.tree.forEach(function(elt){elt.parent=expr2})}
 var assign2=new $AssignCtx(expr2)
 assign2.tree.push($NodeJS('$B.$getattr('+C.to_js()+',"'+
 func+'")('+right+')'))
 expr2.parent.tree.pop()
 expr2.parent.tree.push(assign2)
 if(left_is_id && !was_bound && !this.scope.blurred){this.scope.binding[left_id]=undefined}
 return offset}
 $AugmentedAssignCtx.prototype.to_js=function(){return ''}
 var $AwaitCtx=$B.parser.$AwaitCtx=function(C){
 this.type='await'
 this.parent=C
 this.tree=[]
 C.tree.push(this)
 var p=C
 while(p){if(p.type=="list_or_tuple"){p.is_await=true}
 p=p.parent}}
 $AwaitCtx.prototype.transition=function(token,value){var C=this
 C.parent.is_await=true
 return $transition(C.parent,token,value)}
 $AwaitCtx.prototype.to_js=function(){return 'var save_stack = $B.save_stack();'+
 'await ($B.promise('+$to_js(this.tree)+'));'+
 '$B.restore_stack(save_stack, $locals); '}
 var $BodyCtx=$B.parser.$BodyCtx=function(C){
 var ctx_node=C.parent
 while(ctx_node.type !=='node'){ctx_node=ctx_node.parent}
 var tree_node=ctx_node.node
 var body_node=new $Node()
 body_node.is_body_node=true
 body_node.line_num=tree_node.line_num
 tree_node.insert(0,body_node)
 return new $NodeCtx(body_node)}
 var set_loop_context=$B.parser.set_loop_context=function(C,kw){
 var ctx_node=C
 while(ctx_node.type !=='node'){ctx_node=ctx_node.parent}
 var tree_node=ctx_node.node
 var loop_node=tree_node.parent
 var break_flag=false
 while(1){if(loop_node.type=='module'){
 $_SyntaxError(C,kw+' outside of a loop')}else{var ctx=loop_node.C.tree[0]
 if(ctx.type=='condition' && ctx.token=='while'){this.loop_ctx=ctx
 ctx['has_'+kw]=true
 break}
 switch(ctx.type){case 'for':
 this.loop_ctx=ctx
 ctx['has_'+kw]=true
 break_flag=true
 break
 case 'def':
 case 'generator':
 case 'class':
 $_SyntaxError(C,kw+' outside of a loop')
 default:
 loop_node=loop_node.parent}
 if(break_flag){break}}}}
 var $BreakCtx=$B.parser.$BreakCtx=function(C){
 this.type='break'
 this.parent=C
 C.tree[C.tree.length]=this
 set_loop_context.apply(this,[C,'break'])}
 $BreakCtx.prototype.toString=function(){return 'break '}
 $BreakCtx.prototype.transition=function(token,value){var C=this
 if(token=='eol'){return $transition(C.parent,'eol')}
 $_SyntaxError(C,token)}
 $BreakCtx.prototype.to_js=function(){this.js_processed=true
 var scope=$get_scope(this)
 var res=';$locals_'+scope.id.replace(/\./g,'_')+
 '["$no_break'+this.loop_ctx.loop_num+'"] = false'
 if(this.loop_ctx.type !='asyncfor'){res+=';break'}else{res+=';throw _b_.StopIteration.$factory('+
 this.loop_ctx.loop_num+')'}
 return res}
 var $CallArgCtx=$B.parser.$CallArgCtx=function(C){
 this.type='call_arg'
 this.parent=C
 this.start=$pos
 this.tree=[]
 C.tree.push(this)
 this.expect='id'}
 $CallArgCtx.prototype.toString=function(){return 'call_arg '+this.tree}
 $CallArgCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'await':
 case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 if(C.expect=='id'){C.expect=','
 var expr=new $AbstractExprCtx(C,false)
 return $transition(expr,token,value)}
 break
 case '=':
 if(C.expect==','){return new $ExprCtx(new $KwArgCtx(C),'kw_value',false)}
 break
 case 'for':
 if(this.parent.tree.length > 1){$_SyntaxError(C,"non-parenthesized generator expression")}
 var lst=new $ListOrTupleCtx(C,'gen_expr')
 lst.vars=C.vars 
 lst.locals=C.locals
 lst.intervals=[C.start]
 C.tree.pop()
 lst.expression=C.tree
 C.tree=[lst]
 lst.tree=[]
 var comp=new $ComprehensionCtx(lst)
 return new $TargetListCtx(new $CompForCtx(comp))
 case 'op':
 if(C.expect=='id'){var op=value
 C.expect=','
 switch(op){case '+':
 case '-':
 case '~':
 return $transition(new $AbstractExprCtx(C,false),token,op)
 case '*':
 return new $StarArgCtx(C)
 case '**':
 return new $DoubleStarArgCtx(C)}}
 $_SyntaxError(C,'token '+token+' after '+C)
 case ')':
 if(C.parent.kwargs &&
 $B.last(C.parent.tree).tree[0]&& 
 ['kwarg','star_arg','double_star_arg'].
 indexOf($B.last(C.parent.tree).tree[0].type)==-1){$_SyntaxError(C,['non-keyword argument after keyword argument'])}
 if(C.tree.length > 0){var son=C.tree[C.tree.length-1]
 if(son.type=='list_or_tuple' &&
 son.real=='gen_expr'){son.intervals.push($pos)}}
 return $transition(C.parent,token)
 case ':':
 if(C.expect==',' &&
 C.parent.parent.type=='lambda'){return $transition(C.parent.parent,token)}
 break
 case ',':
 if(C.expect==','){if(C.parent.kwargs &&
 ['kwarg','star_arg','double_star_arg'].
 indexOf($B.last(C.parent.tree).tree[0].type)==-1){$_SyntaxError(C,['non-keyword argument after keyword argument'])}
 return $transition(C.parent,token,value)}}
 console.log('token ',token,' after ' ,C)
 $_SyntaxError(C,'token '+token+' after '+C)}
 $CallArgCtx.prototype.to_js=function(){this.js_processed=true
 return $to_js(this.tree)}
 var $CallCtx=$B.parser.$CallCtx=function(C){
 this.type='call'
 this.func=C.tree[0]
 if(this.func !==undefined){
 this.func.parent=this}
 this.parent=C
 if(C.type !='class'){C.tree.pop()
 C.tree[C.tree.length]=this}else{
 C.args=this}
 this.expect='id'
 this.tree=[]
 this.start=$pos
 if(this.func && this.func.type=="attribute" && this.func.name=="wait"
 && this.func.value.type=="id" && this.func.value.value=="time"){console.log('call',this.func)
 $get_node(this).blocking={'type':'wait','call':this}}
 if(this.func && this.func.value=='input'){$get_node(this).blocking={'type':'input'}}}
 $CallCtx.prototype.toString=function(){return '(call) '+this.func+'('+this.tree+')'}
 $CallCtx.prototype.transition=function(token,value){var C=this
 switch(token){case ',':
 if(C.expect=='id'){$_SyntaxError(C,token)}
 C.expect='id'
 return C
 case 'await':
 case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 C.expect=','
 return $transition(new $CallArgCtx(C),token,value)
 case ')':
 C.end=$pos
 return C.parent
 case 'op':
 C.expect=','
 switch(value){case '-':
 case '~':
 case '+':
 C.expect=','
 return $transition(new $CallArgCtx(C),token,value)
 case '*':
 C.has_star=true
 return new $StarArgCtx(C)
 case '**':
 C.has_dstar=true
 return new $DoubleStarArgCtx(C)}
 $_SyntaxError(C,token)
 case 'yield':
 $_SyntaxError(C,token)}
 return $transition(C.parent,token,value)}
 $CallCtx.prototype.to_js=function(){this.js_processed=true
 if(this.tree.length > 0){if(this.tree[this.tree.length-1].tree.length==0){
 this.tree.pop()}}
 var func_js=this.func.to_js()
 if(this.func !==undefined){switch(this.func.value){case 'classmethod':
 return '_b_.classmethod.$factory('+$to_js(this.tree)+')'
 default:
 if(this.func.type=='unary'){
 var res='$B.$getattr('+$to_js(this.tree)
 switch(this.func.op){case '+':
 return res+',"__pos__")()'
 case '-':
 return res+',"__neg__")()'
 case '~':
 return res+',"__invert__")()'}}}
 var _block=false
 var positional=[],kw_args=[],star_args=false,dstar_args=[]
 this.tree.forEach(function(arg){var type
 switch(arg.type){case 'star_arg':
 star_args=true
 positional.push([arg.tree[0].tree[0].to_js(),'*'])
 break
 case 'double_star_arg':
 dstar_args.push(arg.tree[0].tree[0].to_js())
 break
 case 'id':
 positional.push([arg.to_js(),'s'])
 break
 default:
 type=arg.tree[0].type
 switch(type){case 'expr':
 positional.push([arg.to_js(),'s'])
 break
 case 'kwarg':
 kw_args.push(arg.tree[0].tree[0].value+
 ':'+arg.tree[0].tree[1].to_js())
 break
 case 'list_or_tuple':
 case 'op':
 positional.push([arg.to_js(),'s'])
 break
 case 'star_arg':
 star_args=true
 positional.push([arg.tree[0].tree[0].to_js(),'*'])
 break
 case 'double_star_arg':
 dstar_args.push(arg.tree[0].tree[0].to_js())
 break
 default:
 positional.push([arg.to_js(),'s'])
 break}
 break}})
 var args_str
 if(star_args){
 var p=[]
 for(var i=0,len=positional.length;i < len;i++){arg=positional[i]
 if(arg[1]=='*'){
 p.push('_b_.list.$factory('+arg[0]+')')}else{var elt=[positional[i][0]]
 i++
 while(i < len && positional[i][1]=='s'){elt.push(positional[i][0])
 i++}
 i--
 p.push('['+elt.join(',')+']')}}
 args_str=p[0]
 for(var i=1;i < p.length;i++){args_str+='.concat('+p[i]+')'}}else{for(var i=0,len=positional.length;i < len;i++){positional[i]=positional[i][0]}
 args_str=positional.join(', ')}
 var kw_args_str='{'+kw_args.join(', ')+'}'
 if(dstar_args.length){kw_args_str='{$nat:"kw",kw:['+kw_args_str+','+
 dstar_args.join(', ')+']}'}else if(kw_args_str !='{}'){kw_args_str='{$nat:"kw",kw:'+kw_args_str+'}'}else{kw_args_str=''}
 if(star_args && kw_args_str){args_str+='.concat(['+kw_args_str+'])'}else{if(args_str && kw_args_str){args_str+=','+kw_args_str}
 else if(!args_str){args_str=kw_args_str}}
 if(star_args){
 args_str='.apply(null,'+args_str+')'}else{args_str='('+args_str+')'}
 var default_res="$B.$call("+func_js+")"+args_str
 if(this.tree.length >-1 && this.func.type=='id' &&
 this.func.is_builtin){
 var classes=["complex","bytes","bytearray","object","memoryview","int","float","str","list","tuple","dict","set","frozenset","range","slice","zip","bool","type","classmethod","staticmethod","enumerate","reversed","property","$$super","zip","map","filter"]
 if($B.builtin_funcs[this.func.value]!==undefined){if(classes.indexOf(this.func.value)==-1){
 return func_js+args_str}else{
 return func_js+".$factory"+args_str}}}
 return default_res}}
 var $ClassCtx=$B.parser.$ClassCtx=function(C){
 this.type='class'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 this.expect='id'
 var scope=this.scope=$get_scope(this)
 this.parent.node.parent_block=scope
 this.parent.node.bound={}
 this.parent.node.binding={__annotations__:true}}
 $ClassCtx.prototype.toString=function(){return '(class) '+this.name+' '+this.tree+' args '+this.args}
 $ClassCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.expect=='id'){C.set_name(value)
 C.expect='(:'
 return C}
 break
 case '(':
 return new $CallCtx(C)
 case ':':
 return $BodyCtx(C)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $ClassCtx.prototype.set_name=function(name){var C=this.parent
 this.random=$B.UUID()
 this.name=name
 this.id=C.node.module+'_'+name+'_'+this.random
 this.binding={}
 this.parent.node.id=this.id
 var scope=this.scope,parent_block=scope
 var block=scope,parent_classes=[]
 while(block.ntype=="class"){parent_classes.splice(0,0,block.C.tree[0].name)
 block=block.parent}
 this.qualname=parent_classes.concat([name]).join(".")
 while(parent_block.C &&
 parent_block.C.tree[0].type=='class'){parent_block=parent_block.parent}
 while(parent_block.C &&
 'def' !=parent_block.C.tree[0].type &&
 'generator' !=parent_block.C.tree[0].type){parent_block=parent_block.parent}
 this.parent.node.parent_block=parent_block
 $bind(name,scope,this)
 if(scope.is_function){if(scope.C.tree[0].locals.indexOf(name)==-1){scope.C.tree[0].locals.push(name)}}}
 $ClassCtx.prototype.transform=function(node,rank){
 this.doc_string=$get_docstring(node)
 this.module=$get_module(this).module.replace(/\./g,'_')
 var indent='\n'+' '.repeat(node.indent+12),instance_decl=new $Node(),local_ns='$locals_'+this.id.replace(/\./g,'_'),js='var '+local_ns+' = {'+
 '__annotations__: $B.empty_dict()}, '+
 indent+'$locals = '+local_ns
 new $NodeJSCtx(instance_decl,js)
 node.insert(0,instance_decl)
 var global_scope=this.scope
 while(global_scope.parent_block.id !=='__builtins__'){global_scope=global_scope.parent_block}
 var global_ns='$locals_'+global_scope.id.replace(/\./g,'_')
 var js=' '.repeat(node.indent+4)+
 '$locals.$name = "'+this.name+'"'+indent+
 '$locals.$qualname = "'+this.qualname+'"'+indent+
 '$locals.$is_class = true; '+indent+
 '$locals.$line_info = "'+node.line_num+','+
 this.module+'";'+indent+
 'var $top_frame = ["'+local_ns+'", $locals,'+'"'+
 global_scope.id+'", '+global_ns+']'+
 indent+'$locals.$f_trace = $B.enter_frame($top_frame);'+
 indent+'if($locals.$f_trace !== _b_.None){'+
 '$locals.$f_trace = $B.trace_line()}'
 node.insert(1,$NodeJS(js))
 node.add($NodeJS('if($locals.$f_trace !== _b_.None){'+
 '$B.trace_return(_b_.None)}'))
 node.add($NodeJS('$B.leave_frame({$locals})'))
 var ret_obj=new $Node()
 new $NodeJSCtx(ret_obj,'return '+local_ns+';')
 node.insert(node.children.length,ret_obj)
 var run_func=new $Node()
 new $NodeJSCtx(run_func,')();')
 node.parent.insert(rank+1,run_func)
 var module_name='$locals_'+this.module+'.__name__'
 rank++
 node.parent.insert(rank+1,$NodeJS('$'+this.name+'_'+this.random+".__module__ = "+
 module_name))
 var scope=$get_scope(this)
 var name_ref=';$locals_'+scope.id.replace(/\./g,'_')
 name_ref+='["'+this.name+'"]'
 var js=[name_ref+' = $B.$class_constructor("'+this.name],pos=1
 js[pos++]='", $'+this.name+'_'+this.random
 if(this.args !==undefined){
 var arg_tree=this.args.tree,args=[],kw=[]
 arg_tree.forEach(function(_tmp){if(_tmp.tree[0].type=='kwarg'){kw.push(_tmp.tree[0])}
 else{args.push(_tmp.to_js())}})
 js[pos++]=', _b_.tuple.$factory(['+args.join(',')+']),['
 var _re=new RegExp('"','g'),_r=[],rpos=0
 args.forEach(function(arg){_r[rpos++]='"'+arg.replace(_re,'\\"')+'"'})
 js[pos++]=_r.join(',')+']'
 _r=[]
 rpos=0
 kw.forEach(function(_tmp){_r[rpos++]='["'+_tmp.tree[0].value+'",'+
 _tmp.tree[1].to_js()+']'})
 js[pos++]=',['+_r.join(',')+']'}else{
 js[pos++]=', _b_.tuple.$factory([]),[],[]'}
 js[pos++]=')'
 var cl_cons=new $Node()
 new $NodeJSCtx(cl_cons,js.join(''))
 rank++
 node.parent.insert(rank+1,cl_cons)
 rank++
 var ds_node=new $Node()
 js=name_ref+'.__doc__ = '+(this.doc_string ||'_b_.None')+';'
 new $NodeJSCtx(ds_node,js)
 node.parent.insert(rank+1,ds_node)
 if(scope.ntype=='module'){var w_decl=new $Node()
 new $NodeJSCtx(w_decl,'$locals["'+this.name+'"] = '+
 this.name)}
 node.parent.insert(rank+2,$NodeJS("_b_.None;"))
 this.transformed=true}
 $ClassCtx.prototype.to_js=function(){this.js_processed=true
 return 'var $'+this.name+'_'+this.random+' = (function()'}
 var $CompIfCtx=$B.parser.$CompIfCtx=function(C){
 this.type='comp_if'
 C.parent.intervals.push($pos)
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $CompIfCtx.prototype.toString=function(){return '(comp if) '+this.tree}
 $CompIfCtx.prototype.transition=function(token,value){var C=this
 return $transition(C.parent,token,value)}
 $CompIfCtx.prototype.to_js=function(){this.js_processed=true
 return $to_js(this.tree)}
 var $ComprehensionCtx=$B.parser.$ComprehensionCtx=function(C){
 this.type='comprehension'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $ComprehensionCtx.prototype.toString=function(){return '(comprehension) '+this.tree}
 $ComprehensionCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'if':
 return new $AbstractExprCtx(new $CompIfCtx(C),false)
 case 'for':
 return new $TargetListCtx(new $CompForCtx(C))}
 return $transition(C.parent,token,value)}
 $ComprehensionCtx.prototype.to_js=function(){this.js_processed=true
 var intervals=[]
 this.tree.forEach(function(elt){intervals.push(elt.start)})
 return intervals}
 var $CompForCtx=$B.parser.$CompForCtx=function(C){
 this.type='comp_for'
 C.parent.intervals.push($pos)
 this.parent=C
 this.tree=[]
 this.expect='in'
 C.tree[C.tree.length]=this}
 $CompForCtx.prototype.toString=function(){return '(comp for) '+this.tree}
 $CompForCtx.prototype.transition=function(token,value){var C=this
 if(token=='in' && C.expect=='in'){C.expect=null
 return new $AbstractExprCtx(new $CompIterableCtx(C),true)}
 if(C.expect===null){
 return $transition(C.parent,token,value)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $CompForCtx.prototype.to_js=function(){this.js_processed=true
 return $to_js(this.tree)}
 var $CompIterableCtx=$B.parser.$CompIterableCtx=function(C){
 this.type='comp_iterable'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $CompIterableCtx.prototype.toString=function(){return '(comp iter) '+this.tree}
 $CompIterableCtx.prototype.transition=function(token,value){var C=this
 return $transition(C.parent,token,value)}
 $CompIterableCtx.prototype.to_js=function(){this.js_processed=true
 return $to_js(this.tree)}
 var $ConditionCtx=$B.parser.$ConditionCtx=function(C,token){
 this.type='condition'
 this.token=token
 this.parent=C
 this.tree=[]
 this.scope=$get_scope(this)
 if(token=='while'){this.loop_num=$loop_num++}
 C.tree[C.tree.length]=this}
 $ConditionCtx.prototype.toString=function(){return this.token+' '+this.tree}
 $ConditionCtx.prototype.transition=function(token,value){var C=this
 if(token==':'){if(C.tree[0].type=="abstract_expr" &&
 C.tree[0].tree.length==0){
 $_SyntaxError(C,'token '+token+' after '+C)}
 return $BodyCtx(C)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $ConditionCtx.prototype.transform=function(node,rank){var scope=$get_scope(this)
 if(this.token=="while"){node.parent.insert(rank,$NodeJS('$locals["$no_break'+this.loop_num+'"] = true'))
 var module=$get_module(this).module
 if($B.last(node.children).C.tree[0].type !="return"){var js='$locals.$line_info = "'+node.line_num+
 ','+module+'";if($locals.$f_trace !== _b_.None){'+
 '$B.trace_line()};_b_.None;'
 node.add($NodeJS(js))}
 return 2}}
 $ConditionCtx.prototype.to_js=function(){this.js_processed=true
 var tok=this.token
 if(tok=='elif'){tok='else if'}
 var res=[tok+'($B.$bool(']
 if(tok=='while'){res.push('$locals["$no_break'+this.loop_num+'"] && ')}else if(tok=='else if'){var line_info=$get_node(this).line_num+','+
 $get_scope(this).id
 res.push('($B.set_line("'+line_info+'")) && ')}
 if(this.tree.length==1){res.push($to_js(this.tree)+'))')}else{
 res.push(this.tree[0].to_js()+'))')
 if(this.tree[1].tree.length > 0){res.push('{'+this.tree[1].to_js()+'}')}}
 return res.join('')}
 var $ContinueCtx=$B.parser.$ContinueCtx=function(C){
 this.type='continue'
 this.parent=C
 $get_node(this).is_continue=true
 C.tree[C.tree.length]=this
 set_loop_context.apply(this,[C,'continue'])}
 $ContinueCtx.prototype.toString=function(){return '(continue)'}
 $ContinueCtx.prototype.transition=function(token,value){var C=this
 if(token=='eol'){return C.parent}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $ContinueCtx.prototype.to_js=function(){this.js_processed=true
 var js='continue'
 if(this.loop_ctx.has_break){
 js=`$locals["$no_break${this.loop_ctx.loop_num}"]=true;${js}`}
 return js}
 var $DebuggerCtx=$B.parser.$DebuggerCtx=function(C){
 this.type='continue'
 this.parent=C
 C.tree[C.tree.length]=this}
 $DebuggerCtx.prototype.toString=function(){return '(debugger)'}
 $DebuggerCtx.prototype.transition=function(token,value){var C=this}
 $DebuggerCtx.prototype.to_js=function(){this.js_processed=true
 return 'debugger'}
 var $DecoratorCtx=$B.parser.$DecoratorCtx=function(C){
 this.type='decorator'
 this.parent=C
 C.tree[C.tree.length]=this
 this.tree=[]}
 $DecoratorCtx.prototype.toString=function(){return '(decorator) '+this.tree}
 $DecoratorCtx.prototype.transition=function(token,value){var C=this
 if(token=='id' && C.tree.length==0){return $transition(new $AbstractExprCtx(C,false),token,value)}
 if(token=='eol'){return $transition(C.parent,token)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $DecoratorCtx.prototype.transform=function(node,rank){var func_rank=rank+1,children=node.parent.children,decorators=[this.tree]
 while(1){if(func_rank >=children.length){$_SyntaxError(C,['decorator expects function'])}
 else if(children[func_rank].C.type=='node_js'){func_rank++}else if(children[func_rank].C.tree[0].type==
 'decorator'){decorators.push(children[func_rank].C.tree[0].tree)
 children.splice(func_rank,1)}else{break}}
 this.dec_ids=[]
 var pos=0
 decorators.forEach(function(){this.dec_ids.push('$id'+$B.UUID())},this)
 var obj=children[func_rank].C.tree[0]
 if(obj.type=='def'){obj.decorated=true
 obj.alias='$dec'+$B.UUID()}
 var tail='',scope=$get_scope(this),ref='$locals["'
 if(scope.globals && scope.globals.has(obj.name)){var module=$get_module(this)
 ref='$locals_'+module.id+'["'}
 ref+=obj.name+'"]'
 var res=ref+' = '
 decorators.forEach(function(elt,i){res+='$B.$call('+this.dec_ids[i]+')('
 tail+=')'},this)
 res+=(obj.decorated ? obj.alias :ref)+tail+';'
 $bind(obj.name,scope,this)
 node.parent.insert(func_rank+1,$NodeJS(res))
 this.decorators=decorators}
 $DecoratorCtx.prototype.to_js=function(){this.js_processed=true
 var res=[]
 this.decorators.forEach(function(decorator,i){res.push('var '+this.dec_ids[i]+' = '+
 $to_js(decorator)+';')},this)
 return res.join('')}
 var $DefCtx=$B.parser.$DefCtx=function(C){this.type='def'
 this.name=null
 this.parent=C
 this.tree=[]
 this.async=C.async
 this.locals=[]
 C.tree[C.tree.length]=this
 this.enclosing=[]
 var scope=this.scope=$get_scope(this)
 if(scope.C && scope.C.tree[0].type=="class"){this.class_name=scope.C.tree[0].name}
 C.node.binding={}
 var parent_block=scope
 while(parent_block.C &&
 parent_block.C.tree[0].type=='class'){parent_block=parent_block.parent}
 while(parent_block.C &&
 'def' !=parent_block.C.tree[0].type){parent_block=parent_block.parent}
 this.parent.node.parent_block=parent_block
 var pb=parent_block
 this.is_comp=pb.is_comp
 while(pb && pb.C){if(pb.C.tree[0].type=='def'){this.inside_function=true
 break}
 pb=pb.parent_block}
 this.module=scope.module
 this.root=$get_module(this)
 this.num=$loop_num
 $loop_num++
 this.positional_list=[]
 this.default_list=[]
 this.other_args=null
 this.other_kw=null
 this.after_star=[]}
 $DefCtx.prototype.set_name=function(name){try{name=$mangle(name,this.parent.tree[0])}catch(err){console.log(err)
 console.log('parent',this.parent)
 throw err}
 var id_ctx=new $IdCtx(this,name)
 this.name=name
 this.id=this.scope.id+'_'+name
 this.id=this.id.replace(/\./g,'_')
 this.id+='_'+$B.UUID()
 this.parent.node.id=this.id
 this.parent.node.module=this.module
 this.binding={}
 var scope=this.scope
 if(scope.globals !==undefined &&
 scope.globals.has(name)){
 $bind(name,this.root,this)}else{$bind(name,scope,this)}
 id_ctx.bound=true
 if(scope.is_function){if(scope.C.tree[0].locals.indexOf(name)==-1){scope.C.tree[0].locals.push(name)}}}
 $DefCtx.prototype.toString=function(){return 'def '+this.name+'('+this.tree+')'}
 $DefCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.name){$_SyntaxError(C,'token '+token+' after '+C)}
 C.set_name(value)
 return C
 case '(':
 if(C.name==null){$_SyntaxError(C,"missing name in function definition")}
 C.has_args=true;
 return new $FuncArgs(C)
 case 'annotation':
 return new $AbstractExprCtx(new $AnnotationCtx(C),true)
 case ':':
 if(C.has_args){return $BodyCtx(C)}else{$_SyntaxError(C,"missing function parameters")}
 case 'eol':
 if(C.has_args){$_SyntaxError(C,"missing colon")}}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $DefCtx.prototype.transform=function(node,rank){if(this.is_comp){$get_node(this).is_comp=true}
 if(this.transformed !==undefined){return}
 var scope=this.scope
 this.doc_string=$get_docstring(node)
 this.rank=rank 
 var indent=node.indent+12
 if(this.name.substr(0,15)=='lambda_'+$B.lambda_magic){var pblock=scope.parent_block
 if(pblock.C && pblock.C.tree[0].type=="def"){this.enclosing.push(pblock)}}
 var pnode=this.parent.node
 while(pnode.parent && pnode.parent.is_def_func){this.enclosing.push(pnode.parent.parent)
 pnode=pnode.parent.parent}
 var defaults=[],defs1=[],has_end_pos=false
 this.argcount=0
 this.kwonlyargcount=0 
 this.kwonlyargsdefaults=[]
 this.otherdefaults=[]
 this.varnames={}
 this.args=[]
 this.__defaults__=[]
 this.slots=[]
 var slot_list=[],slot_init=[],annotations=[]
 if(this.annotation){annotations.push('"return":'+this.annotation.to_js())}
 this.func_name=this.tree[0].to_js()
 var func_name1=this.func_name
 if(this.decorated){this.func_name='var '+this.alias
 func_name1=this.alias}
 var func_args=this.tree[1].tree
 func_args.forEach(function(arg){if(arg.type=='end_positional'){this.args.push("/")
 slot_list.push('"/"')
 has_end_pos=true}else{this.args.push(arg.name)
 this.varnames[arg.name]=true}
 if(arg.type=='func_arg_id'){if(this.star_arg){this.kwonlyargcount++
 if(arg.has_default){this.kwonlyargsdefaults.push(arg.name)}}
 else{this.argcount++
 if(arg.has_default){this.otherdefaults.push(arg.name)}}
 this.slots.push(arg.name+':null')
 slot_list.push('"'+arg.name+'"')
 slot_init.push(arg.name+':'+arg.name)
 if(arg.tree.length > 0){defaults.push('"'+arg.name+'"')
 defs1.push(arg.name+':'+$to_js(arg.tree))
 this.__defaults__.push($to_js(arg.tree))}}else if(arg.type=='func_star_arg'){if(arg.op=='*'){this.star_arg=arg.name}
 else if(arg.op=='**'){this.kw_arg=arg.name}}
 if(arg.annotation){var name=$mangle(arg.name,this)
 annotations.push(name+': '+arg.annotation.to_js())}},this)
 slot_init='{'+slot_init.join(", ")+'}'
 var flags=67
 if(this.star_arg){flags |=4}
 if(this.kw_arg){flags |=8}
 if(this.type=='generator'){flags |=32}
 if(this.async){flags |=128}
 var nodes=[],js
 var global_scope=scope
 while(global_scope.parent_block &&
 global_scope.parent_block.id !=='__builtins__'){global_scope=global_scope.parent_block}
 var global_ns='$locals_'+global_scope.id.replace(/\./g,'_')
 var name=this.name+this.num
 var local_ns='$locals_'+this.id,h='\n'+' '.repeat(indent)
 js='var '+local_ns+' = {},'+
 h+'$locals = '+local_ns+';'
 var new_node=new $Node()
 new_node.locals_def=true
 new_node.func_node=node
 new $NodeJSCtx(new_node,js)
 nodes.push(new_node)
 var enter_frame_nodes=[$NodeJS('$locals.$line_info = "'+node.line_num+','+
 this.module+'"'),$NodeJS(`var $top_frame=["${this.id}",$locals,`+
 '"'+global_scope.id+'", '+global_ns+', '+
 (this.is_comp ? this.name :name)+']'),$NodeJS('$locals.$f_trace = $B.enter_frame($top_frame)'),$NodeJS('var $stack_length = $B.frames_stack.length;')
 ]
 if(this.type=="generator"){enter_frame_nodes.push($NodeJS("$locals.$is_generator = true"))}
 if(this.async){enter_frame_nodes.splice(1,0,$NodeJS(`$locals.$async="${this.id}"`))}
 enter_frame_nodes.forEach(function(node){node.enter_frame=true})
 if(this.is_comp){nodes.push($NodeJS("var $defaults = {}"))}
 this.env=[]
 var make_args_nodes=[]
 var js=local_ns+' = $locals = $B.args("'+this.name+'", '+
 this.argcount+', {'+this.slots.join(', ')+'}, '+
 '['+slot_list.join(', ')+'], arguments, $defaults, '+
 this.other_args+', '+this.other_kw+');'
 var new_node=new $Node()
 new $NodeJSCtx(new_node,js)
 make_args_nodes.push(new_node)
 var only_positional=false
 if(this.other_args===null && this.other_kw===null &&
 this.after_star.length==0 && !has_end_pos){
 only_positional=true
 nodes.push($NodeJS('var $len = arguments.length;'))
 var new_node=new $Node()
 var js='if($len > 0 && arguments[$len - 1].$nat !== undefined)'
 new $NodeJSCtx(new_node,js)
 nodes.push(new_node)
 make_args_nodes.forEach(function(item){new_node.add(item)})
 var else_node=new $Node()
 new $NodeJSCtx(else_node,'else')
 nodes.push(else_node)
 var pos_len=this.slots.length
 var test_node=$NodeJS('if($len == '+pos_len+')')
 else_node.add(test_node)
 test_node.add($NodeJS(local_ns+' = $locals = '+slot_init))
 else_node.add($NodeJS('else if($len > '+pos_len+
 '){$B.wrong_nb_args("'+this.name+'", $len, '+
 pos_len+', ['+slot_list+'])}'))
 if(pos_len > 0){
 else_node.add($NodeJS('else if($len + Object.keys($defaults).length < '+
 pos_len+'){$B.wrong_nb_args("'+this.name+
 '", $len, '+pos_len+', ['+slot_list+'])}'))
 subelse_node=$NodeJS("else")
 else_node.add(subelse_node)
 subelse_node.add($NodeJS(local_ns+' = $locals = '+slot_init))
 subelse_node.add($NodeJS("var defparams = ["+slot_list+"]"))
 subelse_node.add($NodeJS("for(var i = $len; i < defparams.length"+
 "; i++){$locals[defparams[i]] = $defaults[defparams[i]]}"))}}else{nodes.push(make_args_nodes[0])
 if(make_args_nodes.length > 1){nodes.push(make_args_nodes[1])}}
 nodes=nodes.concat(enter_frame_nodes)
 var is_method=scope.ntype=="class"
 if(is_method){class_ref="$locals_"+scope.parent_block.id.replace(/\./g,'_')+
 '.'+scope.C.tree[0].qualname
 this.parent.node.binding["__class__"]=true
 nodes.push($NodeJS("$locals.__class__ = "+class_ref))}
 nodes.push($NodeJS('$B.js_this = this;'))
 for(var i=nodes.length-1;i >=0;i--){node.children.splice(0,0,nodes[i])}
 var def_func_node=new $Node()
 this.params=''
 if(only_positional){this.params=Object.keys(this.varnames).join(', ')}
 new $NodeJSCtx(def_func_node,'')
 def_func_node.is_def_func=true
 def_func_node.module=this.module
 var last_node=node.children[node.children.length-1],indent=last_node.indent,last_instr=last_node.C.tree[0]
 if(last_instr.type !='return'){
 js='if($locals.$f_trace !== _b_.None){\n'+
 '    '.repeat(indent)+'$B.trace_return(_b_.None)\n'+
 '    '.repeat(indent)+'}\n'+'    '.repeat(indent)
 js+='$B.leave_frame'
 if(this.id.substr(0,5)=='$exec'){js+='_exec'}
 js+='({$locals});return _b_.None'
 node.add($NodeJS(js))}
 var free_vars=[]
 if(this.parent.node.referenced){for(var attr in this.parent.node.referenced){if(! this.parent.node.binding[attr]){free_vars.push('"'+attr+'"')}}}
 node.add(def_func_node)
 var offset=1,indent=node.indent
 if(! this.is_comp){
 node.parent.insert(rank+offset++,$NodeJS(name+'.$is_func = true'))
 if(this.$has_yield_in_cm){node.parent.insert(rank+offset++,$NodeJS(name+'.$has_yield_in_cm = true'))}
 node.parent.insert(rank+offset++,$NodeJS(name+'.$infos = {'))
 var __name__=this.name
 if(this.name.substr(0,2)=="$$"){__name__=__name__.substr(2)}
 if(__name__.substr(0,15)=='lambda_'+$B.lambda_magic){__name__="<lambda>"}
 js='    __name__:"'+__name__+'",'
 node.parent.insert(rank+offset++,$NodeJS(js))
 var __qualname__=__name__
 if(this.class_name){__qualname__=this.class_name+'.'+__name__}
 js='    __qualname__:"'+__qualname__+'",'
 node.parent.insert(rank+offset++,$NodeJS(js))
 if(this.otherdefaults.length > 0){var def_names=[]
 this.otherdefaults.forEach(function(_default){def_names.push('$defaults.'+_default)})
 node.parent.insert(rank+offset++,$NodeJS('    __defaults__ : '+
 '$B.fast_tuple(['+def_names.join(', ')+']),'))}else{node.parent.insert(rank+offset++,$NodeJS('    __defaults__ : '+
 '_b_.None,'))}
 if(this.kwonlyargsdefaults.lengh > 0){var def_names=[]
 this.kwonlyargsdefaults.forEach(function(_default){def_names.push('$defaults.'+_default)})
 node.parent.insert(rank+offset++,$NodeJS('    __kwdefaults__ : '+
 '$B.fast_tuple(['+def_names.join(', ')+']),'))}else{node.parent.insert(rank+offset++,$NodeJS('    __kwdefaults__ : '+
 '_b_.None,'))}
 node.parent.insert(rank+offset++,$NodeJS('    __annotations__: {'+annotations.join(',')+'},'))
 node.parent.insert(rank+offset++,$NodeJS('    __dict__: $B.empty_dict(),'))
 node.parent.insert(rank+offset++,$NodeJS('    __doc__: '+(this.doc_string ||'_b_.None')+','))
 var root=$get_module(this)
 node.parent.insert(rank+offset++,$NodeJS('    __module__ : "'+root.module+'",'))
 for(var attr in this.binding){this.varnames[attr]=true}
 var co_varnames=[]
 for(var attr in this.varnames){co_varnames.push('"'+$B.from_alias(attr)+'"')}
 var CODE_MARKER='___%%%-CODE-%%%___'+this.name+this.num;
 var h='\n'+' '.repeat(indent+8)
 js='    __code__:{'+h+'    co_argcount:'+this.argcount
 var h1=','+h+' '.repeat(4)
 var module=$get_module(this).module
 js+=h1+'co_filename:$locals_'+module.replace(/\./g,'_')+
 '["__file__"] || "<string>"'+
 h1+'co_firstlineno:'+node.line_num+
 h1+'co_flags:'+flags+
 h1+'co_freevars: ['+free_vars+']'+
 h1+'co_kwonlyargcount:'+this.kwonlyargcount+
 h1+'co_name: "'+this.name+'"'+
 h1+'co_nlocals: '+co_varnames.length+
 h1+'co_posonlyargcount: '+(this.pos_only ||0)+
 h1+'co_varnames: $B.fast_tuple(['+co_varnames.join(', ')+'])'+
 h+'}\n'+' '.repeat(indent+4)+'};'
 js+='_b_.None;'
 node.parent.insert(rank+offset++,$NodeJS(js))}
 this.default_str='{'+defs1.join(', ')+'}'
 if(! this.is_comp){var name1=name
 if(this.type=="generator"){name1=`$B.generator.$factory(${name})`}
 var res='return '+name1
 if(this.async){if(this.type=="generator"){res=`return $B.async_generator.$factory(${name})`}else{res='return $B.make_async('+name1+')'}}
 node.parent.insert(rank+offset++,$NodeJS(res+'}'))
 node.parent.insert(rank+offset++,$NodeJS(
 this.func_name+" = "+this.name+'$'+this.num+
 '('+this.default_str+')'))
 node.parent.insert(rank+offset++,$NodeJS(
 func_name1+".$set_defaults = function(value){return "+
 func_name1+" = "+this.name+"$"+this.num+
 "(value)}"))
 if(this.$has_yield_in_cm){node.parent.insert(rank+offset++,$NodeJS(`${func_name1}.$has_yield_in_cm=true`))}}
 var parent=node
 for(var pos=0;pos < parent.children.length &&
 parent.children[pos]!==$B.last(enter_frame_nodes);pos++){}
 var try_node=$NodeJS('try'),children=parent.children.slice(pos+1)
 parent.insert(pos+1,try_node)
 children.forEach(function(child){if(child.is_def_func){child.children.forEach(function(grand_child){try_node.add(grand_child)})}else{try_node.add(child)}})
 parent.children.splice(pos+2,parent.children.length)
 var except_node=$NodeJS('catch(err)')
 except_node.add($NodeJS('$B.set_exc(err)'))
 except_node.add($NodeJS('if($locals.$f_trace !== _b_.None){'+
 '$locals.$f_trace = $B.trace_exception()}'))
 except_node.add($NodeJS('$B.leave_frame({$locals});throw err'))
 parent.add(except_node)
 this.transformed=true
 return offset}
 $DefCtx.prototype.to_js=function(func_name){this.js_processed=true
 if(this.is_comp){return "var "+this.name+" = "+
 (this.async ? ' async ' :'')+
 "function* (expr)"}
 func_name=func_name ||this.tree[0].to_js()
 if(this.decorated){func_name='var '+this.alias}
 return "var "+this.name+'$'+this.num+
 ' = function($defaults){'+
 (this.async ? 'async ' :'')+'function'+
 (this.type=='generator' ? "* " :" ")+
 this.name+this.num+'('+this.params+')'}
 var $DelCtx=$B.parser.$DelCtx=function(C){
 this.type='del'
 this.parent=C
 C.tree[C.tree.length]=this
 this.tree=[]}
 $DelCtx.prototype.toString=function(){return 'del '+this.tree}
 $DelCtx.prototype.transition=function(token,value){var C=this
 if(token=='eol'){return $transition(C.parent,token)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $DelCtx.prototype.to_js=function(){this.js_processed=true
 var C=this.parent
 if(this.tree[0].type=='list_or_tuple'){
 var res=[]
 this.tree[0].tree.forEach(function(elt){var subdel=new $DelCtx(C)
 subdel.tree=[elt]
 res.push(subdel.to_js())
 C.tree.pop()})
 this.tree=[]
 return res.join(';')}else if(this.tree[0].type=='expr' &&
 this.tree[0].tree[0].type=='list_or_tuple'){
 this.tree[0]=this.tree[0].tree[0]
 return this.to_js()}else{var expr=this.tree[0].tree[0]
 switch(expr.type){case 'id':
 var scope=$get_scope(this),is_global=false
 if((scope.ntype=="def" ||scope.ntype=="generator")&&
 scope.globals && scope.globals.has(expr.value)){
 scope=scope.parent
 while(scope.parent &&
 scope.parent.id !=="__builtins__"){scope=scope.parent}
 is_global=true}
 var res='$B.$delete("'+expr.value+'"'+
 (is_global ? ', "global"' :'')+');'
 delete scope.binding[expr.value]
 return res
 case 'list_or_tuple':
 var res=[]
 expr.tree.forEach(function(elt){res.push('delete '+elt.to_js())})
 return res.join(';')
 case 'sub':
 expr.func='delitem'
 js=expr.to_js()
 expr.func='getitem'
 return js
 case 'op':
 $_SyntaxError(this,["cannot delete operator"])
 case 'call':
 $_SyntaxError(this,["cannot delete function call"])
 case 'attribute':
 return '_b_.delattr('+expr.value.to_js()+',"'+
 expr.name+'")'
 default:
 $_SyntaxError(this,["cannot delete "+expr.type])}}}
 var $DictOrSetCtx=$B.parser.$DictOrSetCtx=function(C){
 this.type='dict_or_set'
 this.real='dict_or_set'
 this.expect='id'
 this.closed=false
 this.start=$pos
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $DictOrSetCtx.prototype.toString=function(){switch(this.real){case 'dict':
 return '(dict) {'+this.items+'}'
 case 'set':
 return '(set) {'+this.tree+'}'}
 return '(dict_or_set) {'+this.tree+'}'}
 $DictOrSetCtx.prototype.transition=function(token,value){var C=this
 if(C.closed){switch(token){case '[':
 return new $AbstractExprCtx(new $SubCtx(C.parent),false)
 case '(':
 return new $CallArgCtx(new $CallCtx(C.parent))}
 return $transition(C.parent,token,value)}else{if(C.expect==','){switch(token){case '}':
 switch(C.real){case 'dict_or_set':
 if(C.tree.length !=1){break}
 C.real='set' 
 case 'set':
 case 'set_comp':
 case 'dict_comp':
 C.items=C.tree
 C.tree=[]
 C.closed=true
 return C
 case 'dict':
 if(C.nb_dict_items()% 2==0){C.items=C.tree
 C.tree=[]
 C.closed=true
 return C}}
 $_SyntaxError(C,'token '+token+
 ' after '+C)
 case ',':
 if(C.real=='dict_or_set'){C.real='set'}
 if(C.real=='dict' &&
 C.nb_dict_items()% 2){$_SyntaxError(C,'token '+token+
 ' after '+C)}
 C.expect='id'
 return C
 case ':':
 if(C.real=='dict_or_set'){C.real='dict'}
 if(C.real=='dict'){C.expect=','
 return new $AbstractExprCtx(C,false)}else{$_SyntaxError(C,'token '+token+
 ' after '+C)}
 case 'for':
 if(C.real=='dict_or_set'){C.real='set_comp'}else{C.real='dict_comp'}
 var lst=new $ListOrTupleCtx(C,'dict_or_set_comp')
 lst.intervals=[C.start+1]
 lst.vars=C.vars
 C.tree.pop()
 lst.expression=C.tree
 if(C.yields){lst.expression.yields=C.yields
 delete C.yields}
 C.tree=[lst]
 lst.tree=[]
 var comp=new $ComprehensionCtx(lst)
 return new $TargetListCtx(new $CompForCtx(comp))}
 $_SyntaxError(C,'token '+token+' after '+C)}else if(C.expect=='id'){switch(token){case '}':
 if(C.tree.length==0){
 C.items=[]
 C.real='dict'}else{
 C.items=C.tree}
 C.tree=[]
 C.closed=true
 return C
 case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 C.expect=','
 var expr=new $AbstractExprCtx(C,false)
 return $transition(expr,token,value)
 case 'op':
 switch(value){case '*':
 case '**':
 C.expect=","
 var expr=new $AbstractExprCtx(C,false)
 expr.packed=value.length 
 if(C.real=="dict_or_set"){C.real=value=="*" ? "set" :
 "dict"}else if(
 (C.real=="set" && value=="**")||
 (C.real=="dict" && value=="*")){$_SyntaxError(C,'token '+token+
 ' after '+C)}
 return expr
 case '+':
 return C
 case '-':
 case '~':
 C.expect=','
 var left=new $UnaryCtx(C,value)
 if(value=='-'){var op_expr=new $OpCtx(left,'unary_neg')}else if(value=='+'){var op_expr=new $OpCtx(left,'unary_pos')}else{var op_expr=new $OpCtx(left,'unary_inv')}
 return new $AbstractExprCtx(op_expr,false)}
 $_SyntaxError(C,'token '+token+
 ' after '+C)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 return $transition(C.parent,token,value)}}
 $DictOrSetCtx.prototype.nb_dict_items=function(){var nb=0
 this.tree.forEach(function(item){if(item.packed){nb+=2}
 else{nb++}})
 return nb}
 $DictOrSetCtx.prototype.packed_indices=function(){var ixs=[]
 this.items.forEach(function(t,i){if(t.type=="expr" && t.packed){ixs.push(i)}})
 return ixs}
 $DictOrSetCtx.prototype.unpack_dict=function(packed){var js="",res,first,i=0,item,elts=[]
 while(i < this.items.length){item=this.items[i]
 first=i==0
 if(item.type=="expr" && item.packed){res="_b_.list.$factory(_b_.dict.items("+item.to_js()+"))"
 i++}else{res="[["+item.to_js()+","+
 this.items[i+1].to_js()+"]]"
 i+=2}
 if(! first){res=".concat("+res+")"}
 js+=res}
 return js}
 $DictOrSetCtx.prototype.unpack_set=function(packed){var js="",res
 this.items.forEach(function(t,i){if(packed.indexOf(i)>-1){res="_b_.list.$factory("+t.to_js()+")"}else{res="["+t.to_js()+"]"}
 if(i > 0){res=".concat("+res+")"}
 js+=res})
 return js}
 $DictOrSetCtx.prototype.to_js=function(){this.js_processed=true
 switch(this.real){case 'dict':
 var packed=this.packed_indices()
 if(packed.length > 0){return '_b_.dict.$factory('+this.unpack_dict(packed)+
 ')'+$to_js(this.tree)}
 var res=[]
 for(var i=0;i < this.items.length;i+=2){res.push('['+this.items[i].to_js()+','+
 this.items[i+1].to_js()+']')}
 return '_b_.dict.$factory(['+res.join(',')+'])'+
 $to_js(this.tree)
 case 'set_comp':
 return '_b_.set.$factory('+$to_js(this.items)+')'+
 $to_js(this.tree)
 case 'dict_comp':
 return '_b_.dict.$factory('+$to_js(this.items)+')'+
 $to_js(this.tree)}
 var packed=this.packed_indices()
 if(packed.length > 0){return '_b_.set.$factory('+this.unpack_set(packed)+')'}
 return '_b_.set.$factory(['+$to_js(this.items)+'])'+$to_js(this.tree)}
 var $DoubleStarArgCtx=$B.parser.$DoubleStarArgCtx=function(C){
 this.type='double_star_arg'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $DoubleStarArgCtx.prototype.toString=function(){return '**'+this.tree}
 $DoubleStarArgCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 return $transition(new $AbstractExprCtx(C,false),token,value)
 case ',':
 case ')':
 return $transition(C.parent,token)
 case ':':
 if(C.parent.parent.type=='lambda'){return $transition(C.parent.parent,token)}}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $DoubleStarArgCtx.prototype.to_js=function(){this.js_processed=true
 return '{$nat:"pdict",arg:'+$to_js(this.tree)+'}'}
 var $EllipsisCtx=$B.parser.$EllipsisCtx=function(C){
 this.type='ellipsis'
 this.parent=C
 this.nbdots=1
 this.start=$pos
 C.tree[C.tree.length]=this}
 $EllipsisCtx.prototype.toString=function(){return 'ellipsis'}
 $EllipsisCtx.prototype.transition=function(token,value){var C=this
 if(token=='.'){C.nbdots++
 if(C.nbdots==3 && $pos-C.start==2){C.$complete=true}
 return C}else{if(! C.$complete){$pos--
 $_SyntaxError(C,'token '+token+' after '+
 C)}else{return $transition(C.parent,token,value)}}}
 $EllipsisCtx.prototype.to_js=function(){this.js_processed=true
 return '$B.builtins["Ellipsis"]'}
 var $EndOfPositionalCtx=$B.parser.$EndOfConditionalCtx=function(C){
 this.type="end_positional"
 this.parent=C
 C.has_end_positional=true
 C.parent.pos_only=C.tree.length
 C.tree.push(this)}
 $EndOfPositionalCtx.prototype.transition=function(token,value){var C=this
 if(token=="," ||token==")"){return $transition(C.parent,token,value)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $EndOfPositionalCtx.prototype.to_js=function(){return "/"}
 var $ExceptCtx=$B.parser.$ExceptCtx=function(C){
 this.type='except'
 this.parent=C
 C.tree[C.tree.length]=this
 this.tree=[]
 this.expect='id'
 this.scope=$get_scope(this)}
 $ExceptCtx.prototype.toString=function(){return '(except) '}
 $ExceptCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case 'not':
 case 'lambda':
 if(C.expect=='id'){C.expect='as'
 return $transition(new $AbstractExprCtx(C,false),token,value)}
 case 'as':
 if(C.expect=='as' &&
 C.has_alias===undefined){C.expect='alias'
 C.has_alias=true
 return C}
 case 'id':
 if(C.expect=='alias'){C.expect=':'
 C.set_alias(value)
 return C}
 break
 case ':':
 var _ce=C.expect
 if(_ce=='id' ||_ce=='as' ||_ce==':'){return $BodyCtx(C)}
 break
 case '(':
 if(C.expect=='id' && C.tree.length==0){C.parenth=true
 return C}
 break
 case ')':
 if(C.expect==',' ||C.expect=='as'){C.expect='as'
 return C}
 case ',':
 if(C.parenth !==undefined &&
 C.has_alias===undefined &&
 (C.expect=='as' ||C.expect==',')){C.expect='id'
 return C}}
 $_SyntaxError(C,'token '+token+' after '+C.expect)}
 $ExceptCtx.prototype.set_alias=function(alias){this.tree[0].alias=$mangle(alias,this)
 $bind(alias,this.scope,this)}
 $ExceptCtx.prototype.transform=function(node,rank){
 var linenum_node=$NodeJS("void(0)")
 linenum_node.line_num=node.line_num
 node.insert(0,linenum_node)
 var last_child=$B.last(node.children)
 if(last_child.C.tree && last_child.C.tree[0]&&
 last_child.C.tree[0].type=="return"){}
 else{node.add($NodeJS("$B.del_exc()"))}}
 $ExceptCtx.prototype.to_js=function(){
 this.js_processed=true
 switch(this.tree.length){case 0:
 return 'else'
 case 1:
 if(this.tree[0].name=='Exception'){return 'else if(1)'}}
 var res=[]
 this.tree.forEach(function(elt){res.push(elt.to_js())})
 var lnum=''
 if($B.debug > 0){var module=$get_module(this)
 lnum='($locals.$line_info = "'+$get_node(this).line_num+
 ','+module.id+'") && '}
 return 'else if('+lnum+'$B.is_exc('+this.error_name+
 ',['+res.join(',')+']))'}
 var $ExprCtx=$B.parser.$ExprCtx=function(C,name,with_commas){
 this.type='expr'
 this.name=name
 this.with_commas=with_commas
 this.expect=',' 
 this.parent=C
 if(C.packed){this.packed=C.packed}
 if(C.is_await){var node=$get_node(this)
 node.has_await=node.has_await ||[]
 this.is_await=C.is_await
 node.has_await.push(this)}
 if(C.assign){
 this.assign=C.assign}
 this.tree=[]
 C.tree[C.tree.length]=this}
 $ExprCtx.prototype.toString=function(){return '(expr '+this.with_commas+') '+this.tree}
 $ExprCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'bytes':
 case 'float':
 case 'id':
 case 'imaginary':
 case 'int':
 case 'lambda':
 case 'pass':
 case 'str':
 $_SyntaxError(C,'token '+token+' after '+
 C)
 break
 case '{':
 if(C.tree[0].type !="id" ||
 ["print","exec"].indexOf(C.tree[0].value)==-1){$_SyntaxError(C,'token '+token+' after '+
 C)}
 return new $DictOrSetCtx(C)
 case '[':
 case '(':
 case '.':
 case 'not':
 if(C.expect=='expr'){C.expect=','
 return $transition(new $AbstractExprCtx(C,false),token,value)}}
 switch(token){case 'not':
 if(C.expect==','){return new $ExprNot(C)}
 break
 case 'in':
 if(C.parent.type=='target_list'){
 return $transition(C.parent,token)}
 if(C.expect==','){return $transition(C,'op','in')}
 break
 case ',':
 if(C.expect==','){if(C.with_commas ||
 ["assign","return"].indexOf(C.parent.type)>-1){if($parent_match(C,{type:"yield","from":true})){$_SyntaxError(C,"no implicit tuple for yield from")}
 C.parent.tree.pop()
 var tuple=new $ListOrTupleCtx(C.parent,'tuple')
 tuple.implicit=true
 tuple.has_comma=true
 tuple.tree=[C]
 C.parent=tuple
 return tuple}}
 return $transition(C.parent,token)
 case '.':
 return new $AttrCtx(C)
 case '[':
 return new $AbstractExprCtx(new $SubCtx(C),true)
 case '(':
 return new $CallCtx(C)
 case 'op':
 var op_parent=C.parent,op=value
 if(op_parent.type=='ternary' && op_parent.in_else){var new_op=new $OpCtx(C,op)
 return new $AbstractExprCtx(new_op,false)}
 var op1=C.parent,repl=null
 while(1){if(op1.type=='expr'){op1=op1.parent}
 else if(op1.type=='op' &&
 $op_weight[op1.op]>=$op_weight[op]&&
 !(op1.op=='**' && op=='**')){
 repl=op1
 op1=op1.parent}else if(op1.type=="not" &&
 $op_weight['not']> $op_weight[op]){repl=op1
 op1=op1.parent}else{break}}
 if(repl===null){while(1){if(C.parent !==op1){C=C.parent
 op_parent=C.parent}else{break}}
 C.parent.tree.pop()
 var expr=new $ExprCtx(op_parent,'operand',C.with_commas)
 expr.expect=','
 C.parent=expr
 var new_op=new $OpCtx(C,op)
 return new $AbstractExprCtx(new_op,false)}else{
 if(op==='and' ||op==='or'){while(repl.parent.type=='not'||
 (repl.parent.type=='expr' &&
 repl.parent.parent.type=='not')){
 repl=repl.parent
 op_parent=repl.parent}}}
 if(repl.type=='op'){var _flag=false
 switch(repl.op){case '<':
 case '<=':
 case '==':
 case '!=':
 case 'is':
 case '>=':
 case '>':
 _flag=true}
 if(_flag){switch(op){case '<':
 case '<=':
 case '==':
 case '!=':
 case 'is':
 case '>=':
 case '>':
 var c2=repl.tree[1],
 c2js=c2.to_js()
 var c2_clone=new Object()
 for(var attr in c2){c2_clone[attr]=c2[attr]}
 var vname="$c"+chained_comp_num
 c2.to_js=function(){return vname}
 c2_clone.to_js=function(){return vname}
 chained_comp_num++
 while(repl.parent && repl.parent.type=='op'){if($op_weight[repl.parent.op]<
 $op_weight[repl.op]){repl=repl.parent}else{break}}
 repl.parent.tree.pop()
 var and_expr=new $OpCtx(repl,'and')
 and_expr.wrap={'name':vname,'js':c2js}
 c2_clone.parent=and_expr
 and_expr.tree.push('xxx')
 var new_op=new $OpCtx(c2_clone,op)
 return new $AbstractExprCtx(new_op,false)}}}
 repl.parent.tree.pop()
 var expr=new $ExprCtx(repl.parent,'operand',false)
 expr.tree=[op1]
 repl.parent=expr
 var new_op=new $OpCtx(repl,op)
 return new $AbstractExprCtx(new_op,false)
 case 'augm_assign':
 var parent=C.parent
 while(parent){if(parent.type=="assign" ||parent.type=="augm_assign"){$_SyntaxError(C,"augmented assignment inside assignment")}else if(parent.type=="op"){$_SyntaxError(C,["cannot assign to operator"])}
 parent=parent.parent}
 if(C.expect==','){return new $AbstractExprCtx(
 new $AugmentedAssignCtx(C,value),true)}
 return $transition(C.parent,token,value)
 case ":":
 if(C.parent.type=="sub" ||
 (C.parent.type=="list_or_tuple" &&
 C.parent.parent.type=="sub")){return new $AbstractExprCtx(new $SliceCtx(C.parent),false)}else if(C.parent.type=="slice"){return $transition(C.parent,token,value)}else if(C.parent.type=="node"){
 if(C.tree.length==1){var child=C.tree[0]
 if(["id","sub","attribute"].indexOf(child.type)>-1){return new $AbstractExprCtx(new $AnnotationCtx(C),false)}else if(child.real=="tuple" && child.expect=="," &&
 child.tree.length==1){return new $AbstractExprCtx(new $AnnotationCtx(child.tree[0]),false)}}
 $_SyntaxError(C,"invalid target for annotation")}
 break
 case '=':
 function has_parent(ctx,type){
 while(ctx.parent){if(ctx.parent.type==type){return ctx.parent}
 ctx=ctx.parent}
 return false}
 var annotation
 if(C.expect==','){if(C.parent.type=="call_arg"){
 if(C.tree[0].type !="id"){$_SyntaxError(C,['expression cannot contain'+
 ' assignment, perhaps you meant "=="?'])}
 return new $AbstractExprCtx(new $KwArgCtx(C),true)}else if(annotation=has_parent(C,"annotation")){return $transition(annotation,token,value)}else if(C.parent.type=="op"){
 $_SyntaxError(C,["cannot assign to operator"])}else if(C.parent.type=="not"){
 $_SyntaxError(C,["cannot assign to operator"])}else if(C.parent.type=="list_or_tuple"){
 for(var i=0;i < C.parent.tree.length;i++){var item=C.parent.tree[i]
 if(item.type=="expr" && item.name=="operand"){$_SyntaxError(C,["cannot assign to operator"])}}}else if(C.tree.length > 0 && C.tree[0].assign){
 $_SyntaxError(C,["cannot assign to named expression"])}else if(C.parent.type=="expr" &&
 C.parent.name=="target list"){$_SyntaxError(C,'token '+token+' after '
 +C)}else if(C.parent.type=="lambda"){if(C.parent.parent.parent.type !="node"){$_SyntaxError(C,['expression cannot contain'+
 ' assignment, perhaps you meant "=="?'])}}
 while(C.parent !==undefined){C=C.parent
 if(C.type=="condition"){$_SyntaxError(C,'token '+token+' after '
 +C)}else if(C.type=="augm_assign"){$_SyntaxError(C,"assignment inside augmented assignment")}}
 C=C.tree[0]
 return new $AbstractExprCtx(new $AssignCtx(C),true)}
 break
 case ':=':
 var ptype=C.parent.type
 if(["node","assign","kwarg","annotation"].
 indexOf(ptype)>-1){$_SyntaxError(C,':= invalid, parent '+ptype)}else if(ptype=="func_arg_id" &&
 C.parent.tree.length > 0){
 $_SyntaxError(C,':= invalid, parent '+ptype)}else if(ptype=="call_arg" &&
 C.parent.parent.type=="call" &&
 C.parent.parent.parent.type=="lambda"){
 $_SyntaxError(C,':= invalid inside function arguments' )}
 if(C.tree.length==1 &&
 C.tree[0].type=="id"){var scope=$get_scope(C),name=C.tree[0].value
 while(scope.is_comp){scope=scope.parent_block}
 $bind(name,scope,C)
 var parent=C.parent
 parent.tree.pop()
 var assign_expr=new $AbstractExprCtx(parent,false)
 assign_expr.assign=C.tree[0]
 return assign_expr}
 $_SyntaxError(C,'token '+token+' after '+C)
 case 'if':
 var in_comp=false,ctx=C.parent
 while(true){if(ctx.type=="list_or_tuple"){
 break}else if(ctx.type=='comp_for' ||ctx.type=="comp_if"){in_comp=true
 break}else if(ctx.type=='call_arg'){break}
 if(ctx.parent !==undefined){ctx=ctx.parent}
 else{break}}
 if(in_comp){break}
 var ctx=C
 while(ctx.parent &&
 (ctx.parent.type=='op' ||
 (ctx.parent.type=="expr" && ctx.parent.name=="operand"))){ctx=ctx.parent}
 return new $AbstractExprCtx(new $TernaryCtx(ctx),true)
 case 'eol':
 if(C.tree.length==2 &&
 C.tree[0].type=="id" &&
 ["print","exec"].indexOf(C.tree[0].value)>-1){$_SyntaxError(C,["Missing parentheses in call "+
 "to '"+C.tree[0].value+"'."])}
 if(["dict_or_set","list_or_tuple"].indexOf(C.parent.type)==-1){var t=C.tree[0]
 if(t.type=="packed" ||
 (t.type=="call" && t.func.type=="packed")){$_SyntaxError(C,["can't use starred expression here"])}}}
 return $transition(C.parent,token)}
 $ExprCtx.prototype.to_js=function(arg){var res
 this.js_processed=true
 if(this.type=='list'){res='['+$to_js(this.tree)+']'}else if(this.tree.length==1){res=this.tree[0].to_js(arg)}else{res='_b_.tuple.$factory(['+$to_js(this.tree)+'])'}
 if(this.is_await){res="await ($B.promise("+res+"))"}
 if(this.assign){
 var scope=$get_scope(this)
 while(scope.is_comp){scope=scope.parent_block}
 if(scope.globals && scope.globals.has(this.assign.value)){
 while(scope.parent_block &&
 scope.parent_block.id !=="__builtins__"){scope=scope.parent_block}}else if(scope.nonlocals &&
 scope.nonlocals[this.assign.value]){
 scope=scope.parent_block}
 res="($locals_"+scope.id.replace(/\./g,'_')+'["'+
 this.assign.value+'"] = '+res+')'}
 return res}
 var $ExprNot=$B.parser.$ExprNot=function(C){
 this.type='expr_not'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $ExprNot.prototype.transition=function(token,value){var C=this
 if(token=='in'){
 C.parent.tree.pop()
 return new $AbstractExprCtx(
 new $OpCtx(C.parent,'not_in'),false)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $ExprNot.prototype.toString=function(){return '(expr_not)'}
 var $ForExpr=$B.parser.$ForExpr=function(C){
 if(C.node.parent.is_comp){
 C.node.parent.first_for=this}
 this.type='for'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 this.loop_num=$loop_num
 this.scope=$get_scope(this)
 if(this.scope.is_comp){}
 this.module=this.scope.module
 $loop_num++}
 $ForExpr.prototype.toString=function(){return '(for) '+this.tree}
 $ForExpr.prototype.transition=function(token,value){var C=this
 switch(token){case 'in':
 if(C.tree[0].tree.length==0){
 $_SyntaxError(C,"missing target between 'for' and 'in'")}
 return new $AbstractExprCtx(
 new $ExprCtx(C,'target list',true),false)
 case ':':
 if(C.tree.length < 2 
 ||C.tree[1].tree[0].type=="abstract_expr"){$_SyntaxError(C,'token '+token+' after '+
 C)}
 return $BodyCtx(C)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $ForExpr.prototype.transform=function(node,rank){
 var pnode=this.parent.node.parent
 while(pnode){if(pnode.is_comp){var module=$get_module(this)
 if(module.outermost_expr===undefined){pnode.outermost_expr=this.tree[1]
 module.outermost_expr=this.tree[1]
 this.tree.pop()
 new $RawJSCtx(this,"expr")}
 break}
 pnode=pnode.parent}
 if(this.async){return this.transform_async(node,rank)}
 var scope=$get_scope(this),target=this.tree[0],target_is_1_tuple=target.tree.length==1 && target.expect=='id',iterable=this.tree[1],num=this.loop_num,local_ns='$locals_'+scope.id.replace(/\./g,'_'),h='\n'+' '.repeat(node.indent+4)
 var $range=false
 if(target.tree.length==1 &&
 ! scope.blurred &&
 target.expct !='id' &&
 iterable.type=='expr' &&
 iterable.tree[0].type=='expr' &&
 iterable.tree[0].tree[0].type=='call'){var call=iterable.tree[0].tree[0]
 if(call.func.type=='id'){var func_name=call.func.value
 if(func_name=='range' && call.tree.length < 3 &&
 call.tree.length > 0){
 $range=call}}}
 var new_nodes=[],pos=0
 var children=node.children
 var offset=1
 if($range){if(this.has_break){
 new_node=new $Node()
 new $NodeJSCtx(new_node,local_ns+'["$no_break'+num+'"] = true')
 new_nodes[pos++]=new_node}
 var range_is_builtin=false,_scope=$get_scope(this),found=[]
 while(1){if(_scope.binding["range"]){found.push(_scope.id)}
 if(_scope.parent_block){_scope=_scope.parent_block}
 else{break}}
 range_is_builtin=found.length==1 &&
 found[0]=="__builtins__"
 var test_range_node=new $Node()
 test_range_node.module=node.parent.module
 if(range_is_builtin){new $NodeJSCtx(test_range_node,'if(1)')}else{new $NodeJSCtx(test_range_node,'if('+call.func.to_js()+' === _b_.range)')}
 new_nodes[pos++]=test_range_node
 var idt=target.to_js(),shortcut=false
 if($range.tree.length==1){var stop=$range.tree[0].tree[0]
 if(stop.tree[0].type=="int"){stop=parseInt(stop.to_js())
 if(0 < stop < $B.max_int){shortcut=true
 var varname="$i"+$B.UUID()
 var for_node=$NodeJS("for (var "+varname+" = 0; "+
 varname+" < "+stop+"; "+varname+"++)")
 for_node.add($NodeJS(idt+" = "+varname))}}
 var start=0,stop=$range.tree[0].to_js()}else{var start=$range.tree[0].to_js(),stop=$range.tree[1].to_js()}
 if(!shortcut){var js='var $stop_'+num+' = $B.int_or_bool('+stop+'),'+
 h+'        $next'+num+" = "+start+','+
 h+'        $safe'+num+' = typeof $next'+num+
 ' == "number" && typeof '+'$stop_'+num+' == "number";'+
 h+'    while(true)'
 var for_node=new $Node()
 new $NodeJSCtx(for_node,js)
 for_node.add($NodeJS('if($safe'+num+' && $next'+num+
 '>= $stop_'+num+'){break}'))
 for_node.add($NodeJS('else if(!$safe'+num+' && $B.ge($next'+
 num+', $stop_'+num+')){break}'))
 for_node.add($NodeJS(idt+' = $next'+num))
 for_node.add($NodeJS('if($safe'+num+'){$next'+num+
 ' += 1}'))
 for_node.add($NodeJS('else{$next'+num+' = $B.add($next'+
 num+',1)}'))}
 children.forEach(function(child){for_node.add(child.clone_tree())})
 if($B.last(node.children).C.tree[0].type !="return"){var js='$locals.$line_info = "'+node.line_num+
 ','+this.module+'";if($locals.$f_trace !== _b_.None){'+
 '$B.trace_line()};_b_.None;'
 for_node.add($NodeJS(js))}
 var in_loop=false
 if(scope.ntype=='module'){var pnode=node.parent
 while(pnode){if(pnode.for_wrapper){in_loop=true;break}
 pnode=pnode.parent}}
 if(scope.ntype=='module' && !in_loop){var func_node=new $Node()
 func_node.for_wrapper=true
 js='function $f'+num+'('
 if(this.has_break){js+='$no_break'+num}
 js+=')'
 new $NodeJSCtx(func_node,js)
 test_range_node.add(func_node)
 func_node.add(for_node)
 if(this.has_break){func_node.add($NodeJS('return $no_break'+num))}
 test_range_node.add($NodeJS('var $res'+num+' = $f'+num+
 '();'))
 if(this.has_break){test_range_node.add($NodeJS('var $no_break'+num+
 ' = $res'+num))}}else{
 test_range_node.add(for_node)}
 if(range_is_builtin){node.parent.children.splice(rank,1)
 var k=0
 if(this.has_break){node.parent.insert(rank,new_nodes[0])
 k++}
 new_nodes[k].children.forEach(function(child){node.parent.insert(rank+k,child)})
 node.parent.children[rank].line_num=node.line_num
 node.parent.children[rank].bindings=node.bindings
 node.children=[]
 return 0}
 var else_node=$NodeJS("else")
 new_nodes[pos++]=else_node
 for(var i=new_nodes.length-1;i >=0;i--){node.parent.insert(rank+1,new_nodes[i])}
 this.test_range=true
 new_nodes=[],pos=0}
 var new_node=new $Node()
 new_node.line_num=$get_node(this).line_num
 var it_js=iterable.to_js(),iterable_name='$iter'+num,js='var '+iterable_name+' = '+it_js+';'+
 '$locals["$next'+num+'"]'+' = $B.$getattr($B.$iter('+
 iterable_name+'),"__next__")'
 new $NodeJSCtx(new_node,js)
 new_nodes[pos++]=new_node
 if(this.has_break){
 new_nodes[pos++]=$NodeJS(local_ns+'["$no_break'+num+
 '"] = true;')}
 var while_node=new $Node()
 if(this.has_break){js='while('+local_ns+'["$no_break'+num+'"])'}else{js='while(true)'}
 new $NodeJSCtx(while_node,js)
 while_node.C.loop_num=num 
 while_node.C.type='for' 
 new_nodes[pos++]=while_node
 node.parent.children.splice(rank,1)
 if(this.test_range){for(var i=new_nodes.length-1;i >=0;i--){else_node.insert(0,new_nodes[i])}}else{for(var i=new_nodes.length-1;i >=0;i--){node.parent.insert(rank,new_nodes[i])
 offset+=new_nodes.length}}
 var try_node=$NodeJS("try")
 try_node.bindings=node.bindings
 while_node.add(try_node)
 var iter_node=new $Node()
 iter_node.id=this.module
 var C=new $NodeCtx(iter_node)
 var target_expr=new $ExprCtx(C,'left',true)
 if(target_is_1_tuple){
 var t=new $ListOrTupleCtx(target_expr)
 t.real='tuple'
 t.tree=target.tree}else{target_expr.tree=target.tree}
 var assign=new $AssignCtx(target_expr)
 assign.tree[1]=new $JSCode('$locals["$next'+num+'"]()')
 try_node.add(iter_node)
 while_node.add(
 $NodeJS('catch($err){if($B.is_exc($err, [_b_.StopIteration]))'+
 '{break;}else{throw($err)}}'))
 children.forEach(function(child){
 while_node.add(child.clone())})
 if(node.children.length==0){console.log("bizarre",this)}
 if($B.last(node.children).C.tree[0].type !="return"){var js='$locals.$line_info = "'+node.line_num+
 ','+this.module+'";if($locals.$f_trace !== _b_.None){'+
 '$B.trace_line()};_b_.None;'
 while_node.add($NodeJS(js))}
 node.children=[]
 return 0}
 $ForExpr.prototype.transform_async=function(node,rank){
 var scope=$get_scope(this),target=this.tree[0],target_is_1_tuple=target.tree.length==1 && target.expect=='id',iterable=this.tree[1],num=this.loop_num,local_ns='$locals_'+scope.id.replace(/\./g,'_'),h='\n'+' '.repeat(node.indent+4)
 var new_nodes=[]
 var it_js=iterable.to_js(),iterable_name='$iter'+num,type_name='$type'+num,running_name='$running'+num,anext_name='$anext'+num,target_name='$target'+num,js='var '+iterable_name+' = '+it_js
 new_nodes.push($NodeJS(js))
 new_nodes.push($NodeJS('var '+type_name+' = _b_.type.$factory( '+
 iterable_name+')'))
 js=iterable_name+' = $B.$call($B.$getattr('+type_name+
 ', "__aiter__"))('+iterable_name+')'
 new_nodes.push($NodeJS(js))
 new_nodes.push($NodeJS('var '+running_name+' = true'))
 new_nodes.push($NodeJS('var '+anext_name+
 ' = $B.$call($B.$getattr('+type_name+', "__anext__"))'))
 var while_node=$NodeJS('while('+running_name+')')
 new_nodes.push(while_node)
 var try_node=$NodeJS('try')
 while_node.add(try_node)
 if(target.tree.length==1){var js=target.to_js()+' = await ($B.promise('+
 anext_name+'('+iterable_name+')))'
 try_node.add($NodeJS(js))}else{var new_node=new $Node(),ctx=new $NodeCtx(new_node),expr=new $ExprCtx(ctx,"left",false)
 expr.tree.push(target)
 target.parent=expr
 var assign=new $AssignCtx(expr)
 new $RawJSCtx(assign,'await ($B.promise('+
 anext_name+'('+iterable_name+')))')
 try_node.add(new_node)}
 var catch_node=$NodeJS('catch(err)')
 while_node.add(catch_node)
 var js='if(err.__class__ === _b_.StopAsyncIteration)'+
 '{'+running_name+' = false; continue}else{throw err}'
 catch_node.add($NodeJS(js))
 node.children.forEach(function(child){while_node.add(child)})
 node.parent.children.splice(rank,1)
 for(var i=new_nodes.length-1;i >=0;i--){node.parent.insert(rank,new_nodes[i])}
 node.children=[]
 return 0}
 $ForExpr.prototype.to_js=function(){this.js_processed=true
 var iterable=this.tree.pop()
 return 'for ('+$to_js(this.tree)+' in '+iterable.to_js()+')'}
 var $FromCtx=$B.parser.$FromCtx=function(C){
 this.type='from'
 this.parent=C
 this.module=''
 this.names=[]
 C.tree[C.tree.length]=this
 this.expect='module'
 this.scope=$get_scope(this)}
 $FromCtx.prototype.add_name=function(name){this.names[this.names.length]=name
 if(name=='*'){this.scope.blurred=true}}
 $FromCtx.prototype.bind_names=function(){
 var scope=$get_scope(this)
 this.names.forEach(function(name){if(Array.isArray(name)){name=name[1]}
 $bind(name,scope,this)},this)}
 $FromCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.expect=='id'){C.add_name(value)
 C.expect=','
 return C}
 if(C.expect=='alias'){C.names[C.names.length-1]=
 [$B.last(C.names),value]
 C.expect=','
 return C}
 case '.':
 if(C.expect=='module'){if(token=='id'){C.module+=value}
 else{C.module+='.'}
 return C}
 case 'import':
 if(C.expect=='module'){C.expect='id'
 return C}
 case 'op':
 if(value=='*' && C.expect=='id'
 && C.names.length==0){if($get_scope(C).ntype !=='module'){$_SyntaxError(C,["import * only allowed at module level"])}
 C.add_name('*')
 C.expect='eol'
 return C}
 case ',':
 if(C.expect==','){C.expect='id'
 return C}
 case 'eol':
 switch(C.expect){case ',':
 case 'eol':
 C.bind_names()
 return $transition(C.parent,token)
 case 'id':
 $_SyntaxError(C,['trailing comma not allowed without '+
 'surrounding parentheses'])
 default:
 $_SyntaxError(C,['invalid syntax'])}
 case 'as':
 if(C.expect==',' ||C.expect=='eol'){C.expect='alias'
 return C}
 case '(':
 if(C.expect=='id'){C.expect='id'
 return C}
 case ')':
 if(C.expect==',' ||C.expect=='id'){C.expect='eol'
 return C}}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $FromCtx.prototype.toString=function(){return '(from) '+this.module+' (import) '+this.names}
 $FromCtx.prototype.to_js=function(){this.js_processed=true
 var scope=$get_scope(this),module=$get_module(this),mod=module.module,res=[],pos=0,indent=$get_node(this).indent,head=' '.repeat(indent)
 if(mod.startsWith("$exec")){var frame=$B.last($B.frames_stack)[1]
 if(frame.module && frame.module.__name__){mod=frame.module.__name__}}
 var mod_elts=this.module.split(".")
 for(var i=0;i < mod_elts.length;i++){module.imports[mod_elts.slice(0,i+1).join(".")]=true}
 var _mod=this.module.replace(/\$/g,''),$package,packages=[]
 while(_mod.length > 0){if(_mod.charAt(0)=='.'){if($package===undefined){if($B.imported[mod]!==undefined){$package=$B.imported[mod].__package__
 packages=$package.split('.')}}else{$package=$B.imported[$package]
 packages.pop()}
 if($package===undefined){return 'throw _b_.SystemError.$factory("Parent module \'\' '+
 'not loaded, cannot perform relative import")'}else if($package=='None'){console.log('package is None !')}
 _mod=_mod.substr(1)}else{break}}
 if(_mod){packages.push(_mod)}
 this.module=packages.join('.')
 var mod_name=this.module.replace(/\$/g,'')
 res[pos++]='var module = $B.$import("'
 res[pos++]=mod_name+'",["'
 var names=[]
 for(var i=0,len=this.names.length;i < len;i++){if(Array.isArray(this.names[i])){names.push(this.names[i][0])}else{names.push(this.names[i])}}
 res[pos++]=names.join('","')+'"], {'
 var sep=''
 for(var attr in this.aliases){res[pos++]=sep+'"'+attr+'": "'+this.aliases[attr]+'"'
 sep=','}
 res[pos++]='}, {}, true);'
 if(this.names[0]=='*'){
 scope.blurred=true
 res[pos++]='\n'+head+'$B.import_all($locals, module);'}else{this.names.forEach(function(name){var alias=name
 if(Array.isArray(name)){alias=name[1]
 name=name[0]}
 module.imports[this.module+'.'+name]=true
 res[pos++]='\n'+head+'$locals["'+
 alias+'"] = $B.$getattr($B.imported["'+
 mod_name+'"], "'+name+'");'},this)}
 res[pos++]='\n'+head+'_b_.None;'
 return res.join('');}
 var $FuncArgs=$B.parser.$FuncArgs=function(C){
 this.type='func_args'
 this.parent=C
 this.tree=[]
 this.names=[]
 C.tree[C.tree.length]=this
 this.expect='id'
 this.has_default=false
 this.has_star_arg=false
 this.has_kw_arg=false}
 $FuncArgs.prototype.toString=function(){return 'func args '+this.tree}
 $FuncArgs.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.has_kw_arg){$_SyntaxError(C,'duplicate keyword argument')}
 if(C.expect=='id'){C.expect=','
 if(C.names.indexOf(value)>-1){$_SyntaxError(C,['duplicate argument '+value+
 ' in function definition'])}}
 return new $FuncArgIdCtx(C,value)
 case ',':
 if(C.expect==','){C.expect='id'
 return C}
 $_SyntaxError(C,'token '+token+' after '+
 C)
 case ')':
 var last=$B.last(C.tree)
 if(last && last.type=="func_star_arg"){if(last.name=="*"){if(C.op=='*'){
 $_SyntaxError(C,['named arguments must follow bare *'])}else{$_SyntaxError(C,'invalid syntax')}}}
 return C.parent
 case 'op':
 if(C.has_kw_arg){$_SyntaxError(C,'duplicate keyword argument')}
 var op=value
 C.expect=','
 if(op=='*'){if(C.has_star_arg){$_SyntaxError(C,'duplicate star argument')}
 return new $FuncStarArgCtx(C,'*')}else if(op=='**'){return new $FuncStarArgCtx(C,'**')}else if(op=='/'){
 if(C.has_end_positional){$_SyntaxError(C,['duplicate / in function parameters'])}else if(C.has_star_arg){$_SyntaxError(C,['/ after * in function parameters'])}
 return new $EndOfPositionalCtx(C)}
 $_SyntaxError(C,'token '+op+' after '+C)
 case ':':
 if(C.parent.type=="lambda"){return $transition(C.parent,token)}}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $FuncArgs.prototype.to_js=function(){this.js_processed=true
 return $to_js(this.tree)}
 var $FuncArgIdCtx=$B.parser.$FuncArgIdCtx=function(C,name){
 this.type='func_arg_id'
 this.name=name
 this.parent=C
 if(C.has_star_arg){C.parent.after_star.push(name)}else{C.parent.positional_list.push(name)}
 var node=$get_node(this)
 if(node.binding[name]){$_SyntaxError(C,["duplicate argument '"+name+"' in function definition"])}
 $bind(name,node,this)
 this.tree=[]
 C.tree[C.tree.length]=this
 var ctx=C
 while(ctx.parent !==undefined){if(ctx.type=='def'){ctx.locals.push(name)
 break}
 ctx=ctx.parent}
 this.expect='='}
 $FuncArgIdCtx.prototype.toString=function(){return 'func arg id '+this.name+'='+this.tree}
 $FuncArgIdCtx.prototype.transition=function(token,value){var C=this
 switch(token){case '=':
 if(C.expect=='='){C.has_default=true
 var def_ctx=C.parent.parent
 if(C.parent.has_star_arg){def_ctx.default_list.push(def_ctx.after_star.pop())}else{def_ctx.default_list.push(def_ctx.positional_list.pop())}
 return new $AbstractExprCtx(C,false)}
 break
 case ',':
 case ')':
 if(C.parent.has_default && C.tree.length==0 &&
 C.parent.has_star_arg===undefined){$pos-=C.name.length
 $_SyntaxError(C,['non-default argument follows default argument'])}else{return $transition(C.parent,token)}
 case ':':
 if(C.parent.parent.type=="lambda"){
 return $transition(C.parent.parent,":")}
 if(C.has_default){
 $_SyntaxError(C,'token '+token+' after '+
 C)}
 return new $AbstractExprCtx(new $AnnotationCtx(C),false)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $FuncArgIdCtx.prototype.to_js=function(){this.js_processed=true
 return this.name+$to_js(this.tree)}
 var $FuncStarArgCtx=$B.parser.$FuncStarArgCtx=function(C,op){
 this.type='func_star_arg'
 this.op=op
 this.parent=C
 this.node=$get_node(this)
 C.has_star_arg=op=='*'
 C.has_kw_arg=op=='**'
 C.tree[C.tree.length]=this}
 $FuncStarArgCtx.prototype.toString=function(){return '(func star arg '+this.op+') '+this.name}
 $FuncStarArgCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.name===undefined){if(C.parent.names.indexOf(value)>-1){$_SyntaxError(C,['duplicate argument '+value+
 ' in function definition'])}}
 C.set_name(value)
 C.parent.names.push(value)
 return C
 case ',':
 case ')':
 if(C.name===undefined){
 C.set_name('*')
 C.parent.names.push('*')}
 return $transition(C.parent,token)
 case ':':
 if(C.parent.parent.type=="lambda"){
 return $transition(C.parent.parent,":")}
 if(C.name===undefined){$_SyntaxError(C,'annotation on an unnamed parameter')}
 return new $AbstractExprCtx(
 new $AnnotationCtx(C),false)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $FuncStarArgCtx.prototype.set_name=function(name){this.name=name
 if(this.node.binding[name]){$_SyntaxError(C,["duplicate argument '"+name+"' in function definition"])}
 $bind(name,this.node,this)
 var ctx=this.parent
 while(ctx.parent !==undefined){if(ctx.type=='def'){ctx.locals.push(name)
 break}
 ctx=ctx.parent}
 if(this.op=='*'){ctx.other_args='"'+name+'"'}
 else{ctx.other_kw='"'+name+'"'}}
 var $GlobalCtx=$B.parser.$GlobalCtx=function(C){
 this.type='global'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 this.expect='id'
 this.scope=$get_scope(this)
 this.scope.globals=this.scope.globals ||new Set()
 this.module=$get_module(this)
 while(this.module.module !=this.module.id){this.module=this.module.parent_block}
 this.module.binding=this.module.binding ||{}}
 $GlobalCtx.prototype.toString=function(){return 'global '+this.tree}
 $GlobalCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.expect=='id'){new $IdCtx(C,value)
 C.add(value)
 C.expect=','
 return C}
 break
 case ',':
 if(C.expect==','){C.expect='id'
 return C}
 break
 case 'eol':
 if(C.expect==','){return $transition(C.parent,token)}
 break}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $GlobalCtx.prototype.add=function(name){if(this.scope.annotations && this.scope.annotations.has(name)){$_SyntaxError(C,["annotated name '"+name+
 "' can't be global"])}
 this.scope.globals.add(name)
 var mod=this.scope.parent_block
 if(this.module.module.startsWith("$exec")){while(mod && mod.parent_block !==this.module){
 mod._globals=mod._globals ||{}
 mod._globals[name]=this.module.id
 delete mod.binding[name]
 mod=mod.parent_block}}
 this.module.binding[name]=true}
 $GlobalCtx.prototype.to_js=function(){this.js_processed=true
 return ''}
 var $IdCtx=$B.parser.$IdCtx=function(C,value){
 this.type='id'
 this.value=$mangle(value,C)
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 var scope=this.scope=$get_scope(this)
 this.blurred_scope=this.scope.blurred
 this.env=clone(this.scope.binding)
 if(["def","generator"].indexOf(scope.ntype)>-1){scope.referenced=scope.referenced ||{}
 if(! $B.builtins[this.value]){scope.referenced[this.value]=true}}
 if(C.parent.type=='call_arg'){this.call_arg=true}
 var ctx=C
 while(ctx.parent !==undefined){switch(ctx.type){case 'ctx_manager_alias':
 $bind(value,scope,this)
 break
 case 'list_or_tuple':
 case 'dict_or_set':
 case 'call_arg':
 case 'def':
 case 'lambda':
 if(ctx.vars===undefined){ctx.vars=[value]}
 else if(ctx.vars.indexOf(value)==-1){ctx.vars.push(value)}
 if(this.call_arg&&ctx.type=='lambda'){if(ctx.locals===undefined){ctx.locals=[value]}
 else{ctx.locals.push(value)}}}
 ctx=ctx.parent}
 if($parent_match(C,{type:'target_list'})){
 this.no_bindings=true
 $bind(value,scope,this)
 this.bound=true}
 if(["def","generator"].indexOf(scope.ntype)>-1){
 var _ctx=this.parent
 while(_ctx){if(_ctx.type=='list_or_tuple' && _ctx.is_comp()){this.in_comp=true
 break}
 _ctx=_ctx.parent}
 if(C.type=='expr' && C.parent.type=='comp_if'){}else if(C.type=='global'){if(scope.globals===undefined){scope.globals=new Set([value])}else{scope.globals.add(value)}}}}
 $IdCtx.prototype.toString=function(){return '(id) '+this.value+':'+(this.tree ||'')}
 $IdCtx.prototype.transition=function(token,value){var C=this
 switch(token){case '=':
 if(C.parent.type=='expr' &&
 C.parent.parent !==undefined &&
 C.parent.parent.type=='call_arg'){return new $AbstractExprCtx(
 new $KwArgCtx(C.parent),false)}
 return $transition(C.parent,token,value)
 case 'op':
 return $transition(C.parent,token,value)
 case 'id':
 case 'str':
 case 'int':
 case 'float':
 case 'imaginary':
 if(["print","exec"].indexOf(C.value)>-1 ){$_SyntaxError(C,["missing parenthesis in call to '"+
 C.value+"'"])}
 $_SyntaxError(C,'token '+token+' after '+
 C)}
 if(this.parent.parent.type=="packed"){if(['.','[','('].indexOf(token)==-1){return this.parent.parent.transition(token,value)}}
 return $transition(C.parent,token,value)}
 $IdCtx.prototype.firstBindingScopeId=function(){
 var scope=this.scope,found=[],nb=0
 while(scope){if(scope.globals && scope.globals.has(this.value)){return $get_module(this).id}
 if(scope.binding && scope.binding[this.value]){return scope.id}
 scope=scope.parent}}
 $IdCtx.prototype.boundBefore=function(scope){
 var node=$get_node(this),found=false
 var $test=false 
 if($test){console.log(this.value,"bound before")
 console.log("node",node)}
 while(!found && node.parent){var pnode=node.parent
 if(pnode.bindings && pnode.bindings[this.value]){if($test){console.log("bound in",pnode)}
 return pnode.bindings[this.value]}
 for(var i=0;i < pnode.children.length;i++){var child=pnode.children[i]
 if(child===node){break}
 if(child.bindings && child.bindings[this.value]){if($test){console.log("bound in child",child)}
 return child.bindings[this.value]}}
 if(pnode===scope){break}
 node=pnode}
 return found}
 $IdCtx.prototype.bindingType=function(scope){
 var nb=0,node=$get_node(this),found=false,unknown,ix
 while(!found && node.parent && nb++< 100){var pnode=node.parent
 if(pnode.bindings && pnode.bindings[this.value]){return pnode.bindings[this.value]}
 for(var i=0;i < pnode.children.length;i++){var child=pnode.children[i]
 if(child===node){break}
 if(child.bindings && child.bindings[this.value]){found=child.bindings[this.value]
 ix=i}}
 if(found){for(var j=ix+1;j < pnode.children.length;j++){child=pnode.children[j]
 if(child.children.length > 0){unknown=true
 break}else if(child===node){break}}
 return unknown ||found}
 if(pnode===scope){break}
 node=pnode}
 return found}
 $IdCtx.prototype.to_js=function(arg){
 if(this.result !==undefined && this.scope.ntype=='generator'){return this.result}
 var val=this.value
 var $test=false 
 if($test){console.log("this",this)}
 if(val=='__BRYTHON__' ||val=='$B'){return val}
 if(val.startsWith("comp_result_"+$B.lambda_magic)){if(this.bound){return "var "+val}
 return val}
 this.js_processed=true
 if(this.scope._globals && this.scope._globals[val]){this.global_module=this.scope._globals[val]}
 if(this.global_module){return '$locals_'+this.global_module.replace(/\./g,"_")+
 '["'+val+'"]'}
 var is_local=this.scope.binding[val]!==undefined,this_node=$get_node(this),bound_before=this_node.bound_before
 this.nonlocal=this.scope.nonlocals &&
 this.scope.nonlocals[val]!==undefined
 this.unbound=this.unbound ||(is_local && !this.bound &&
 bound_before && bound_before.indexOf(val)==-1)
 if((!this.bound)&& this.scope.C
 && this.scope.ntype=='class' &&
 this.scope.C.tree[0].name==val){
 return '$B.$search("'+val+'")'}
 if(this.unbound && !this.nonlocal){if(this.scope.ntype=='def' ||this.scope.ntype=='generator'){return '$B.$local_search("'+val+'")'}else{return '$B.$search("'+val+'")'}}
 var innermost=$get_scope(this),scope=innermost,found=[]
 var search_ids=['"'+innermost.id+'"']
 var gs=innermost
 while(true){if($test){console.log(gs.id,gs)}
 if(gs.parent_block){if(gs.parent_block==$B.builtins_scope){break}
 else if(gs.parent_block.id===undefined){break}
 gs=gs.parent_block}
 search_ids.push('"'+gs.id+'"')}
 search_ids="["+search_ids.join(", ")+"]"
 if(innermost.globals && innermost.globals.has(val)){search_ids=['"'+gs.id+'"']
 innermost=gs}
 if($test){console.log("search ids",search_ids)}
 if(this.nonlocal ||this.bound){var bscope=this.firstBindingScopeId()
 if($test){console.log("binding",bscope)}
 if(bscope !==undefined){return "$locals_"+bscope.replace(/\./g,"_")+'["'+
 val+'"]'}else if(this.bound){return "$locals_"+innermost.id.replace(/\./g,"_")+
 '["'+val+'"]'}}
 var global_ns='$locals_'+gs.id.replace(/\./g,'_')
 while(1){if(scope.globals !==undefined &&
 scope.globals.has(val)){if($test){console.log("in globals of",scope.id)}
 if(this.boundBefore(gs)){if($test){console.log("bound before in gs",gs)}
 return global_ns+'["'+val+'"]'}else{if($test){console.log("use global search",this)}
 if(this.augm_assign){return global_ns+'["'+val+'"]'}else{return '$B.$global_search("'+val+'", '+
 search_ids+')'}}}
 if($test){console.log("scope",scope,"innermost",innermost,scope===innermost,"bound_before",bound_before,"found",found.slice())}
 if(scope===innermost){
 if(bound_before){if(bound_before.indexOf(val)>-1){found.push(scope)}
 else if(scope.C &&
 scope.C.tree[0].type=='def' &&
 scope.C.tree[0].env.indexOf(val)>-1){found.push(scope)}}else{if(scope.binding[val]){
 if(this_node.locals[val]===undefined){
 if(!scope.is_comp &&
 (!scope.parent_block ||
 !scope.parent_block.is_comp)){
 found.push(scope)}}else{found.push(scope)
 break}
 if($test){console.log(val,"found in",scope.id)}}}}else{if(scope.binding===undefined){console.log("scope",scope,val,"no binding",innermost)}
 if(scope.binding[val]){found.push(scope)}}
 if(scope.parent_block){scope=scope.parent_block}
 else{break}}
 this.found=found
 if($test){console.log("found",found)
 found.forEach(function(item){console.log(item.id)})}
 if(this.nonlocal && found[0]===innermost){found.shift()}
 if(found.length > 0){
 if(found[0].C && found[0]===innermost
 && val.charAt(0)!='$'){var locs=this_node.locals ||{},nonlocs=innermost.nonlocals
 try{if(locs[val]===undefined &&
 ! this.augm_assign &&
 ((innermost.type !='def' ||
 innermost.type !='generator')&&
 innermost.ntype !='class' &&
 innermost.C.tree[0].args &&
 innermost.C.tree[0].args.indexOf(val)==-1)&&
 (nonlocs===undefined ||nonlocs[val]===undefined)){if($test){console.log("$local search",val,"found",found,"innermost",innermost,"this",this)}
 this.result='$B.$local_search("'+val+'")'
 return this.result}}catch(err){console.log("error",val,innermost)
 throw err}}
 if(found.length > 1 && found[0].C){if(found[0].C.tree[0].type=='class'){var ns0='$locals_'+found[0].id.replace(/\./g,'_'),ns1='$locals_'+found[1].id.replace(/\./g,'_'),res
 if(bound_before){if(bound_before.indexOf(val)>-1){this.found=found[0].binding[val]
 res=ns0}else{this.found=found[1].binding[val]
 res=ns1}
 this.result=res+'["'+val+'"]'
 return this.result}else{this.found=false
 var res=ns0+'["'+val+'"] !== undefined ? '
 res+=ns0+'["'+val+'"] : '
 this.result="("+res+ns1+'["'+val+'"])'
 return this.result}}}
 var scope=found[0]
 this.found=scope.binding[val]
 var scope_ns='$locals_'+scope.id.replace(/\./g,'_')
 if(scope.C===undefined){if($test){console.log("module level",scope.id,scope.module)}
 if(scope.id=='__builtins__'){if(gs.blurred){
 val='('+global_ns+'["'+val+'"] || _b_.'+val+')'}else{
 val='_b_.'+val
 this.is_builtin=true}}else{
 if($test){console.log("name found at module level")}
 if(this.bound ||this.augm_assign){
 val=scope_ns+'["'+val+'"]'}else{if(scope===innermost && this.env[val]===undefined){
 this.result='$B.$search("'+val+'")'
 return this.result}else{if($test){console.log("boudn before ?",scope,this.boundBefore(scope))}
 if(this.boundBefore(scope)){
 val=scope_ns+'["'+val+'"]'}else{
 if($test){console.log("use check def",scope)}
 val='$B.$check_def("'+val+'",'+
 scope_ns+'["'+val+'"])'}}}}}else if(scope===innermost){if($test){console.log("scope is innermost",scope.id)}
 if(scope.globals && scope.globals.has(val)){val=global_ns+'["'+val+'"]'}else if(!this.bound && !this.augm_assign){
 if(this.boundBefore(scope)){val='$locals["'+val+'"]'}else{val='$B.$check_def_local("'+val+'",$locals["'+
 val+'"])'}}else{val='$locals["'+val+'"]'}}else if(!this.augm_assign){
 val='$B.$check_def_free("'+val+'",'+scope_ns+
 '["'+val+'"])'}else{val=scope_ns+'["'+val+'"]'}
 this.result=val+$to_js(this.tree,'')
 return this.result}else{
 this.unknown_binding=true
 this.result='$B.$global_search("'+val+'", '+search_ids+')'
 return this.result}}
 var $ImportCtx=$B.parser.$ImportCtx=function(C){
 this.type='import'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 this.expect='id'}
 $ImportCtx.prototype.toString=function(){return 'import '+this.tree}
 $ImportCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.expect=='id'){new $ImportedModuleCtx(C,value)
 C.expect=','
 return C}
 if(C.expect=='qual'){C.expect=','
 C.tree[C.tree.length-1].name+=
 '.'+value
 C.tree[C.tree.length-1].alias+=
 '.'+value
 return C}
 if(C.expect=='alias'){C.expect=','
 C.tree[C.tree.length-1].alias=
 value
 return C}
 break
 case '.':
 if(C.expect==','){C.expect='qual'
 return C}
 break
 case ',':
 if(C.expect==','){C.expect='id'
 return C}
 break
 case 'as':
 if(C.expect==','){C.expect='alias'
 return C}
 break
 case 'eol':
 if(C.expect==','){C.bind_names()
 return $transition(C.parent,token)}
 break}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $ImportCtx.prototype.bind_names=function(){
 var scope=$get_scope(this)
 this.tree.forEach(function(item){if(item.name==item.alias){var name=item.name,parts=name.split('.'),bound=name
 if(parts.length>1){bound=parts[0]}}else{bound=item.alias}
 $bind(bound,scope,this)},this)}
 $ImportCtx.prototype.to_js=function(){this.js_processed=true
 var scope=$get_scope(this),res=[],module=$get_module(this)
 this.tree.forEach(function(item){var mod_name=item.name,aliases=(item.name==item.alias)?
 '{}' :('{"'+mod_name+'" : "'+
 item.alias+'"}'),localns='$locals_'+scope.id.replace(/\./g,'_'),mod_elts=item.name.split(".")
 for(var i=0;i < mod_elts.length;i++){module.imports[mod_elts.slice(0,i+1).join(".")]=true}
 var js='$B.$import("'+mod_name+'", [],'+aliases+
 ','+localns+', true);'
 res.push(js)})
 return res.join('')+'_b_.None;'}
 var $ImportedModuleCtx=$B.parser.$ImportedModuleCtx=function(C,name){this.type='imported module'
 this.parent=C
 this.name=name
 this.alias=name
 C.tree[C.tree.length]=this}
 $ImportedModuleCtx.prototype.toString=function(){return ' (imported module) '+this.name}
 $ImportedModuleCtx.prototype.transition=function(token,value){var C=this}
 $ImportedModuleCtx.prototype.to_js=function(){this.js_processed=true
 return '"'+this.name+'"'}
 var $JSCode=$B.parser.$JSCode=function(js){this.js=js}
 $JSCode.prototype.toString=function(){return this.js}
 $JSCode.prototype.transition=function(token,value){var C=this}
 $JSCode.prototype.to_js=function(){this.js_processed=true
 return this.js}
 var $KwArgCtx=$B.parser.$KwArgCtx=function(C){
 this.type='kwarg'
 this.parent=C.parent
 this.tree=[C.tree[0]]
 C.parent.tree.pop()
 C.parent.tree.push(this)
 C.parent.parent.has_kw=true
 var value=this.tree[0].value
 var ctx=C.parent.parent 
 if(ctx.kwargs===undefined){ctx.kwargs=[value]}
 else if(ctx.kwargs.indexOf(value)==-1){ctx.kwargs.push(value)}
 else{$_SyntaxError(C,['keyword argument repeated'])}}
 $KwArgCtx.prototype.toString=function(){return 'kwarg '+this.tree[0]+'='+this.tree[1]}
 $KwArgCtx.prototype.transition=function(token,value){var C=this
 if(token==','){return new $CallArgCtx(C.parent.parent)}
 return $transition(C.parent,token)}
 $KwArgCtx.prototype.to_js=function(){this.js_processed=true
 var key=this.tree[0].value
 if(key.substr(0,2)=='$$'){key=key.substr(2)}
 var res='{$nat:"kw",name:"'+key+'",'
 return res+'value:'+
 $to_js(this.tree.slice(1,this.tree.length))+'}'}
 var $LambdaCtx=$B.parser.$LambdaCtx=function(C){
 this.type='lambda'
 this.parent=C
 C.tree[C.tree.length]=this
 this.tree=[]
 this.args_start=$pos+6
 this.vars=[]
 this.locals=[]
 this.node=$get_node(this)
 this.node.binding={}
 this.positional_list=[]
 this.default_list=[]
 this.other_args=null
 this.other_kw=null
 this.after_star=[]}
 $LambdaCtx.prototype.toString=function(){return '(lambda) '+this.args_start+' '+this.body_start}
 $LambdaCtx.prototype.transition=function(token,value){var C=this
 if(token==':' && C.args===undefined){C.args=C.tree
 C.tree=[]
 C.body_start=$pos
 return new $AbstractExprCtx(C,false)}if(C.args !==undefined){
 C.body_end=$pos
 return $transition(C.parent,token)}
 if(C.args===undefined && token !="("){return $transition(new $FuncArgs(C),token,value)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $LambdaCtx.prototype.to_js=function(){this.js_processed=true
 var C=this.parent,node=this.node,module=$get_module(this),src=$get_src(C),args=src.substring(this.args_start,this.body_start),body=src.substring(this.body_start+1,this.body_end)
 body=body.replace(/\\\n/g,' ')
 body=body.replace(/\n/g,' ')
 var scope=$get_scope(this)
 var rand=$B.UUID(),func_name='lambda_'+$B.lambda_magic+'_'+rand,py='def '+func_name+'('+args+'):'
 py+='    return '+body
 var lambda_name='lambda'+rand,module_name=module.id.replace(/\./g,'_')
 var root=$B.py2js(py,module_name,lambda_name,scope,node.line_num)
 var js=root.to_js()
 var params=`$locals_${lambda_name}`,args="{}"
 if(module.is_comp){
 params+=`,$locals_${module.id.replace(/\./g,'_')}`
 args+=`,typeof $locals_${module.id.replace(/\./g,'_')}`+
 `==="undefined" ?{}:$locals_${module.id.replace(/\./g,'_')}`}
 js=`(function(${params}){\n`+js+
 `\nreturn $locals.${func_name}})(${args})`
 $B.clear_ns(lambda_name)
 $B.$py_src[lambda_name]=null
 delete $B.$py_src[lambda_name]
 return js}
 var $ListOrTupleCtx=$B.parser.$ListOrTupleCtx=function(C,real){
 this.type='list_or_tuple'
 this.start=$pos
 this.real=real
 this.expect='id'
 this.closed=false
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $ListOrTupleCtx.prototype.toString=function(){switch(this.real){case 'list':
 return '(list) ['+this.tree+']'
 case 'list_comp':
 case 'gen_expr':
 return '('+this.real+') ['+this.intervals+'-'+
 this.tree+']'
 default:
 return '(tuple) ('+this.tree+')'}}
 $ListOrTupleCtx.prototype.transition=function(token,value){var C=this
 if(C.closed){if(token=='['){return new $AbstractExprCtx(
 new $SubCtx(C.parent),false)}
 if(token=='('){return new $CallCtx(C.parent)}
 return $transition(C.parent,token,value)}else{if(C.expect==','){switch(C.real){case 'tuple':
 case 'gen_expr':
 if(token==')'){var close=true
 while(C.type=="list_or_tuple" &&
 C.real=="tuple" &&
 C.parent.type=="expr" &&
 C.parent.parent.type=="node" &&
 C.tree.length==1){
 close=false
 var node=C.parent.parent,ix=node.tree.indexOf(C.parent),expr=C.tree[0]
 expr.parent=node
 expr.$in_parens=true 
 node.tree.splice(ix,1,expr)
 C=expr.tree[0]}
 if(close){C.close()}
 if(C.real=='gen_expr'){
 if(C.expression.yields){for(const _yield of C.expression.yields){$pos=_yield[1]
 $_SyntaxError(C,["'yield' inside generator expression"])}}
 C.intervals.push($pos)}
 if(C.parent.type=="packed"){return C.parent.parent}
 if(C.parent.type=="abstract_expr" &&
 C.parent.assign){
 C.parent.parent.tree.pop()
 var expr=new $ExprCtx(C.parent.parent,"assign",false)
 expr.tree=C.parent.tree
 expr.tree[0].parent=expr
 expr.assign=C.parent.assign
 return expr}
 return C.parent}
 break
 case 'list':
 case 'list_comp':
 if(token==']'){C.close()
 if(C.real=='list_comp'){
 if(C.expression.yields){for(const _yield of C.expression.yields){$pos=_yield[1]
 $_SyntaxError(C,["'yield' inside list comprehension"])}}
 C.intervals.push($pos)}
 if(C.parent.type=="packed"){if(C.parent.tree.length > 0){return C.parent.tree[0]}else{return C.parent.parent}}
 return C.parent}
 break
 case 'dict_or_set_comp':
 if(token=='}'){
 if(C.expression.yields){for(const _yield of C.expression.yields){$pos=_yield[1]
 var comp_type=C.parent.real=="set_comp" ?
 "set" :"dict"
 $_SyntaxError(C,[`'yield' inside ${comp_type}comprehension`])}}
 C.intervals.push($pos)
 return $transition(C.parent,token)}
 break}
 switch(token){case ',':
 if(C.real=='tuple'){C.has_comma=true}
 C.expect='id'
 return C
 case 'for':
 if(C.real=='list'){if(this.tree.length > 1){
 $_SyntaxError(C,"unparenthesized "+
 "expression before 'for'")}
 C.real='list_comp'}
 else{C.real='gen_expr'}
 C.intervals=[C.start+1]
 C.expression=C.tree
 if(C.yields){C.expression.yields=C.yields
 delete C.yields}
 C.tree=[]
 var comp=new $ComprehensionCtx(C)
 return new $TargetListCtx(new $CompForCtx(comp))}
 return $transition(C.parent,token,value)}else if(C.expect=='id'){switch(C.real){case 'tuple':
 if(token==')'){C.close()
 return C.parent}
 if(token=='eol' && C.implicit===true){C.close()
 return $transition(C.parent,token)}
 break
 case 'gen_expr':
 if(token==')'){C.close()
 return $transition(C.parent,token)}
 break
 case 'list':
 if(token==']'){C.close()
 return C}
 break}
 switch(token){case '=':
 if(C.real=='tuple' &&
 C.implicit===true){C.close()
 C.parent.tree.pop()
 var expr=new $ExprCtx(C.parent,'tuple',false)
 expr.tree=[C]
 C.parent=expr
 return $transition(C.parent,token)}
 break
 case ')':
 break
 case ']':
 if(C.real=='tuple' &&
 C.implicit===true){
 return $transition(C.parent,token,value)}else{break}
 case ',':
 $_SyntaxError(C,'unexpected comma inside list')
 default:
 C.expect=','
 var expr=new $AbstractExprCtx(C,false)
 return $transition(expr,token,value)}}else{return $transition(C.parent,token,value)}}}
 $ListOrTupleCtx.prototype.close=function(){this.closed=true
 for(var i=0,len=this.tree.length;i < len;i++){
 var elt=this.tree[i]
 if(elt.type=="expr" &&
 elt.tree[0].type=="list_or_tuple" &&
 elt.tree[0].real=="tuple" &&
 elt.tree[0].tree.length==1 &&
 elt.tree[0].expect==","){this.tree[i]=elt.tree[0].tree[0]
 this.tree[i].parent=this}}}
 $ListOrTupleCtx.prototype.is_comp=function(){switch(this.real){case 'list_comp':
 case 'gen_expr':
 case 'dict_or_set_comp':
 return true}
 return false}
 $ListOrTupleCtx.prototype.get_src=function(){
 var src=$get_module(this).src
 var scope=$get_scope(this)
 if(scope.comments===undefined){return src}
 scope.comments.forEach(function(comment){var start=comment[0],len=comment[1]
 src=src.substr(0,start)+' '.repeat(len+1)+
 src.substr(start+len+1)})
 return src}
 $ListOrTupleCtx.prototype.bind_ids=function(scope){
 this.tree.forEach(function(item){if(item.type=='id'){$bind(item.value,scope,this)
 item.bound=true}else if(item.type=='expr' && item.tree[0].type=="id"){$bind(item.tree[0].value,scope,this)
 item.tree[0].bound=true}else if(item.type=='expr' && item.tree[0].type=="packed"){var ctx=item.tree[0].tree[0]
 if(ctx.type=='expr' && ctx.tree[0].type=='id'){$bind(ctx.tree[0].value,scope,this)
 ctx.tree[0].bound=true}}else if(item.type=='list_or_tuple' ||
 (item.type=="expr" &&
 item.tree[0].type=='list_or_tuple')){if(item.type=="expr"){item=item.tree[0]}
 item.bind_ids(scope)}},this)}
 $ListOrTupleCtx.prototype.packed_indices=function(){var ixs=[]
 for(var i=0;i < this.tree.length;i++){var t=this.tree[i]
 if(t.type=="expr"){t=t.tree[0]
 if(t.type=="packed" ||
 (t.type=="call" && t.func.type=="packed")){ixs.push(i)}}}
 return ixs}
 $ListOrTupleCtx.prototype.unpack=function(packed){var js="",res
 for(var i=0;i < this.tree.length;i++){if(packed.indexOf(i)>-1){res="_b_.list.$factory("+this.tree[i].to_js()+")"}else{res="["+this.tree[i].to_js()+"]"}
 if(i > 0){res=".concat("+res+")"}
 js+=res}
 return js}
 $ListOrTupleCtx.prototype.to_js=function(){this.js_processed=true
 var scope=$get_scope(this),sc=scope,scope_id=scope.id.replace(/\//g, '_'),
         pos = 0
     var root = $get_module(this),
         module_name = root.module
     switch(this.real) {
         case 'list':
             var packed = this.packed_indices()
             if(packed.length > 0){
                 return '$B.$list(' + this.unpack(packed) + ')'
             }
             return '$B.$list([' + $to_js(this.tree) + '])'
         case 'list_comp':
         case 'gen_expr':
         case 'dict_or_set_comp':
             var src = this.get_src()
             var res1 = [], items = []
             var qesc = new RegExp('"', "g") //to escape double quotes in arguments
 var comments=root.comments
 for(var i=1;i < this.intervals.length;i++){var start=this.intervals[i-1],end=this.intervals[i],txt=src.substring(start,end)
 for(var j=comments.length-1;j >=0;j--){var comment=comments[j]
 if(comment[0]> start && comment[0]< end){
 var pos=comment[0]-start
 txt=txt.substr(0,pos)+
 ' '.repeat(comment[1])+
 txt.substr(pos+comment[1]+1)}}
 txt=txt.replace(/\\\n/g," ")
 items.push(txt)
 var lines=txt.split('\n')
 var res2=[]
 lines.forEach(function(txt){
 if(txt.replace(/ /g,'').length !=0){txt=txt.replace(/\n/g,' ')
 txt=txt.replace(/\\/g,'\\\\')
 txt=txt.replace(qesc,'\\"')
 res2.push('"'+txt+'"')}})
 res1.push('['+res2.join(',')+']')}
 var line_num=$get_node(this).line_num
 switch(this.real){case 'list_comp':
 var lc=$B.$list_comp(items),
 py=lc[0],ix=lc[1],listcomp_name='lc'+$B.lambda_magic+ix,save_pos=$pos,line_info=line_num+','+module_name
 var root=$B.py2js(
 {src:py,is_comp:true,line_info:line_info},module_name,listcomp_name,scope,1)
 var outermost_expr=root.outermost_expr
 if($get_node(this).has_yield){outermost_expr=this.tree[0].tree[0].tree[1]}
 if(outermost_expr===undefined){outermost_expr=root.first_for.tree[1]}
 var outer_most=outermost_expr.to_js()
 $pos=save_pos
 var js=root.to_js()
 root=null
 $B.clear_ns(listcomp_name)
 delete $B.$py_src[listcomp_name]
 js+='return $locals_'+listcomp_name+'["x'+ix+'"]'
 js=`function(expr){${js}})(${outer_most})`
 if(this.is_await){js='async '+js}
 return '('+js
 case 'dict_or_set_comp':
 if(this.expression.length==1){return $B.$gen_expr(module_name,scope,items,line_num,true)}
 return $B.$dict_comp(module_name,scope,items,line_num)}
 return $B.$gen_expr(module_name,scope,items,line_num)
 case 'tuple':
 var packed=this.packed_indices()
 if(packed.length > 0){return '$B.fast_tuple('+this.unpack(packed)+')'}
 if(this.tree.length==1 && this.has_comma===undefined){return this.tree[0].to_js()}
 return '$B.fast_tuple(['+$to_js(this.tree)+'])'}}
 var $NodeCtx=$B.parser.$NodeCtx=function(node){
 this.node=node
 node.C=this
 this.tree=[]
 this.type='node'
 var scope=null
 var tree_node=node
 while(tree_node.parent && tree_node.parent.type !='module'){var ntype=tree_node.parent.C.tree[0].type,_break_flag=false
 switch(ntype){case 'def':
 case 'class':
 case 'generator':
 scope=tree_node.parent
 _break_flag=true}
 if(_break_flag){break}
 tree_node=tree_node.parent}
 if(scope===null){scope=tree_node.parent ||tree_node }
 this.node.locals=clone(scope.binding)
 this.scope=scope}
 $NodeCtx.prototype.toString=function(){return 'node '+this.tree}
 $NodeCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case 'not':
 case 'lambda':
 case '.':
 var expr=new $AbstractExprCtx(C,true)
 return $transition(expr,token,value)
 case 'op':
 switch(value){case '*':
 case '+':
 case '-':
 case '~':
 var expr=new $AbstractExprCtx(C,true)
 return $transition(expr,token,value)}
 break
 case 'async':
 return new $AsyncCtx(C)
 case 'await':
 return new $AbstractExprCtx(new $AwaitCtx(C),true)
 case 'class':
 return new $ClassCtx(C)
 case 'continue':
 return new $ContinueCtx(C)
 case '__debugger__':
 return new $DebuggerCtx(C)
 case 'break':
 return new $BreakCtx(C)
 case 'def':
 return new $DefCtx(C)
 case 'for':
 return new $TargetListCtx(new $ForExpr(C))
 case 'if':
 case 'while':
 return new $AbstractExprCtx(
 new $ConditionCtx(C,token),false)
 case 'elif':
 var previous=$previous(C)
 if(['condition'].indexOf(previous.type)==-1 ||
 previous.token=='while'){$_SyntaxError(C,'elif after '+previous.type)}
 return new $AbstractExprCtx(
 new $ConditionCtx(C,token),false)
 case 'else':
 var previous=$previous(C)
 if(['condition','except','for'].
 indexOf(previous.type)==-1){$_SyntaxError(C,'else after '+previous.type)}
 return new $SingleKwCtx(C,token)
 case 'finally':
 var previous=$previous(C)
 if(['try','except'].indexOf(previous.type)==-1 &&
 (previous.type !='single_kw' ||
 previous.token !='else')){$_SyntaxError(C,'finally after '+previous.type)}
 return new $SingleKwCtx(C,token)
 case 'try':
 return new $TryCtx(C)
 case 'except':
 var previous=$previous(C)
 if(['try','except'].indexOf(previous.type)==-1){$_SyntaxError(C,'except after '+previous.type)}
 return new $ExceptCtx(C)
 case 'assert':
 return new $AbstractExprCtx(
 new $AssertCtx(C),false,true)
 case 'from':
 return new $FromCtx(C)
 case 'import':
 return new $ImportCtx(C)
 case 'global':
 return new $GlobalCtx(C)
 case 'nonlocal':
 return new $NonlocalCtx(C)
 case 'lambda':
 return new $LambdaCtx(C)
 case 'pass':
 return new $PassCtx(C)
 case 'raise':
 return new $AbstractExprCtx(new $RaiseCtx(C),true)
 case 'return':
 return new $AbstractExprCtx(new $ReturnCtx(C),true)
 case 'with':
 return new $AbstractExprCtx(new $WithCtx(C),false)
 case 'yield':
 return new $AbstractExprCtx(new $YieldCtx(C),true)
 case 'del':
 return new $AbstractExprCtx(new $DelCtx(C),true)
 case '@':
 return new $DecoratorCtx(C)
 case ',':
 if(C.tree && C.tree.length==0){$_SyntaxError(C,'token '+token+' after '+C)}
 var first=C.tree[0]
 C.tree=[]
 var implicit_tuple=new $ListOrTupleCtx(C)
 implicit_tuple.real="tuple"
 implicit_tuple.implicit=0
 implicit_tuple.tree.push(first)
 first.parent=implicit_tuple
 return implicit_tuple
 case 'eol':
 if(C.tree.length==0){
 C.node.parent.children.pop()
 return C.node.parent.C}
 return C}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $NodeCtx.prototype.to_js=function(){if(this.js !==undefined){return this.js}
 this.js_processed=true
 if(this.tree.length > 1){var new_node=new $Node()
 var ctx=new $NodeCtx(new_node)
 ctx.tree=[this.tree[1]]
 new_node.indent=node.indent+4
 this.tree.pop()
 node.add(new_node)}
 this.js=""
 if(this.tree[0]){var is_not_def=this.scope.ntype !="def"
 if(this.tree[0].annotation){
 if(is_not_def){if(this.tree[0].type=="expr" &&
 ! this.tree[0].$in_parens &&
 this.tree[0].tree[0].type=="id"){var js=""
 if(this.create_annotations){js+="$locals.__annotations__ = $B.empty_dict();"}
 return js+"_b_.dict.$setitem($locals.__annotations__, '"+
 this.tree[0].tree[0].value+"', "+
 this.tree[0].annotation.to_js()+");"}else if(this.tree[0].type=="def"){
 this.js=this.tree[0].annotation.to_js()+";"}else{
 this.js=""
 this.tree=[]}}else if(this.tree[0].type !="def"){
 this.tree=[]}}else if(this.tree[0].type=="assign" &&
 ! this.tree[0].tree[0].$in_parens &&
 this.tree[0].tree[0].annotation){
 var left=this.tree[0].tree[0],right=this.tree[0].tree[1]
 if(this.create_annotations){this.js+="$locals.__annotations__ = $B.empty_dict();"}
 this.js+="var $value = "+right.to_js()+";"
 this.tree[0].tree.splice(1,1)
 new $RawJSCtx(this.tree[0],"$value")
 if(left.tree[0]&& left.tree[0].type=="id" && is_not_def){this.js+="_b_.dict.$setitem($locals.__annotations__, '"+
 left.tree[0].value+"', "+
 left.annotation.to_js()+");"}else{
 this.js+=$to_js(this.tree)+";"
 if(is_not_def){this.js+=left.annotation.to_js()}
 return this.js}}}
 if(this.node.children.length==0){this.js+=$to_js(this.tree)+';'}else{this.js+=$to_js(this.tree)}
 return this.js}
 var $NodeJS=$B.parser.$NodeJS=function(js){var node=new $Node()
 new $NodeJSCtx(node,js)
 return node}
 var $NodeJSCtx=$B.parser.$NodeJSCtx=function(node,js){
 this.node=node
 node.C=this
 this.type='node_js'
 this.tree=[js]}
 $NodeJSCtx.prototype.toString=function(){return 'js '+js}
 $NodeJSCtx.prototype.to_js=function(){this.js_processed=true
 return this.tree[0]}
 var $NonlocalCtx=$B.parser.$NonlocalCtx=function(C){
 this.type='nonlocal'
 this.parent=C
 this.tree=[]
 this.names={}
 C.tree[C.tree.length]=this
 this.expect='id'
 this.scope=$get_scope(this)
 this.scope.nonlocals=this.scope.nonlocals ||{}
 if(this.scope.C===undefined){$_SyntaxError(C,["nonlocal declaration not allowed at module level"])}}
 $NonlocalCtx.prototype.toString=function(){return 'nonlocal '+this.tree}
 $NonlocalCtx.prototype.add=function(name){if(this.scope.binding[name]=="arg"){$_SyntaxError(C,["name '"+name+"' is parameter and nonlocal"])}
 this.names[name]=[false,$pos]
 this.scope.nonlocals[name]=true}
 $NonlocalCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.expect=='id'){new $IdCtx(C,value)
 C.add(value)
 C.expect=','
 return C}
 break
 case ',':
 if(C.expect==','){C.expect='id'
 return C}
 break
 case 'eol':
 if(C.expect==','){return $transition(C.parent,token)}
 break}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $NonlocalCtx.prototype.transform=function(node,rank){var C=this.parent,pscope=this.scope.parent_block
 if(pscope.C===undefined){$_SyntaxError(C,["no binding for nonlocal '"+
 $B.last(Object.keys(this.names))+"' found"])}else{while(pscope !==undefined && pscope.C !==undefined){for(var name in this.names){if(pscope.binding[name]!==undefined){this.names[name]=[true]}}
 pscope=pscope.parent_block}
 for(var name in this.names){if(!this.names[name][0]){console.log('nonlocal error, C '+C)
 $pos=this.names[name][1]
 $_SyntaxError(C,["no binding for nonlocal '"+
 name+"' found"])}}}}
 $NonlocalCtx.prototype.to_js=function(){this.js_processed=true
 return ''}
 var $NotCtx=$B.parser.$NotCtx=function(C){
 this.type='not'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $NotCtx.prototype.toString=function(){return 'not ('+this.tree+')'}
 $NotCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'in':
 C.parent.parent.tree.pop()
 return new $ExprCtx(new $OpCtx(C.parent,'not_in'),'op',false)
 case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 var expr=new $AbstractExprCtx(C,false)
 return $transition(expr,token,value)
 case 'op':
 var a=value
 if('+'==a ||'-'==a ||'~'==a){var expr=new $AbstractExprCtx(C,false)
 return $transition(expr,token,value)}}
 return $transition(C.parent,token)}
 $NotCtx.prototype.to_js=function(){this.js_processed=true
 return '!$B.$bool('+$to_js(this.tree)+')'}
 var $NumberCtx=$B.parser.$NumberCtx=function(type,C,value){
 this.type=type
 this.value=value
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $NumberCtx.prototype.toString=function(){return this.type+' '+this.value}
 $NumberCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case 'not':
 case 'lambda':
 $_SyntaxError(C,'token '+token+' after '+
 C)}
 return $transition(C.parent,token,value)}
 $NumberCtx.prototype.to_js=function(){this.js_processed=true
 var type=this.type,value=this.value
 if(type=='int'){var v=parseInt(value[1],value[0])
 if(v > $B.min_int && v < $B.max_int){if(this.unary_op){v=eval(this.unary_op+v)}
 return v}else{var v=$B.long_int.$factory(value[1],value[0])
 switch(this.unary_op){case "-":
 v=$B.long_int.__neg__(v)
 break
 case "~":
 v=$B.long_int.__invert__(v)
 break}
 return '{__class__: $B.long_int, value: "'+v.value+
 '", pos: '+v.pos+'}'}}else if(type=="float"){
 if(/^\d+$/.exec(value)||/^\d+\.\d*$/.exec(value)){return '(new Number('+this.value+'))'}
 return '_b_.float.$factory('+value+')'}else if(type=="imaginary"){return '$B.make_complex(0,'+value+')'}}
 var $OpCtx=$B.parser.$OpCtx=function(C,op){
 this.type='op'
 this.op=op
 this.parent=C.parent
 this.tree=[C]
 this.scope=$get_scope(this)
 if(C.type=="expr"){if(['int','float','str'].indexOf(C.tree[0].type)>-1){this.left_type=C.tree[0].type}else if(C.tree[0].type=="id"){var binding=this.scope.binding[C.tree[0].value]
 if(binding){this.left_type=binding.type}}}
 C.parent.tree.pop()
 C.parent.tree.push(this)}
 $OpCtx.prototype.toString=function(){return '(op '+this.op+') ['+this.tree+']'}
 $OpCtx.prototype.transition=function(token,value){var C=this
 if(C.op===undefined){$_SyntaxError(C,['C op undefined '+C])}
 if(C.op.substr(0,5)=='unary'){if(token !='eol'){if(C.parent.type=='assign' ||
 C.parent.type=='return'){
 C.parent.tree.pop()
 var t=new $ListOrTupleCtx(C.parent,'tuple')
 t.tree.push(C)
 C.parent=t
 return t}}
 if(C.tree.length==2 && C.tree[1].type=="expr" &&
 C.tree[1].tree[0].type=="int"){
 C.parent.tree.pop()
 C.parent.tree.push(C.tree[1])
 C.tree[1].parent=C.parent
 C.tree[1].tree[0].unary_op=C.tree[0].op}}
 switch(token){case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 return $transition(new $AbstractExprCtx(C,false),token,value)
 case 'op':
 switch(value){case '+':
 case '-':
 case '~':
 return new $UnaryCtx(C,value)}
 default:
 if(C.tree[C.tree.length-1].type==
 'abstract_expr'){$_SyntaxError(C,'token '+token+' after '+
 C)}}
 return $transition(C.parent,token)}
 $OpCtx.prototype.to_js=function(){this.js_processed=true
 var comps={'==':'eq','!=':'ne','>=':'ge','<=':'le','<':'lt','>':'gt'}
 if(comps[this.op]!==undefined){var method=comps[this.op]
 if(this.tree[0].type=='expr' && this.tree[1].type=='expr'){var t0=this.tree[0].tree[0],t1=this.tree[1].tree[0],js0=t0.to_js(),js1=t1.to_js()
 switch(t1.type){case 'int':
 switch(t0.type){case 'int':
 if(Number.isSafeInteger(t0.value)&&
 Number.isSafeInteger(t1.value)){return js0+this.op+js1}else{return '$B.$getattr('+
 this.tree[0].to_js()+',"__'+
 method+'__")('+
 this.tree[1].to_js()+')'}
 case 'str':
 switch(this.op){case "==":
 return "false"
 case "!=":
 return "true"
 default:
 return '$B.$TypeError("unorderable types: '+
 " int() "+this.op+' str()")'}
 case 'id':
 return '(typeof '+js0+' == "number" ? '+
 js0+this.op+js1+' : $B.rich_comp("__'+
 method+'__",'+this.tree[0].to_js()+
 ','+this.tree[1].to_js()+'))'}
 break;
 case 'str':
 switch(t0.type){case 'str':
 return js0+this.op+js1
 case 'int':
 switch(this.op){case "==":
 return "false"
 case "!=":
 return "true"
 default:
 return '$B.$TypeError("unorderable types: '+
 ' str() '+this.op+' int()")'}
 case 'id':
 return '(typeof '+js0+' == "string" ? '+
 js0+this.op+js1+' : $B.rich_comp("__'+
 method+'__",'+this.tree[0].to_js()+
 ','+this.tree[1].to_js()+'))'}
 break;
 case 'id':
 if(t0.type=='id'){return 'typeof '+js0+'!="object" && typeof '+
 js0+'!="function" && typeof '+js0+
 ' == typeof '+js1+' ? '+js0+this.op+js1+
 ' : $B.rich_comp("__'+method+'__",'+
 this.tree[0].to_js()+','+this.tree[1].to_js()+
 ')'}
 break}}}
 switch(this.op){case 'and':
 var op0=this.tree[0].to_js(),op1=this.tree[1].to_js()
 if(this.wrap !==undefined){
 return '(function(){var '+this.wrap.name+' = '+
 this.wrap.js+';return $B.$test_expr($B.$test_item('+
 op0+') && $B.$test_item('+op1+'))})()'}else{return '$B.$test_expr($B.$test_item('+op0+')&&'+
 '$B.$test_item('+op1+'))'}
 case 'or':
 var res='$B.$test_expr($B.$test_item('+
 this.tree[0].to_js()+')||'
 return res+'$B.$test_item('+this.tree[1].to_js()+'))'
 case 'in':
 return '$B.$is_member('+$to_js(this.tree)+')'
 case 'not_in':
 return '!$B.$is_member('+$to_js(this.tree)+')'
 case 'unary_neg':
 case 'unary_pos':
 case 'unary_inv':
 var op,method
 if(this.op=='unary_neg'){op='-';method='__neg__'}
 else if(this.op=='unary_pos'){op='+';method='__pos__'}
 else{op='~';method='__invert__'}
 if(this.tree[1].type=="expr"){var x=this.tree[1].tree[0]
 switch(x.type){case 'int':
 var v=parseInt(x.value[1],x.value[0])
 if(Number.isSafeInteger(v)){return op+v}
 return '$B.$getattr('+x.to_js()+', "'+
 method+'")()'
 case 'float':
 return '_b_.float.$factory('+op+x.value+')'
 case 'imaginary':
 return '$B.make_complex(0,'+op+x.value+')'}}
 return '$B.$getattr('+this.tree[1].to_js()+',"'+
 method+'")()'
 case 'is':
 return '$B.$is('+this.tree[0].to_js()+', '+
 this.tree[1].to_js()+')'
 case 'is_not':
 return this.tree[0].to_js()+'!=='+this.tree[1].to_js()
 case '+':
 return '$B.add('+this.tree[0].to_js()+', '+
 this.tree[1].to_js()+')'
 case '*':
 case '-':
 var op=this.op,vars=[],has_float_lit=false,scope=$get_scope(this)
 function is_simple(elt){if(elt.type=='expr' && elt.tree[0].type=='int'){return true}else if(elt.type=='expr' &&
 elt.tree[0].type=='float'){has_float_lit=true
 return true}else if(elt.type=='expr' &&
 elt.tree[0].type=='list_or_tuple' &&
 elt.tree[0].real=='tuple' &&
 elt.tree[0].tree.length==1 &&
 elt.tree[0].tree[0].type=='expr'){return is_simple(elt.tree[0].tree[0].tree[0])}else if(elt.type=='expr' && elt.tree[0].type=='id'){var _var=elt.tree[0].to_js()
 if(vars.indexOf(_var)==-1){vars.push(_var)}
 return true}else if(elt.type=='op' &&
 ['*','+','-'].indexOf(elt.op)>-1){for(var i=0;i < elt.tree.length;i++){if(!is_simple(elt.tree[i])){return false}}
 return true}
 return false}
 function get_type(ns,v){var t
 if(['int','float','str'].indexOf(v.type)>-1){t=v.type}else if(v.type=='id' && ns[v.value]){t=ns[v.value].type}
 return t}
 var e0=this.tree[0],e1=this.tree[1]
 if(is_simple(this)){var v0=this.tree[0].tree[0],v1=this.tree[1].tree[0]
 if(vars.length==0 && !has_float_lit){
 return this.simple_js()}else if(vars.length==0){
 return 'new Number('+this.simple_js()+')'}else{
 var ns=scope.binding,t0=get_type(ns,v0),t1=get_type(ns,v1)
 if((t0=='float' && t1=='float')||
 (this.op=='+' && t0=='str' && t1=='str')){this.result_type=t0
 return v0.to_js()+this.op+v1.to_js()}else if(['int','float'].indexOf(t0)>-1 &&
 ['int','float'].indexOf(t1)>-1){if(t0=='int' && t1=='int'){this.result_type='int'}else{this.result_type='float'}
 switch(this.op){case '-':
 return '$B.sub('+v0.to_js()+','+
 v1.to_js()+')'
 case '*':
 return '$B.mul('+v0.to_js()+','+
 v1.to_js()+')'}}
 var tests=[],tests1=[],pos=0
 vars.forEach(function(_var){
 tests.push('typeof '+_var+
 '.valueOf() == "number"')
 tests1.push('typeof '+_var+' == "number"')})
 var res=[tests.join(' && ')+' ? ']
 res.push('('+tests1.join(' && ')+' ? ')
 res.push(this.simple_js())
 res.push(' : new Number('+this.simple_js()+')')
 res.push(')')
 var t0=this.tree[0].to_js(),t1=this.tree[1].to_js()
 if(this.op=='+'){res.push(' : (typeof '+t0+
 ' == "string" && typeof '+t1+
 ' == "string") ? '+t0+'+'+t1)}
 res.push(': $B.rich_op("'+$operators[this.op]+'",'+
 t0+','+t1+')')
 return '('+res.join('')+')'}}
 if(comps[this.op]!==undefined){return '$B.rich_comp("__'+$operators[this.op]+'__",'+
 e0.to_js()+','+e1.to_js()+')'}else{return '$B.rich_op("'+$operators[this.op]+'", '+
 e0.to_js()+', '+e1.to_js()+')'}
 default:
 if(comps[this.op]!==undefined){return '$B.rich_comp("__'+$operators[this.op]+'__",'+
 this.tree[0].to_js()+','+this.tree[1].to_js()+')'}else{return '$B.rich_op("'+$operators[this.op]+'", '+
 this.tree[0].to_js()+', '+this.tree[1].to_js()+
 ')'}}}
 $OpCtx.prototype.simple_js=function(){var op=this.op
 function sjs(elt){if(elt.type=='op'){return elt.simple_js()}else if(elt.type=='expr' && elt.tree[0].type=='list_or_tuple'
 && elt.tree[0].real=='tuple'
 && elt.tree[0].tree.length==1
 && elt.tree[0].tree[0].type=='expr'){return '('+elt.tree[0].tree[0].tree[0].simple_js()+')'}else{return elt.tree[0].to_js()}}
 if(op=='+'){return '$B.add('+sjs(this.tree[0])+','+
 sjs(this.tree[1])+')'}else if(op=='-'){return '$B.sub('+sjs(this.tree[0])+','+
 sjs(this.tree[1])+')'}else if(op=='*'){return '$B.mul('+sjs(this.tree[0])+','+
 sjs(this.tree[1])+')'}else if(op=='/'){return '$B.div('+sjs(this.tree[0])+','+
 sjs(this.tree[1])+')'}else{return sjs(this.tree[0])+op+sjs(this.tree[1])}}
 var $PackedCtx=$B.parser.$PackedCtx=function(C){
 this.type='packed'
 if(C.parent.type=='list_or_tuple' &&
 C.parent.parent.type=="node"){
 for(var i=0;i < C.parent.tree.length;i++){var child=C.parent.tree[i]
 if(child.type=='expr' && child.tree.length > 0
 && child.tree[0].type=='packed'){$_SyntaxError(C,["two starred expressions in assignment"])}}}
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $PackedCtx.prototype.toString=function(){return '(packed) '+this.tree}
 $PackedCtx.prototype.transition=function(token,value){var C=this
 if(C.tree.length > 0 && token=="["){
 return $transition(C.tree[0],token,value)}
 if(token=='id'){var expr=new $AbstractExprCtx(C,false)
 expr.packed=true
 C.parent.expect=','
 var id=$transition(expr,token,value)
 return id}else if(token=="["){C.parent.expect=','
 return new $ListOrTupleCtx(C,"list")}else if(token=="("){C.parent.expect=','
 return new $ListOrTupleCtx(C,"tuple")}else if(token=="]"){return $transition(C.parent,token,value)}else if(token=="{"){C.parent.expect=','
 return new $DictOrSetCtx(C)}
 return C.parent.transition(token,C)}
 $PackedCtx.prototype.to_js=function(){this.js_processed=true
 return $to_js(this.tree)}
 var $PassCtx=$B.parser.$PassCtx=function(C){
 this.type='pass'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $PassCtx.prototype.toString=function(){return '(pass)'}
 $PassCtx.prototype.transition=function(token,value){var C=this
 if(token=='eol'){return C.parent}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $PassCtx.prototype.to_js=function(){this.js_processed=true
 return 'void(0)'}
 var $RaiseCtx=$B.parser.$RaiseCtx=function(C){
 this.type='raise'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 this.scope_type=$get_scope(this).ntype}
 $RaiseCtx.prototype.toString=function(){return ' (raise) '+this.tree}
 $RaiseCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.tree.length==0){return new $IdCtx(new $ExprCtx(C,'exc',false),value)}
 break
 case 'from':
 if(C.tree.length > 0){return new $AbstractExprCtx(C,false)}
 break
 case 'eol':
 return $transition(C.parent,token)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $RaiseCtx.prototype.to_js=function(){this.js_processed=true
 var exc=this.tree.length==0 ? '' :this.tree[0].to_js()
 return '$B.$raise('+exc+')'}
 var $RawJSCtx=$B.parser.$RawJSCtx=function(C,js){this.type="raw_js"
 C.tree[C.tree.length]=this
 this.parent=C
 this.js=js}
 $RawJSCtx.prototype.toString=function(){return '(js) '+this.js}
 $RawJSCtx.prototype.transition=function(token,value){var C=this}
 $RawJSCtx.prototype.to_js=function(){this.js_processed=true
 return this.js}
 var $ReturnCtx=$B.parser.$ReturnCtx=function(C){
 this.type='return'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 this.scope=$get_scope(this)
 if(["def","generator"].indexOf(this.scope.ntype)==-1){$_SyntaxError(C,["'return' outside function"])}
 var node=this.node=$get_node(this)
 while(node.parent){if(node.parent.C){var elt=node.parent.C.tree[0]
 if(elt.type=='for'){elt.has_return=true
 break}else if(elt.type=='try'){elt.has_return=true}else if(elt.type=='single_kw' && elt.token=='finally'){elt.has_return=true}}
 node=node.parent}}
 $ReturnCtx.prototype.toString=function(){return 'return '+this.tree}
 $ReturnCtx.prototype.transition=function(token,value){var C=this
 return $transition(C.parent,token)}
 $ReturnCtx.prototype.to_js=function(){this.js_processed=true
 if(this.tree.length==1 && this.tree[0].type=='abstract_expr'){
 this.tree.pop()
 new $IdCtx(new $ExprCtx(this,'rvalue',false),'None')}
 var scope=this.scope
 if(scope.ntype=='generator'){return 'var $res = '+$to_js(this.tree)+'; $B.leave_frame({$locals});'+
 'return $B.generator_return($res)'}
 var indent='    '.repeat(this.node.indent-1)
 var js='var $res = '+$to_js(this.tree)+';\n'+indent+
 'if($locals.$f_trace !== _b_.None){$B.trace_return($res)}\n'+indent+
 '$B.leave_frame'
 if(scope.id.substr(0,6)=='$exec_'){js+='_exec'}
 js+='({$locals});\n'+indent+'return $res'
 return js}
 var $SingleKwCtx=$B.parser.$SingleKwCtx=function(C,token){
 this.type='single_kw'
 this.token=token
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this
 if(token=="else"){var node=C.node
 var pnode=node.parent
 for(var rank=0;rank < pnode.children.length;rank++){if(pnode.children[rank]===node){break}}
 var pctx=pnode.children[rank-1].C
 if(pctx.tree.length > 0){var elt=pctx.tree[0]
 if(elt.type=='for' ||
 elt.type=='asyncfor' ||
 (elt.type=='condition' && elt.token=='while')){elt.has_break=true
 elt.else_node=$get_node(this)
 this.loop_num=elt.loop_num}}}}
 $SingleKwCtx.prototype.toString=function(){return this.token}
 $SingleKwCtx.prototype.transition=function(token,value){var C=this
 if(token==':'){return $BodyCtx(C)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $SingleKwCtx.prototype.transform=function(node,rank){
 if(this.token=='finally'){var scope=$get_scope(this)
 node.insert(0,$NodeJS('var $exit;'+
 'if($B.frames_stack.length < $stack_length){'+
 '$exit = true;'+
 '$B.frames_stack.push($top_frame)'+
 '}')
 )
 var scope_id=scope.id.replace(/\./g,'_')
 var last_child=node.children[node.children.length-1]
 if(last_child.C.tree[0].type !="return"){node.add($NodeJS('if($exit){$B.leave_frame({$locals})}'))}}}
 $SingleKwCtx.prototype.to_js=function(){this.js_processed=true
 if(this.token=='finally'){return this.token}
 if(this.loop_num !==undefined){var scope=$get_scope(this)
 var res='if($locals_'+scope.id.replace(/\./g,'_')
 return res+'["$no_break'+this.loop_num+'"])'}
 return this.token}
 var $SliceCtx=$B.parser.$SliceCtx=function(C){
 this.type='slice'
 this.parent=C
 this.tree=C.tree.length > 0 ?[C.tree.pop()]:[]
 C.tree.push(this)}
 $SliceCtx.prototype.transition=function(token,value){var C=this
 if(token==":"){return new $AbstractExprCtx(C,false)}
 return $transition(C.parent,token,value)}
 $SliceCtx.prototype.to_js=function(){for(var i=0;i < this.tree.length;i++){if(this.tree[i].type=="abstract_expr"){this.tree[i].to_js=function(){return "_b_.None"}}}
 return "_b_.slice.$factory("+$to_js(this.tree)+")"}
 var $StarArgCtx=$B.parser.$StarArgCtx=function(C){
 this.type='star_arg'
 this.parent=C
 this.tree=[]
 C.tree[C.tree.length]=this}
 $StarArgCtx.prototype.toString=function(){return '(star arg) '+this.tree}
 $StarArgCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.parent.type=="target_list"){C.tree.push(value)
 C.parent.expect=','
 return C.parent}
 return $transition(new $AbstractExprCtx(C,false),token,value)
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case 'not':
 case 'lambda':
 return $transition(new $AbstractExprCtx(C,false),token,value)
 case ',':
 case ')':
 if(C.tree.length==0){$_SyntaxError(C,"unnamed star argument")}
 return $transition(C.parent,token)
 case ':':
 if(C.parent.parent.type=='lambda'){return $transition(C.parent.parent,token)}}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $StarArgCtx.prototype.to_js=function(){this.js_processed=true
 return '{$nat:"ptuple",arg:'+$to_js(this.tree)+'}'}
 var $StringCtx=$B.parser.$StringCtx=function(C,value){
 this.type='str'
 this.parent=C
 this.tree=[value]
 C.tree[C.tree.length]=this
 this.raw=false}
 $StringCtx.prototype.toString=function(){return 'string '+(this.tree ||'')}
 $StringCtx.prototype.transition=function(token,value){var C=this
 switch(token){case '[':
 return new $AbstractExprCtx(new $SubCtx(C.parent),false)
 case '(':
 C.parent.tree[0]=C
 return new $CallCtx(C.parent)
 case 'str':
 C.tree.push(value)
 return C}
 return $transition(C.parent,token,value)}
 $StringCtx.prototype.to_js=function(){this.js_processed=true
 var res='',type=null,scope=$get_scope(this),has_surrogate=false
 function _has_surrogate(s){for(var i=0;i < s.length;i++){try{code=s.charCodeAt(i)}catch(err){console.log("err for s",s)
 throw err}
 if(code >=0xD800 && code <=0xDBFF){return true}}
 return false}
 function fstring(parsed_fstring){
 var elts=[]
 for(var i=0;i < parsed_fstring.length;i++){if(parsed_fstring[i].type=='expression'){var expr=parsed_fstring[i].expression
 var pos=0,br_stack=[],parts=[expr]
 while(pos < expr.length){var car=expr.charAt(pos)
 if(car==":" && br_stack.length==0){parts=[expr.substr(0,pos),expr.substr(pos+1)]
 break}else if("{[(".indexOf(car)>-1){br_stack.push(car)}else if(")]}".indexOf(car)>-1){br_stack.pop()}
 pos++}
 expr=parts[0]
 var save_pos=$pos
 var expr_node=$B.py2js(expr,scope.module,scope.id,scope)
 expr_node.to_js()
 $pos=save_pos
 for(var j=0;j < expr_node.children.length;j++){var node=expr_node.children[j]
 if(node.C.tree && node.C.tree.length==1 &&
 node.C.tree[0]=="try"){
 for(var k=0;k < node.children.length;k++){
 if(node.children[k].is_line_num){continue}
 var expr1=node.children[k].js
 while("\n;".indexOf(expr1.charAt(expr1.length-1))>-1){expr1=expr1.substr(0,expr1.length-1)}
 break}
 break}}
 switch(parsed_fstring[i].conversion){case "a":
 expr1='_b_.ascii('+expr1+')'
 break
 case "r":
 expr1='_b_.repr('+expr1+')'
 break
 case "s":
 expr1='_b_.str.$factory('+expr1+')'
 break}
 var fmt=parts[1]
 if(fmt !==undefined){
 var parsed_fmt=$B.parse_fstring(fmt)
 if(parsed_fmt.length > 1){fmt=fstring(parsed_fmt)}else{fmt="'"+fmt+"'"}
 var res1="_b_.str.format('{0:' + "+
 fmt+" + '}', "+expr1+")"
 elts.push(res1)}else{if(parsed_fstring[i].conversion===null){expr1='_b_.str.$factory('+expr1+')'}
 elts.push(expr1)}}else{var re=new RegExp("'","g")
 var elt=parsed_fstring[i].replace(re,"\\'")
 .replace(/\n/g,"\\n")
 has_surrogate=has_surrogate ||_has_surrogate(elt)
 elts.push("'"+elt+"'")}}
 return elts.join(' + ')}
 function prepare(value){value=value.replace(/\n/g,'\\n\\\n')
 value=value.replace(/\\U([A-Fa-f0-9]{8})/gm,function(mo){return String.fromCharCode("0x"+mo.slice(2))})
 return value}
 for(var i=0;i < this.tree.length;i++){if(this.tree[i].type=="call"){
 var js='(function(){throw _b_.TypeError.$factory("'+"'str'"+
 ' object is not callable")}())'
 return js}else{var value=this.tree[i],is_fstring=Array.isArray(value),is_bytes=false
 if(!is_fstring){is_bytes=value.charAt(0)=='b'}
 if(type==null){type=is_bytes
 if(is_bytes){res+='_b_.bytes.$new(_b_.bytes, '}}else if(type !=is_bytes){return '$B.$TypeError("can\'t concat bytes to str")'}
 if(!is_bytes){if(is_fstring){res+=fstring(value)}else{has_surrogate=has_surrogate ||_has_surrogate(value)
 res+=prepare(value)}}else{res+=prepare(value.substr(1))}
 if(i < this.tree.length-1){res+='+'}}}
 if(is_bytes){res+=',"ISO-8859-1")'}
 if(res.length==0){res='""'}
 if(has_surrogate){res="_b_.str.$surrogate.$factory("+res+")"}
 return res}
 var $SubCtx=$B.parser.$SubCtx=function(C){
 this.type='sub'
 this.func='getitem' 
 this.value=C.tree[0]
 C.tree.pop()
 C.tree[C.tree.length]=this
 this.parent=C
 this.tree=[]}
 $SubCtx.prototype.toString=function(){return '(sub) (value) '+this.value+' (tree) '+this.tree}
 $SubCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 case 'imaginary':
 case 'int':
 case 'float':
 case 'str':
 case 'bytes':
 case '[':
 case '(':
 case '{':
 case '.':
 case 'not':
 case 'lambda':
 var expr=new $AbstractExprCtx(C,false)
 return $transition(expr,token,value)
 case ']':
 if(C.parent.packed){return C.parent.tree[0]}
 if(C.tree[0].tree.length > 0){return C.parent}
 break
 case ':':
 return new $AbstractExprCtx(new $SliceCtx(C),false)
 case ',':
 return new $AbstractExprCtx(C,false)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $SubCtx.prototype.to_js=function(){this.js_processed=true
 if(this.func=='getitem' && this.value.type=='id'){var type=$get_node(this).locals[this.value.value],val=this.value.to_js()
 if(type=='list' ||type=='tuple'){if(this.tree.length==1){return '$B.list_key('+val+
 ', '+this.tree[0].to_js()+')'}else if(this.tree.length==2){return '$B.list_slice('+val+
 ', '+(this.tree[0].to_js()||"null")+','+
 (this.tree[1].to_js()||"null")+')'}else if(this.tree.length==3){return '$B.list_slice_step('+val+
 ', '+(this.tree[0].to_js()||"null")+','+
 (this.tree[1].to_js()||"null")+','+
 (this.tree[2].to_js()||"null")+')'}}}
 if(this.func=='getitem' && this.tree.length==1){if(this.tree[0].type=="slice"){return `$B.getitem_slice(${this.value.to_js()},`+
 `${this.tree[0].to_js()})`}
 return '$B.$getitem('+this.value.to_js()+','+
 this.tree[0].to_js()+')'}
 var res='',shortcut=false
 if(this.func !=='delitem' &&
 this.tree.length==1 && !this.in_sub){var expr='',x=this
 shortcut=true
 while(x.value.type=='sub'){expr+='['+x.tree[0].to_js()+']'
 x.value.in_sub=true
 x=x.value}
 var subs=x.value.to_js()+'['+x.tree[0].to_js()+']'+
 '((Array.isArray('+x.value.to_js()+') || typeof '+
 x.value.to_js()+' == "string") && '+subs+
 ' !== undefined ?'+subs+expr+' : '}
 var val=this.value.to_js()
 res+='$B.$getattr('+val+',"__'+this.func+'__")('
 if(this.tree.length==1){res+=this.tree[0].to_js()+')'}else{var res1=[]
 this.tree.forEach(function(elt){if(elt.type=='abstract_expr'){res1.push('_b_.None')}
 else{res1.push(elt.to_js())}})
 res+='_b_.tuple.$factory(['+res1.join(',')+']))'}
 return shortcut ? res+')' :res}
 var $TargetListCtx=$B.parser.$TargetListCtx=function(C){
 this.type='target_list'
 this.parent=C
 this.tree=[]
 this.expect='id'
 C.tree[C.tree.length]=this}
 $TargetListCtx.prototype.toString=function(){return '(target list) '+this.tree}
 $TargetListCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.expect=='id'){C.expect=','
 return new $IdCtx(
 new $ExprCtx(C,'target',false),value)}
 case 'op':
 if(C.expect=='id' && value=='*'){
 return new $PackedCtx(C)}
 case '(':
 case '[':
 if(C.expect=='id'){C.expect=','
 return new $ListOrTupleCtx(C,token=='(' ? 'tuple' :'list')}
 case ')':
 case ']':
 if(C.expect==','){return C.parent}
 case ',':
 if(C.expect==','){C.expect='id'
 return C}}
 if(C.expect==','){return $transition(C.parent,token,value)}else if(token=='in'){
 return $transition(C.parent,token,value)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $TargetListCtx.prototype.to_js=function(){this.js_processed=true
 return $to_js(this.tree)}
 var $TernaryCtx=$B.parser.$TernaryCtx=function(C){
 this.type='ternary'
 this.parent=C.parent
 C.parent.tree.pop()
 C.parent.tree.push(this)
 C.parent=this
 this.tree=[C]}
 $TernaryCtx.prototype.toString=function(){return '(ternary) '+this.tree}
 $TernaryCtx.prototype.transition=function(token,value){var C=this
 if(token=='else'){C.in_else=true
 return new $AbstractExprCtx(C,false)}else if(! C.in_else){$_SyntaxError(C,'token '+token+' after '+C)}else if(token==","){
 if(["assign","augm_assign","node","return"].
 indexOf(C.parent.type)>-1){C.parent.tree.pop()
 var t=new $ListOrTupleCtx(C.parent,'tuple')
 t.implicit=true
 t.tree[0]=C
 C.parent=t
 t.expect="id"
 return t}}
 return $transition(C.parent,token,value)}
 $TernaryCtx.prototype.to_js=function(){this.js_processed=true
 var res='$B.$bool('+this.tree[1].to_js()+') ? ' 
 res+=this.tree[0].to_js()+' : ' 
 return res+this.tree[2].to_js()}
 var $TryCtx=$B.parser.$TryCtx=function(C){
 this.type='try'
 this.parent=C
 C.tree[C.tree.length]=this}
 $TryCtx.prototype.toString=function(){return '(try) '}
 $TryCtx.prototype.transition=function(token,value){var C=this
 if(token==':'){return $BodyCtx(C)}
 $_SyntaxError(C,'token '+token+' after '+C)}
 $TryCtx.prototype.transform=function(node,rank){if(node.parent.children.length==rank+1){$_SyntaxError(C,["unexpected EOF while parsing"])}else{var next_ctx=node.parent.children[rank+1].C.tree[0]
 switch(next_ctx.type){case 'except':
 case 'finally':
 case 'single_kw':
 break
 default:
 $_SyntaxError(C,"no clause after try")}}
 var scope=$get_scope(this)
 var error_name=create_temp_name('$err')
 var failed_name="$locals."+create_temp_name('$failed')
 var js=failed_name+' = false;\n'+
 ' '.repeat(node.indent+4)+'try'
 new $NodeJSCtx(node,js)
 node.has_return=this.has_return
 var catch_node=$NodeJS('catch('+error_name+')')
 node.parent.insert(rank+1,catch_node)
 catch_node.add($NodeJS("$B.set_exc("+error_name+")"))
 catch_node.add($NodeJS("if($locals.$f_trace !== _b_.None)"+
 "{$locals.$f_trace = $B.trace_exception()}"))
 catch_node.add(
 $NodeJS(failed_name+' = true;'+
 '$B.pmframe = $B.last($B.frames_stack);'+
 'if(false){}')
 )
 var pos=rank+2,has_default=false,
 has_else=false,
 has_finally=false
 while(1){if(pos==node.parent.children.length){break}
 var ctx=node.parent.children[pos].C.tree[0]
 if(ctx===undefined){
 break}
 if(ctx.type=='except'){
 if(has_else){$_SyntaxError(C,"'except' or 'finally' after 'else'")}
 if(has_finally){$_SyntaxError(C,"'except' after 'finally'")}
 ctx.error_name=error_name
 if(ctx.tree.length > 0 && ctx.tree[0].alias !==null
 && ctx.tree[0].alias !==undefined){
 var alias=ctx.tree[0].alias
 node.parent.children[pos].insert(0,$NodeJS('$locals["'+alias+'"] = $B.exception('+
 error_name+')')
 )}
 catch_node.insert(catch_node.children.length,node.parent.children[pos])
 if(ctx.tree.length==0){if(has_default){$_SyntaxError(C,'more than one except: line')}
 has_default=true}
 node.parent.children.splice(pos,1)}else if(ctx.type=='single_kw' && ctx.token=='finally'){has_finally=true
 var finally_node=node.parent.children[pos]
 pos++}else if(ctx.type=='single_kw' && ctx.token=='else'){if(has_else){$_SyntaxError(C,"more than one 'else'")}
 if(has_finally){$_SyntaxError(C,"'else' after 'finally'")}
 has_else=true
 var else_body=node.parent.children[pos]
 node.parent.children.splice(pos,1)}else{break}}
 if(!has_default){
 var new_node=new $Node(),ctx=new $NodeCtx(new_node)
 catch_node.insert(catch_node.children.length,new_node)
 new $SingleKwCtx(ctx,'else')
 new_node.add($NodeJS('throw '+error_name))}
 if(has_else){var else_node=new $Node()
 else_node.module=scope.module
 new $NodeJSCtx(else_node,'if(!'+failed_name+')')
 else_body.children.forEach(function(elt){else_node.add(elt)})
 if(has_finally){finally_node.insert(0,else_node)}else{node.parent.insert(pos,else_node)}
 pos++}
 $loop_num++}
 $TryCtx.prototype.to_js=function(){this.js_processed=true
 return 'try'}
 var $UnaryCtx=$B.parser.$UnaryCtx=function(C,op){
 this.type='unary'
 this.op=op
 this.parent=C
 C.tree[C.tree.length]=this}
 $UnaryCtx.prototype.toString=function(){return '(unary) '+this.op}
 $UnaryCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'int':
 case 'float':
 case 'imaginary':
 var expr=C.parent
 C.parent.parent.tree.pop()
 if(C.op=='-'){value="-"+value}
 else if(C.op=='~'){value=~value}
 return $transition(C.parent.parent,token,value)
 case 'id':
 C.parent.parent.tree.pop()
 var expr=new $ExprCtx(C.parent.parent,'call',false)
 var expr1=new $ExprCtx(expr,'id',false)
 new $IdCtx(expr1,value)
 var repl=new $AttrCtx(expr)
 if(C.op=='+'){repl.name='__pos__'}
 else if(C.op=='-'){repl.name='__neg__'}
 else{repl.name='__invert__'}
 return expr1
 case 'op':
 if('+'==value ||'-'==value){if(C.op===value){C.op='+'}
 else{C.op='-'}
 return C}}
 return $transition(C.parent,token,value)}
 this.to_js=function(){this.js_processed=true
 return this.op}
 var $WithCtx=$B.parser.$WithCtx=function(C){
 this.type='with'
 this.parent=C
 C.tree[C.tree.length]=this
 this.tree=[]
 this.expect='as'
 this.scope=$get_scope(this)}
 $WithCtx.prototype.toString=function(){return '(with) '+this.tree}
 $WithCtx.prototype.transition=function(token,value){var C=this
 switch(token){case 'id':
 if(C.expect=='id'){C.expect='as'
 return $transition(
 new $AbstractExprCtx(C,false),token,value)}
 $_SyntaxError(C,'token '+token+' after '+C)
 case 'as':
 return new $AbstractExprCtx(new $AliasCtx(C))
 case ':':
 switch(C.expect){case 'id':
 case 'as':
 case ':':
 return $BodyCtx(C)}
 break
 case '(':
 if(C.expect=='id' && C.tree.length==0){C.parenth=true
 return C}else if(C.expect=='alias'){C.expect=':'
 return new $TargetListCtx(C,false)}
 break
 case ')':
 if(C.expect==',' ||C.expect=='as'){C.expect=':'
 return C}
 break
 case ',':
 if(C.parenth !==undefined &&
 C.has_alias===undefined &&
 (C.expect==',' ||C.expect=='as')){C.expect='id'
 return C}else if(C.expect=='as'){C.expect='id'
 return C}else if(C.expect==':'){C.expect='id'
 return C}
 break}
 $_SyntaxError(C,'token '+token+' after '+
 C.expect)}
 $WithCtx.prototype.set_alias=function(ctx){var ids=[]
 if(ctx.type=="id"){ids=[ctx]}else if(ctx.type=="list_or_tuple"){
 ctx.tree.forEach(function(expr){if(expr.type=="expr" && expr.tree[0].type=="id"){ids.push(expr.tree[0])}})}
 for(var i=0,len=ids.length;i < len;i++){var id_ctx=ids[i]
 $bind(id_ctx.value,this.scope,this)
 id_ctx.bound=true
 if(this.scope.ntype !=='module'){
 this.scope.C.tree[0].locals.push(id_ctx.value)}}}
 $WithCtx.prototype.transform=function(node,rank){while(this.tree.length > 1){
 var suite=node.children,item=this.tree.pop(),new_node=new $Node(),ctx=new $NodeCtx(new_node),with_ctx=new $WithCtx(ctx)
 item.parent=with_ctx
 with_ctx.tree=[item]
 with_ctx.async=this.async
 suite.forEach(function(elt){new_node.add(elt)})
 node.children=[new_node]}
 if(this.transformed){return}
 this.prefix=""
 if(this.tree.length > 1){var nw=new $Node(),ctx=new $NodeCtx(nw)
 nw.parent=node
 nw.module=node.module
 nw.indent=node.indent+4
 var wc=new $WithCtx(ctx)
 wc.async=this.async
 wc.tree=this.tree.slice(1)
 node.children.forEach(function(elt){nw.add(elt)})
 node.children=[nw]
 this.transformed=true
 return}
 if(this.async){return this.transform_async(node,rank)}
 var top_try_node=$NodeJS("try")
 node.parent.insert(rank+1,top_try_node)
 var num=this.num=$loop_num++
 top_try_node.ctx_manager_num=num
 this.cm_name=this.prefix+'$ctx_manager'+num
 this.cmexit_name=this.prefix+'$ctx_manager_exit'+num
 this.exc_name=this.prefix+'$exc'+num
 this.err_name='$err'+num
 this.val_name='$value'+num
 this.yield_name=this.prefix+'$yield'+num
 if(this.tree[0].alias===null){this.tree[0].alias='$temp'}
 if(this.tree[0].type=='expr' &&
 this.tree[0].tree[0].type=='list_or_tuple'){if(this.tree[1].type !='expr' ||
 this.tree[1].tree[0].type !='list_or_tuple'){$_SyntaxError(C)}
 if(this.tree[0].tree[0].tree.length !=
 this.tree[1].tree[0].tree.length){$_SyntaxError(C,['wrong number of alias'])}
 var ids=this.tree[0].tree[0].tree,alias=this.tree[1].tree[0].tree
 this.tree.shift()
 this.tree.shift()
 for(var i=ids.length-1;i >=0;i--){ids[i].alias=alias[i].value
 this.tree.splice(0,0,ids[i])}}
 var block=node.children 
 node.children=[]
 var try_node=new $Node()
 new $NodeJSCtx(try_node,'try')
 top_try_node.add(try_node)
 if(this.tree[0].alias){var alias=this.tree[0].alias.tree[0].tree[0].value
 try_node.add($NodeJS('$locals'+'["'+alias+'"] = '+
 this.val_name))}
 block.forEach(function(elt){try_node.add(elt)})
 var catch_node=new $Node()
 new $NodeJSCtx(catch_node,'catch('+this.err_name+')')
 var js=this.exc_name+' = false;'+this.err_name+
 ' = $B.exception('+this.err_name+', true)\n'+
 ' '.repeat(node.indent+4)+
 'var $b = '+this.cmexit_name+'('+
 this.err_name+'.__class__,'+
 this.err_name+','+
 '$B.$getattr('+this.err_name+', "__traceback__"));'
 if(this.scope.ntype=="generator"){js+='$B.set_cm_in_generator('+this.cmexit_name+');'}
 js+='if(!$B.$bool($b)){throw '+this.err_name+'}'
 catch_node.add($NodeJS(js))
 top_try_node.add(catch_node)
 var finally_node=new $Node()
 new $NodeJSCtx(finally_node,'finally')
 finally_node.C.type='single_kw'
 finally_node.C.token='finally'
 finally_node.C.in_ctx_manager=true
 finally_node.is_except=true
 finally_node.in_ctx_manager=true
 var js='if('+this.exc_name
 js+='){'+this.cmexit_name+'(_b_.None, _b_.None, _b_.None);'
 if(this.scope.ntype=="generator"){js+='delete '+this.cmexit_name}
 js+='};'
 finally_node.add($NodeJS(js))
 node.parent.insert(rank+2,finally_node)
 this.transformed=true}
 $WithCtx.prototype.transform_async=function(node,rank){
 var scope=$get_scope(this),expr=this.tree[0],alias=this.tree[0].alias
 var new_nodes=[]
 var num=this.num=$loop_num++
 this.cm_name='$ctx_manager'+num,this.cmexit_name='$ctx_manager_exit'+num
 this.exc_name='$exc'+num
 var cmtype_name='$ctx_mgr_type'+num,cmenter_name='$ctx_manager_enter'+num,err_name='$err'+num
 var js='var '+this.cm_name+' = '+expr.to_js()+','
 new_nodes.push($NodeJS(js))
 new_nodes.push($NodeJS('    '+cmtype_name+
 ' = _b_.type.$factory('+this.cm_name+'),'))
 new_nodes.push($NodeJS('    '+this.cmexit_name+
 ' = $B.$call($B.$getattr('+cmtype_name+', "__aexit__")),'))
 new_nodes.push($NodeJS('    '+cmenter_name+
 ' = $B.$call($B.$getattr('+cmtype_name+', "__aenter__"))'+
 '('+this.cm_name+'),'))
 new_nodes.push($NodeJS("    "+this.exc_name+" = false"))
 js=""
 if(alias){if(alias.tree[0].tree[0].type !="list_or_tuple"){var js=alias.tree[0].to_js()+' = '+
 'await ($B.promise('+cmenter_name+'))'
 new_nodes.push($NodeJS(js))}else{
 var new_node=new $Node(),ctx=new $NodeCtx(new_node),expr=new $ExprCtx(ctx,"left",false)
 expr.tree.push(alias.tree[0].tree[0])
 alias.tree[0].tree[0].parent=expr
 var assign=new $AssignCtx(expr)
 new $RawJSCtx(assign,'await ($B.promise('+
 cmenter_name+'))')
 new_nodes.push(new_node)}}else{new_nodes.push($NodeJS('await ($B.promise('+cmenter_name+'))'))}
 var try_node=new $NodeJS('try')
 node.children.forEach(function(child){try_node.add(child)})
 new_nodes.push(try_node)
 var catch_node=new $NodeJS('catch(err)')
 new_nodes.push(catch_node)
 catch_node.add($NodeJS(this.exc_name+' = true'))
 catch_node.add($NodeJS('var '+err_name+
 ' = $B.imported["_sys"].exc_info()'))
 var if_node=$NodeJS('if(! await ($B.promise('+
 this.cmexit_name+'('+this.cm_name+', '+err_name+'[0], '+
 err_name+'[1], '+err_name+'[2]))))')
 catch_node.add(if_node)
 if_node.add($NodeJS('$B.$raise()'))
 var else_node=$NodeJS('if(! '+this.exc_name+')')
 new_nodes.push(else_node)
 else_node.add($NodeJS('await ($B.promise('+this.cmexit_name+'('+
 this.cm_name+', _b_.None, _b_.None, _b_.None)))'))
 node.parent.children.splice(rank,1)
 for(var i=new_nodes.length-1;i >=0;i--){node.parent.insert(rank,new_nodes[i])}
 node.children=[]
 return 0}
 $WithCtx.prototype.to_js=function(){this.js_processed=true
 var indent=$get_node(this).indent,h=' '.repeat(indent),num=this.num
 var head=this.prefix=="" ? "var " :this.prefix,cm_name='$ctx_manager'+num,cme_name=head+'$ctx_manager_exit'+num,exc_name=head+'$exc'+num,val_name='$value'+num
 return 'var '+cm_name+' = '+this.tree[0].to_js()+'\n'+
 h+cme_name+' = $B.$getattr('+cm_name+',"__exit__")\n'+
 h+'var '+val_name+' = $B.$getattr('+cm_name+',"__enter__")()\n'+
 h+exc_name+' = true\n'}
 var $YieldCtx=$B.parser.$YieldCtx=function(C,is_await){
 this.type='yield'
 this.parent=C
 this.tree=[]
 this.is_await=is_await
 C.tree[C.tree.length]=this
 if(C.type=="list_or_tuple" && C.tree.length > 1){$_SyntaxError(C,"non-parenthesized yield")}
 if($parent_match(C,{type:"annotation"})){$_SyntaxError(C,["'yield' outside function"])}
 var parent=this
 while(true){var list_or_tuple=$parent_match(parent,{type:"list_or_tuple"})
 if(list_or_tuple){list_or_tuple.yields=list_or_tuple.yields ||[]
 list_or_tuple.yields.push([this,$pos])
 parent=list_or_tuple}else{break}}
 var parent=this
 while(true){var set_or_dict=$parent_match(parent,{type:"dict_or_set"})
 if(set_or_dict){set_or_dict.yields=set_or_dict.yields ||[]
 set_or_dict.yields.push([this,$pos])
 parent=set_or_dict}else{break}}
 var root=$get_module(this)
 root.yields_func_check=root.yields_func_check ||[]
 root.yields_func_check.push([this,$pos])
 var scope=this.scope=$get_scope(this,true),node=$get_node(this)
 node.has_yield=this
 var in_comp=$parent_match(this,{type:"comprehension"})
 if($get_scope(this).id.startsWith("lc"+$B.lambda_magic)){delete node.has_yield}
 if(in_comp){var outermost_expr=in_comp.tree[0].tree[1]
 var parent=C
 while(parent){if(parent===outermost_expr){break}
 parent=parent.parent}
 if(! parent){$_SyntaxError(C,["'yield' inside list comprehension"])}}
 var in_lambda=false,parent=C
 while(parent){if(parent.type=="lambda"){in_lambda=true
 this.in_lambda=true
 break}
 parent=parent.parent}
 var parent=node.parent
 while(parent){if(parent.C && parent.C.tree.length > 0 &&
 parent.C.tree[0].type=="with"){scope.C.tree[0].$has_yield_in_cm=true
 break}
 parent=parent.parent}
 if(! in_lambda){switch(C.type){case 'node':
 break;
 case 'assign':
 case 'list_or_tuple':
 break
 default:
 $_SyntaxError(C,'yield atom must be inside ()')}}}
 $YieldCtx.prototype.toString=function(){return '(yield) '+(this.from ? '(from) ' :'')+this.tree}
 $YieldCtx.prototype.transition=function(token,value){var C=this
 if(token=='from'){
 if(C.tree[0].type !='abstract_expr'){
 $_SyntaxError(C,"'from' must follow 'yield'")}
 C.from=true
 C.from_num=$B.UUID()
 return C.tree[0]}
 return $transition(C.parent,token)}
 $YieldCtx.prototype.transform=function(node,rank){
 var parent=node.parent
 while(parent){if(parent.ctx_manager_num !==undefined){node.parent.insert(rank+1,$NodeJS("$top_frame[1].$has_yield_in_cm = true"))
 break}
 parent=parent.parent}}
 $YieldCtx.prototype.to_js=function(){if(this.from){return `_r${this.from_num}`}else{return "yield "+$to_js(this.tree)}}
 $YieldCtx.prototype.check_in_function=function(){if(this.in_lambda){return}
 var scope=$get_scope(this),in_func=scope.is_function,func_scope=scope
 if(! in_func && scope.is_comp){var parent=scope.parent_block
 while(parent.is_comp){parent=parent_block}
 in_func=parent.is_function
 func_scope=parent}
 if(! in_func){$_SyntaxError(this.parent,["'yield' outside function"])}else{var def=func_scope.C.tree[0]
 if(! this.is_await){def.type='generator'}}}
 var $add_line_num=$B.parser.$add_line_num=function(node,rank,line_info){if(node.type=='module'){var i=0
 while(i < node.children.length){i+=$add_line_num(node.children[i],i,line_info)}}else if(node.type !=='marker'){var elt=node.C.tree[0],offset=1,flag=true,pnode=node,_line_info
 while(pnode.parent !==undefined){pnode=pnode.parent}
 var mod_id=pnode.id
 var line_num=node.line_num
 if(line_num===undefined){flag=false}
 if(elt.type=='condition' && elt.token=='elif'){flag=false}
 else if(elt.type=='except'){flag=false}
 else if(elt.type=='single_kw'){flag=false}
 if(flag){_line_info=line_info===undefined ? line_num+','+mod_id :
 line_info
 var js=';$locals.$line_info = "'+_line_info+
 '";if($locals.$f_trace !== _b_.None){$B.trace_line()};'+
 '_b_.None;'
 var new_node=new $Node()
 new_node.is_line_num=true 
 new $NodeJSCtx(new_node,js)
 node.parent.insert(rank,new_node)
 offset=2}
 var i=0
 while(i < node.children.length){i+=$add_line_num(node.children[i],i,line_info)}
 return offset}else{return 1}}
 var $bind=$B.parser.$bind=function(name,scope,C){
 if(scope.nonlocals && scope.nonlocals[name]){
 return}
 if(scope.globals && scope.globals.has(name)){var module=$get_module(C)
 module.binding[name]=true
 return}
 if(! C.no_bindings){var node=$get_node(C)
 node.bindings=node.bindings ||{}
 node.bindings[name]=true}
 scope.binding=scope.binding ||{}
 if(scope.binding[name]===undefined){scope.binding[name]=true}}
 function $parent_match(ctx,obj){
 var flag
 while(ctx.parent){flag=true
 for(var attr in obj){if(ctx.parent[attr]!=obj[attr]){flag=false
 break}}
 if(flag){return ctx.parent}
 ctx=ctx.parent}
 return false}
 var $previous=$B.parser.$previous=function(C){var previous=C.node.parent.children[C.node.parent.children.length-2]
 if(!previous ||!previous.C){$_SyntaxError(C,'keyword not following correct keyword')}
 return previous.C.tree[0]}
 var $get_docstring=$B.parser.$get_docstring=function(node){var doc_string=''
 if(node.children.length > 0){var firstchild=node.children[0]
 if(firstchild.C.tree && firstchild.C.tree.length > 0 &&
 firstchild.C.tree[0].type=='expr'){var expr=firstchild.C.tree[0].tree[0]
 if(expr.type=='str' && !Array.isArray(expr.tree[0])){doc_string=firstchild.C.tree[0].tree[0].to_js()}}}
 return doc_string}
 var $get_scope=$B.parser.$get_scope=function(C,flag){
 var ctx_node=C.parent
 while(ctx_node.type !=='node'){ctx_node=ctx_node.parent}
 var tree_node=ctx_node.node,scope=null
 while(tree_node.parent && tree_node.parent.type !=='module'){var ntype=tree_node.parent.C.tree[0].type
 switch(ntype){case 'def':
 case 'class':
 case 'generator':
 var scope=tree_node.parent
 scope.ntype=ntype
 scope.is_function=ntype !='class'
 return scope}
 tree_node=tree_node.parent}
 var scope=tree_node.parent ||tree_node 
 scope.ntype="module"
 return scope}
 var $get_line_num=$B.parser.$get_line_num=function(C){var ctx_node=$get_node(C),line_num=ctx_node.line_num
 if(ctx_node.line_num===undefined){ctx_node=ctx_node.parent
 while(ctx_node && ctx_node.line_num===undefined){ctx_node=ctx_node.parent}
 if(ctx_node && ctx_node.line_num){line_num=ctx_node.line_num}}
 return line_num}
 var $get_module=$B.parser.$get_module=function(C){
 var ctx_node=C.parent
 while(ctx_node.type !=='node'){ctx_node=ctx_node.parent}
 var tree_node=ctx_node.node
 if(tree_node.ntype=="module"){return tree_node}
 var scope=null
 while(tree_node.parent.type !='module'){tree_node=tree_node.parent}
 scope=tree_node.parent 
 scope.ntype="module"
 return scope}
 var $get_src=$B.parser.$get_src=function(C){
 var node=$get_node(C)
 while(node.parent !==undefined){node=node.parent}
 return node.src}
 var $get_node=$B.parser.$get_node=function(C){var ctx=C
 while(ctx.parent){ctx=ctx.parent}
 return ctx.node}
 var $to_js_map=$B.parser.$to_js_map=function(tree_element){if(tree_element.to_js !==undefined){return tree_element.to_js()}
 throw Error('no to_js() for '+tree_element)}
 var $to_js=$B.parser.$to_js=function(tree,sep){if(sep===undefined){sep=','}
 return tree.map($to_js_map).join(sep)}
 var $mangle=$B.parser.$mangle=function(name,C){
 if(name.substr(0,2)=="__" && name.substr(name.length-2)!=="__"){var klass=null,scope=$get_scope(C)
 while(true){if(scope.ntype=="module"){return name}
 else if(scope.ntype=="class"){var class_name=scope.C.tree[0].name
 while(class_name.charAt(0)=='_'){class_name=class_name.substr(1)}
 return '_'+class_name+name}else{if(scope.parent && scope.parent.C){scope=$get_scope(scope.C.tree[0])}else{return name}}}}else{return name}}
 var $transition=$B.parser.$transition=function(C,token,value){
 return C.transition(token,value)}
 $B.forbidden=["alert","arguments","case","catch","const","constructor","Date","debugger","delete","default","do","document","enum","export","eval","extends","Error","history","function","instanceof","keys","length","location","Math","message","new","null","Number","RegExp","String","super","switch","this","throw","typeof","var","window","toLocaleString","toString","void"]
 $B.aliased_names=$B.list2obj($B.forbidden)
 var s_escaped='abfnrtvxuU"0123456789'+"'"+'\\',is_escaped={}
 for(var i=0;i < s_escaped.length;i++){is_escaped[s_escaped.charAt(i)]=true}
 var $tokenize=$B.parser.$tokenize=function(root,src){var br_close={")":"(","]":"[","}":"{"},br_stack="",br_pos=[]
 var kwdict=["class","return","break","for","lambda","try","finally","raise","def","from","nonlocal","while","del","global","with","as","elif","else","if","yield","assert","import","except","raise","in","pass","with","continue","__debugger__","async","await"
 ]
 var unsupported=[]
 var $indented=["class","def","for","condition","single_kw","try","except","with"
 ]
 var int_pattern=/^(\d[0-9_]*)(j|J)?/,float_pattern1=/^(\d[\d_]*)\.(\d+(_\d+)*)?([eE][+-]?\d+(_\d+)*)?(j|J)?/,float_pattern2=/^(\d[\d_]*)([eE][+-]?\d+(_\d+)*)(j|J)?/,hex_pattern=/^0[xX]([\da-fA-F_]+)/,octal_pattern=/^0[oO]([0-7_]+)/,binary_pattern=/^0[bB]([01_]+)/
 var C=null
 var new_node=new $Node(),current=root,name="",_type=null,pos=0,indent=null,string_modifier=false
 var module=root.module
 var lnum=root.line_num ||1
 while(pos < src.length){var car=src.charAt(pos)
 if(indent===null){var indent=0
 while(pos < src.length){var _s=src.charAt(pos)
 if(_s==" "){indent++;pos++}
 else if(_s=="\t"){
 indent++;pos++
 if(indent % 8 > 0){indent+=8-indent % 8}}else{break}}
 var _s=src.charAt(pos)
 if(_s=='\n'){pos++;lnum++;indent=null;
 continue}
 else if(_s=='#'){
 var offset=src.substr(pos).search(/\n/)
 if(offset==-1){break}
 pos+=offset+1
 lnum++
 indent=null
 continue}
 new_node.indent=indent
 new_node.line_num=lnum
 new_node.module=module
 if(current.is_body_node){
 current.indent=indent}
 if(indent > current.indent){
 if(C !==null){if($indented.indexOf(C.tree[0].type)==-1){$pos=pos
 $_SyntaxError(C,'unexpected indent',pos)}}
 current.add(new_node)}else if(indent <=current.indent && C && C.tree[0]&&
 $indented.indexOf(C.tree[0].type)>-1 &&
 C.tree.length < 2){$pos=pos
 $_SyntaxError(C,'expected an indented block',pos)}else{
 while(indent !==current.indent){current=current.parent
 if(current===undefined ||indent > current.indent){$pos=pos
 $_SyntaxError(C,'unexpected indent',pos)}}
 current.parent.add(new_node)}
 current=new_node
 C=new $NodeCtx(new_node)
 continue}
 if(car=="#"){var end=src.substr(pos+1).search('\n')
 if(end==-1){end=src.length-1}
 root.comments.push([pos,end])
 pos+=end+1
 continue}
 if(car=='"' ||car=="'"){var raw=C.type=='str' && C.raw,bytes=false,fstring=false,sm_length,
 end=null;
 if(string_modifier){switch(string_modifier){case 'r':
 raw=true
 break
 case 'u':
 break
 case 'b':
 bytes=true
 break
 case 'rb':
 case 'br':
 bytes=true;raw=true
 break
 case 'f':
 fstring=true
 sm_length=1
 break
 case 'fr','rf':
 fstring=true
 sm_length=2
 raw=true
 break}
 string_modifier=false}
 if(src.substr(pos,3)==car+car+car){_type="triple_string"
 end=pos+3}else{_type="string"
 end=pos+1}
 var escaped=false,zone=car,found=false
 while(end < src.length){if(escaped){if(src.charAt(end)=="a"){zone=zone.substr(0,zone.length-1)+"\u0007"}else{zone+=src.charAt(end)
 if(raw && src.charAt(end)=='\\'){zone+='\\'}}
 escaped=false
 end++}else if(src.charAt(end)=="\\"){if(raw){if(end < src.length-1 &&
 src.charAt(end+1)==car){zone+='\\\\'+car
 end+=2}else{zone+='\\\\'
 end++}
 escaped=true}else{if(src.charAt(end+1)=='\n'){
 end+=2
 lnum++}else if(src.substr(end+1,2)=='N{'){
 var end_lit=end+3,re=new RegExp("[-a-zA-Z0-9 ]+"),search=re.exec(src.substr(end_lit))
 if(search===null){$_SyntaxError(C,"(unicode error) "+
 "malformed \\N character escape",pos)}
 var end_lit=end_lit+search[0].length
 if(src.charAt(end_lit)!="}"){$_SyntaxError(C,"(unicode error) "+
 "malformed \\N character escape")}
 var description=search[0].toUpperCase()
 if($B.unicodedb===undefined){var xhr=new XMLHttpRequest
 xhr.open("GET",$B.brython_path+"unicode.txt",false)
 xhr.onreadystatechange=function(){if(this.readyState==4){if(this.status==200){$B.unicodedb=this.responseText}else{console.log("Warning - could not "+
 "load unicode.txt")}}}
 xhr.send()}
 if($B.unicodedb !==undefined){var re=new RegExp("^([0-9A-F]+);"+
 description+";.*$","m")
 search=re.exec($B.unicodedb)
 if(search===null){$_SyntaxError(C,"(unicode error) "+
 "unknown Unicode character name")}
 var cp="0x"+search[1]
 zone+=String.fromCodePoint(eval(cp))
 end=end_lit+1}else{end++}}else{if(end < src.length-1 &&
 is_escaped[src.charAt(end+1)]===undefined){zone+='\\'}
 zone+='\\'
 escaped=true
 end++}}}else if(src.charAt(end)=='\n' && _type !='triple_string'){
 console.log(pos,end,src.substring(pos,end))
 $pos=end
 $_SyntaxError(C,["EOL while scanning string literal"])}else if(src.charAt(end)==car){if(_type=="triple_string" &&
 src.substr(end,3)!=car+car+car){zone+=src.charAt(end)
 end++}else{found=true
 $pos=pos
 var $string=zone.substr(1),string=''
 for(var i=0;i < $string.length;i++){var $car=$string.charAt(i)
 if($car==car &&
 (raw ||(i==0 ||
 $string.charAt(i-1)!='\\'))){string+='\\'}
 string+=$car}
 if(fstring){try{var re=new RegExp("\\\\"+car,"g"),string_no_bs=string.replace(re,car)
 var elts=$B.parse_fstring(string_no_bs)}catch(err){$_SyntaxError(C,[err.toString()])}}
 if(bytes){C=$transition(C,'str','b'+car+string+car)}else if(fstring){$pos-=sm_length
 C=$transition(C,'str',elts)
 $pos+=sm_length}else{C=$transition(C,'str',car+string+car)}
 C.raw=raw;
 pos=end+1
 if(_type=="triple_string"){pos=end+3}
 break}}else{zone+=src.charAt(end)
 if(src.charAt(end)=='\n'){lnum++}
 end++}}
 if(!found){if(_type==="triple_string"){$_SyntaxError(C,"Triple string end not found")}else{$_SyntaxError(C,"String end not found")}}
 continue}
 if(name=="" && car !='$'){
 if($B.unicode_tables.XID_Start[car.charCodeAt(0)]){name=car 
 var p0=pos
 pos++
 while(pos < src.length &&
 $B.unicode_tables.XID_Continue[src.charCodeAt(pos)]){name+=src.charAt(pos)
 pos++}}
 if(name){if(kwdict.indexOf(name)>-1){$pos=pos-name.length
 if(unsupported.indexOf(name)>-1){$_SyntaxError(C,"Unsupported Python keyword '"+name+"'")}
 C=$transition(C,name)}else if(typeof $operators[name]=='string' &&
 ['is_not','not_in'].indexOf(name)==-1){
 if(name=='is'){
 var re=/^\s+not\s+/
 var res=re.exec(src.substr(pos))
 if(res !==null){pos+=res[0].length
 $pos=pos-name.length
 C=$transition(C,'op','is_not')}else{$pos=pos-name.length
 C=$transition(C,'op',name)}}else if(name=='not'){
 var re=/^\s+in\s+/
 var res=re.exec(src.substr(pos))
 if(res !==null){pos+=res[0].length
 $pos=pos-name.length
 C=$transition(C,'op','not_in')}else{$pos=pos-name.length
 C=$transition(C,name)}}else{$pos=pos-name.length
 C=$transition(C,'op',name)}}else if((src.charAt(pos)=='"' ||src.charAt(pos)=="'")
 &&['r','b','u','rb','br','f','fr','rf'].
 indexOf(name.toLowerCase())!==-1){string_modifier=name.toLowerCase()
 name=""
 continue}else{if($B.forbidden.indexOf(name)>-1){name='$$'+name}
 $pos=pos-name.length
 C=$transition(C,'id',name)}
 name=""
 continue}}
 function rmuf(numeric_literal){
 if(numeric_literal.search("__")>-1){
 $_SyntaxError(C,"invalid literal")}else if(numeric_literal.endsWith("_")){
 $_SyntaxError(C,"invalid literal")}
 return numeric_literal.replace(/_/g,"")}
 function check_int(numeric_literal){
 rmuf(numeric_literal)
 if(numeric_literal.startsWith("0")){if(numeric_literal.substr(1).search(/[^0_]/)>-1){
 $_SyntaxError(C,"invalid literal")}else{return "0"}}}
 function rmu(numeric_literal){return numeric_literal.replace(/_/g,"")}
 switch(car){case ' ':
 case '\t':
 pos++
 break
 case '.':
 if(pos < src.length-1 &&/^\d$/.test(src.charAt(pos+1))){
 var j=pos+1
 while(j < src.length &&
 src.charAt(j).search(/\d|e|E|_/)>-1){j++}
 if(src.charAt(j)=="j"){C=$transition(C,'imaginary','0'+rmu(src.substr(pos,j-pos)))
 j++}else{C=$transition(C,'float','0'+rmu(src.substr(pos,j-pos)))}
 pos=j
 break}
 $pos=pos
 C=$transition(C,'.')
 pos++
 break
 case '0':
 var res=hex_pattern.exec(src.substr(pos))
 if(res){rmuf(res[1])
 C=$transition(C,'int',[16,rmu(res[1])])
 pos+=res[0].length
 break}
 var res=octal_pattern.exec(src.substr(pos))
 if(res){C=$transition(C,'int',[8,rmuf(res[1])])
 pos+=res[0].length
 break}
 var res=binary_pattern.exec(src.substr(pos))
 if(res){C=$transition(C,'int',[2,rmuf(res[1])])
 pos+=res[0].length
 break}
 if(src.charAt(pos+1).search(/\d/)>-1){
 if(parseInt(src.substr(pos))===0){res=int_pattern.exec(src.substr(pos))
 $pos=pos
 check_int(res[0])
 C=$transition(C,'int',[10,rmu(res[0])])
 pos+=res[0].length
 break}else{$_SyntaxError(C,'invalid literal starting with 0')}}
 case '0':
 case '1':
 case '2':
 case '3':
 case '4':
 case '5':
 case '6':
 case '7':
 case '8':
 case '9':
 var res=float_pattern1.exec(src.substr(pos))
 if(res){check_int(res[1])
 if(res[2]){rmuf(res[2])}
 $pos=pos
 if($B.last(res)!==undefined){C=$transition(C,'imaginary',rmuf(res[0].substr(0,res[0].length-1)))}else{C=$transition(C,'float',rmuf(res[0]))}}else{res=float_pattern2.exec(src.substr(pos))
 if(res){check_int(res[1])
 $pos=pos
 if($B.last(res)!==undefined){C=$transition(C,'imaginary',rmuf(res[0].substr(0,res[0].length-1)))}else{C=$transition(C,'float',rmuf(res[0]))}}else{res=int_pattern.exec(src.substr(pos))
 check_int(res[1])
 $pos=pos
 if(res[2]!==undefined){C=$transition(C,'imaginary',rmu(res[1]))}else{C=$transition(C,'int',[10,rmu(res[0])])}}}
 pos+=res[0].length
 break
 case '\n':
 lnum++
 if(br_stack.length > 0){
 pos++}else{if(current.C.tree.length > 0 ||current.C.async){$pos=pos
 C=$transition(C,'eol')
 indent=null
 new_node=new $Node()}else{new_node.line_num=lnum}
 pos++}
 break
 case '(':
 case '[':
 case '{':
 br_stack+=car
 br_pos[br_stack.length-1]=[C,pos]
 $pos=pos
 C=$transition(C,car)
 pos++
 break
 case ')':
 case ']':
 case '}':
 if(br_stack==""){$pos=pos
 $_SyntaxError(C,"Unexpected closing bracket")}else if(br_close[car]!=
 br_stack.charAt(br_stack.length-1)){$pos=pos
 $_SyntaxError(C,"Unbalanced bracket")}else{br_stack=br_stack.substr(0,br_stack.length-1)
 $pos=pos
 C=$transition(C,car)
 pos++}
 break
 case '=':
 if(src.charAt(pos+1)!="="){$pos=pos
 C=$transition(C,'=')
 pos++}else{$pos=pos
 C=$transition(C,'op','==')
 pos+=2}
 break
 case ',':
 case ':':
 $pos=pos
 if(src.substr(pos,2)==":="){
 C=$transition(C,":=")
 pos++}else{C=$transition(C,car)}
 pos++
 break
 case ';':
 $transition(C,'eol')
 if(current.C.tree.length==0){
 $pos=pos
 $_SyntaxError(C,'invalid syntax')}
 var pos1=pos+1
 var ends_line=false
 while(pos1 < src.length){var _s=src.charAt(pos1)
 if(_s=='\n' ||_s=='#'){ends_line=true;break}
 else if(_s==' '){pos1++}
 else{break}}
 if(ends_line){pos++;break}
 new_node=new $Node()
 new_node.indent=$get_node(C).indent
 new_node.line_num=lnum
 new_node.module=module
 $get_node(C).parent.add(new_node)
 current=new_node
 C=new $NodeCtx(new_node)
 pos++
 break
 case '/':
 case '%':
 case '&':
 case '>':
 case '<':
 case '-':
 case '+':
 case '*':
 case '@':
 case '/':
 case '^':
 case '=':
 case '|':
 case '~':
 case '!':
 if(car=='-' && src.charAt(pos+1)=='>'){C=$transition(C,'annotation')
 pos+=2
 continue}
 if(car=='@' && C.type=="node"){$pos=pos
 C=$transition(C,car)
 pos++
 break}
 var op_match=""
 for(var op_sign in $operators){if(op_sign==src.substr(pos,op_sign.length)
 && op_sign.length > op_match.length){op_match=op_sign}}
 $pos=pos
 if(op_match.length > 0){if(op_match in $augmented_assigns){C=$transition(C,'augm_assign',op_match)}else{C=$transition(C,'op',op_match)}
 pos+=op_match.length}else{$_SyntaxError(C,'invalid character: '+car)}
 break
 case '\\':
 if(src.charAt(pos+1)=='\n'){lnum++
 pos+=2
 if(pos==src.length){$_SyntaxError(C,["unexpected EOF while parsing"])}else if(C.type=="node"){$_SyntaxError(C,'nothing before \\')}
 break}else{$pos=pos
 $_SyntaxError(C,['unexpected character after line continuation character'])}
 case String.fromCharCode(12):
 pos+=1
 break
 default:
 $pos=pos
 $_SyntaxError(C,'unknown token ['+car+']')}}
 if(br_stack.length !=0){var br_err=br_pos[0]
 $pos=br_err[1]
 var lines=src.split("\n"),id=root.id,fname=id.startsWith("$")? '<string>' :id
 $_SyntaxError(br_err[0],["unexpected EOF while parsing ("+fname+", line "+
 (lines.length-1)+")"])}
 if(C !==null){if(C.type=="async"){
 console.log("error with async",pos,src,src.substr(pos))
 $pos=pos-7
 throw $_SyntaxError(C,"car "+car+"after async",pos)}else if(C.tree[0]&&
 $indented.indexOf(C.tree[0].type)>-1){$pos=pos-1
 $_SyntaxError(C,'expected an indented block',pos)}else{var parent=current.parent
 if(parent.C && parent.C.tree &&
 parent.C.tree[0]&&
 parent.C.tree[0].type=="try"){$pos=pos-1
 $_SyntaxError(C,["unexpected EOF while parsing"])}
 if(root.yields_func_check){var save_pos=$pos
 for(const _yield of root.yields_func_check){$pos=_yield[1]
 _yield[0].check_in_function()}
 $pos=save_pos}}}}
 var $create_root_node=$B.parser.$create_root_node=function(src,module,locals_id,parent_block,line_num){var root=new $Node('module')
 root.module=module
 root.id=locals_id
 root.binding={__doc__:true,__name__:true,__file__:true,__package__:true}
 root.parent_block=parent_block
 root.line_num=line_num
 root.indent=-1
 root.comments=[]
 root.imports={}
 if(typeof src=="object"){root.is_comp=src.is_comp
 if(src.has_annotations){root.binding.__annotations__=true}
 src=src.src}
 root.src=src
 return root}
 $B.py2js=function(src,module,locals_id,parent_scope,line_num){
 $pos=0
 if(typeof module=="object"){var __package__=module.__package__
 module=module.__name__}else{var __package__=""}
 parent_scope=parent_scope ||$B.builtins_scope
 var t0=new Date().getTime(),is_comp=false,has_annotations=true,
 line_info,
 ix 
 if(typeof src=='object'){var is_comp=src.is_comp,has_annotations=src.has_annotations,line_info=src.line_info,ix=src.ix
 if(line_info !==undefined){line_num=parseInt(line_info.split(",")[0])}
 src=src.src}
 src=src.replace(/\r\n/gm,"\n")
 if(src.endsWith("\\")&& !src.endsWith("\\\\")){src=src.substr(0,src.length-1)}
 if(src.charAt(src.length-1)!="\n"){src+="\n"}
 var locals_is_module=Array.isArray(locals_id)
 if(locals_is_module){locals_id=locals_id[0]}
 var internal=locals_id.charAt(0)=='$'
 var local_ns='$locals_'+locals_id.replace(/\./g,'_')
 var global_ns='$locals_'+module.replace(/\./g,'_')
 var root=$create_root_node(
 {src:src,is_comp:is_comp,has_annotations:has_annotations},module,locals_id,parent_scope,line_num)
 $tokenize(root,src)
 root.is_comp=is_comp
 if(ix !=undefined){root.ix=ix}
 root.transform()
 var js=['var $B = __BRYTHON__;\n'],pos=1
 js[pos++]='var _b_ = __BRYTHON__.builtins;\n'
 js[pos]='var $locals = '+local_ns
 if(is_comp){js[pos]+=' = {}'}
 var offset=0
 root.insert(0,$NodeJS(js.join('')))
 offset++
 root.insert(offset++,$NodeJS(local_ns+'.__package__ = "'+__package__+'"'))
 if(root.binding.__annotations__){root.insert(offset++,$NodeJS('$locals.__annotations__ = $B.empty_dict()'))}
 var enter_frame_pos=offset,js='var $top_frame = ["'+locals_id.replace(/\./g,'_')+'", '+
 local_ns+', "'+module.replace(/\./g,'_')+'", '+
 global_ns+']\n$locals.$f_trace = $B.enter_frame($top_frame)\n'+
 'var $stack_length = $B.frames_stack.length;'
 root.insert(offset++,$NodeJS(js))
 var try_node=new $NodeJS('try'),children=root.children.slice(enter_frame_pos+1,root.children.length)
 root.insert(enter_frame_pos+1,try_node)
 if(children.length==0){children=[$NodeJS('')]}
 children.forEach(function(child){try_node.add(child)})
 try_node.add($NodeJS('$B.leave_frame({$locals, value: _b_.None})'))
 root.children.splice(enter_frame_pos+2,root.children.length)
 var catch_node=$NodeJS('catch(err)')
 catch_node.add($NodeJS('$B.leave_frame({$locals, value: _b_.None})'))
 catch_node.add($NodeJS('throw err'))
 root.add(catch_node)
 $add_line_num(root,null,line_info)
 var t1=new Date().getTime()
 if($B.debug > 2){if(module==locals_id){console.log('module '+module+' translated in '+
 (t1-t0)+' ms')}}
 $B.compile_time+=t1-t0
 return root}
 $B.set_import_paths=function(){
 var meta_path=[],path_hooks=[]
 if($B.use_VFS){meta_path.push($B.finders.VFS)}
 if($B.$options.static_stdlib_import !==false && $B.protocol !="file"){
 meta_path.push($B.finders.stdlib_static)
 if($B.path.length > 3){$B.path.shift()
 $B.path.shift()}}
 if($B.protocol !=="file"){meta_path.push($B.finders.path)
 path_hooks.push($B.$path_hooks[0])}
 if($B.$options.cpython_import){if($B.$options.cpython_import=="replace"){$B.path.pop()}
 meta_path.push($B.finders.CPython)}
 $B.meta_path=meta_path
 $B.path_hooks=path_hooks}
 var brython=$B.parser.brython=function(options){
 if(options===undefined){options={'debug':1}}
 if(typeof options=='number'){options={'debug':options}}
 if(options.debug===undefined){options.debug=1}
 $B.debug=options.debug
 _b_.__debug__=$B.debug > 0
 $B.compile_time=0
 if(options.profile===undefined){options.profile=0}
 $B.profile=options.profile
 if(options.indexedDB===undefined){options.indexedDB=true}
 if(options.static_stdlib_import===undefined){options.static_stdlib_import=true}
 $B.static_stdlib_import=options.static_stdlib_import
 $B.$options=options
 $B.set_import_paths()
 var $href=$B.script_path=_window.location.href,$href_elts=$href.split('/')
 $href_elts.pop()
 if($B.isWebWorker ||$B.isNode){$href_elts.pop()}
 $B.curdir=$href_elts.join('/')
 if(options.pythonpath !==undefined){$B.path=options.pythonpath
 $B.$options.static_stdlib_import=false}
 if(options.python_paths){options.python_paths.forEach(function(path){var lang,prefetch
 if(typeof path !=="string"){lang=path.lang
 prefetch=path.prefetch
 path=path.path}
 $B.path.push(path)
 if(path.slice(-7).toLowerCase()=='.vfs.js' &&
 (prefetch===undefined ||prefetch===true)){$B.path_importer_cache[path+'/']=
 $B.imported['_importlib'].VFSPathFinder(path)}
 if(lang){_importlib.optimize_import_for_path(path,lang)}})}
 if(!($B.isWebWorker ||$B.isNode)){
 var path_links=document.querySelectorAll('head link[rel~=pythonpath]'),_importlib=$B.imported['_importlib']
 for(var i=0,e;e=path_links[i];++i){var href=e.href;
 if((' '+e.rel+' ').indexOf(' prepend ')!=-1){$B.path.unshift(href);}else{$B.path.push(href);}
 var filetype=e.hreflang
 if(filetype){if(filetype.slice(0,2)=='x-'){filetype=filetype.slice(2)}
 _importlib.optimize_import_for_path(e.href,filetype)}}}
 if($B.$options.args){$B.__ARGV=$B.$options.args}else{$B.__ARGV=_b_.list.$factory([])}
 if(!($B.isWebWorker ||$B.isNode)){_run_scripts(options)}}
 $B.run_script=function(src,name,run_loop){
 $B.$py_module_path[name]=$B.script_path
 try{var root=$B.py2js(src,name,name),js=root.to_js(),script={__doc__:root.__doc__,js:js,__name__:name,$src:src,__file__:$B.script_path+
 ($B.script_path.endsWith("/")? "" :"/")+name}
 $B.file_cache[script.__file__]=src
 if($B.debug > 1){console.log(js)}}catch(err){$B.handle_error(err)}
 if($B.hasOwnProperty("VFS")&& $B.has_indexedDB){
 var imports1=Object.keys(root.imports).slice(),imports=imports1.filter(function(item){return $B.VFS.hasOwnProperty(item)})
 Object.keys(imports).forEach(function(name){if($B.VFS.hasOwnProperty(name)){var submodule=$B.VFS[name],type=submodule[0]
 if(type==".py"){var src=submodule[1],subimports=submodule[2],is_package=submodule.length==4
 if(type==".py"){
 required_stdlib_imports(subimports)}
 subimports.forEach(function(mod){if(imports.indexOf(mod)==-1){imports.push(mod)}})}}})
 for(var j=0;j < imports.length;j++){$B.tasks.push([$B.inImported,imports[j]])}
 root=null}
 $B.tasks.push(["execute",script])
 if(run_loop){$B.loop()}}
 var $log=$B.$log=function(js){js.split("\n").forEach(function(line,i){console.log(i+1,":",line)})}
 var _run_scripts=$B.parser._run_scripts=function(options){
 var kk=Object.keys(_window)
 var defined_ids={}
 if(options.ipy_id !==undefined){var $elts=[]
 options.ipy_id.forEach(function(elt){$elts.push(document.getElementById(elt))})}else{var scripts=document.getElementsByTagName('script'),$elts=[],webworkers=[]
 for(var i=0;i < scripts.length;i++){var script=scripts[i]
 if(script.type=="text/python" ||script.type=="text/python3"){if(script.className=="webworker"){if(script.id===undefined){throw _b_.AttributeError.$factory(
 "webworker script has no attribute 'id'")}
 webworkers.push(script)}else{$elts.push(script)}}}}
 var first_script=true,module_name
 if(options.ipy_id !==undefined){module_name='__main__'
 var $src="",js,root
 $B.$py_module_path[module_name]=$B.script_path
 $elts.forEach(function(elt){$src+=(elt.innerHTML ||elt.textContent)})
 try{
 root=$B.py2js($src,module_name,module_name)
 js=root.to_js()
 if($B.debug > 1){$log(js)}
 eval(js)
 $B.clear_ns(module_name)
 root=null
 js=null}catch($err){root=null
 js=null
 console.log($err)
 if($B.debug > 1){console.log($err)
 for(var attr in $err){console.log(attr+' : ',$err[attr])}}
 if($err.$py_error===undefined){console.log('Javascript error',$err)
 $err=_b_.RuntimeError.$factory($err+'')}
 var $trace=$B.$getattr($err,'info')+'\n'+$err.__name__+
 ': '+$err.args
 try{$B.$getattr($B.stderr,'write')($trace)}catch(print_exc_err){console.log($trace)}
 throw $err}}else{if($elts.length > 0){if(options.indexedDB && $B.has_indexedDB &&
 $B.hasOwnProperty("VFS")){$B.tasks.push([$B.idb_open])}}
 for(var i=0;i < $elts.length;i++){var elt=$elts[i]
 if(elt.id){if(defined_ids[elt.id]){throw Error("Brython error : Found 2 scripts with the "+
 "same id '"+elt.id+"'")}else{defined_ids[elt.id]=true}}}
 var src
 for(var i=0,len=webworkers.length;i < len;i++){var worker=webworkers[i]
 if(worker.src){
 $B.tasks.push([$B.ajax_load_script,{name:worker.id,url:worker.src,is_ww:true}])}else{
 src=(worker.innerHTML ||worker.textContent)
 src=src.replace(/^\n/,'')
 $B.webworkers[worker.id]=src}}
 for(var i=0;i < $elts.length;i++){var elt=$elts[i]
 if(elt.type=="text/python" ||elt.type=="text/python3"){
 if(elt.id){module_name=elt.id}else{
 if(first_script){module_name='__main__'
 first_script=false}else{module_name='__main__'+$B.UUID()}
 while(defined_ids[module_name]!==undefined){module_name='__main__'+$B.UUID()}}
 if(elt.src){
 $B.tasks.push([$B.ajax_load_script,{name:module_name,url:elt.src}])}else{
 src=(elt.innerHTML ||elt.textContent)
 src=src.replace(/^\n/,'')
 $B.run_script(src,module_name)}}}}
 if(options.ipy_id===undefined){$B.loop()}}
 $B.$operators=$operators
 $B.$Node=$Node
 $B.$NodeJSCtx=$NodeJSCtx
 $B.brython=brython})(__BRYTHON__)
 var brython=__BRYTHON__.brython
 if(__BRYTHON__.isNode){global.__BRYTHON__=__BRYTHON__
 module.exports={__BRYTHON__ }}
 ;
 
 (function($B){var _b_=$B.builtins
 if($B.VFS_timestamp && $B.VFS_timestamp > $B.timestamp){
 $B.timestamp=$B.VFS_timestamp}
 function idb_load(evt,module){
 var res=evt.target.result
 var timestamp=$B.timestamp
 if(res===undefined ||res.timestamp !=$B.timestamp ||
 ($B.VFS[module]&& res.source_ts !==$B.VFS[module].timestamp)){
 if($B.VFS[module]!==undefined){var elts=$B.VFS[module],ext=elts[0],source=elts[1]
 if(ext==".py"){var imports=elts[2],is_package=elts.length==4,source_ts=elts.timestamp,__package__
 if(is_package){__package__=module}
 else{var parts=module.split(".")
 parts.pop()
 __package__=parts.join(".")}
 $B.imported[module]=$B.module.$factory(module,"",__package__)
 try{var root=$B.py2js(source,module,module),js=root.to_js()}catch(err){$B.handle_error(err)}
 delete $B.imported[module]
 if($B.debug > 1){console.log("precompile",module)}
 var parts=module.split(".")
 if(parts.length > 1){parts.pop()}
 if($B.stdlib.hasOwnProperty(parts.join("."))){var imports=elts[2]
 imports=imports.join(",")
 $B.tasks.splice(0,0,[store_precompiled,module,js,source_ts,imports,is_package])}}else{console.log('bizarre',module,ext)}}else{}}else{
 if(res.is_package){$B.precompiled[module]=[res.content]}else{$B.precompiled[module]=res.content}
 if(res.imports.length > 0){
 if($B.debug > 1){console.log(module,"imports",res.imports)}
 var subimports=res.imports.split(",")
 for(var i=0;i < subimports.length;i++){var subimport=subimports[i]
 if(subimport.startsWith(".")){
 var url_elts=module.split("."),nb_dots=0
 while(subimport.startsWith(".")){nb_dots++
 subimport=subimport.substr(1)}
 var elts=url_elts.slice(0,nb_dots)
 if(subimport){elts=elts.concat([subimport])}
 subimport=elts.join(".")}
 if(!$B.imported.hasOwnProperty(subimport)&&
 !$B.precompiled.hasOwnProperty(subimport)){
 if($B.VFS.hasOwnProperty(subimport)){var submodule=$B.VFS[subimport],ext=submodule[0],source=submodule[1]
 if(submodule[0]==".py"){$B.tasks.splice(0,0,[idb_get,subimport])}else{add_jsmodule(subimport,source)}}}}}}
 loop()}
 function store_precompiled(module,js,source_ts,imports,is_package){
 var db=$B.idb_cx.result,tx=db.transaction("modules","readwrite"),store=tx.objectStore("modules"),cursor=store.openCursor(),data={"name":module,"content":js,"imports":imports,"origin":origin,"timestamp":__BRYTHON__.timestamp,"source_ts":source_ts,"is_package":is_package},request=store.put(data)
 if($B.debug > 1){console.log("store precompiled",module,"package",is_package)}
 document.dispatchEvent(new CustomEvent('precompile',{detail:'cache module '+module}))
 var ix=$B.outdated.indexOf(module)
 if(ix >-1){$B.outdated.splice(ix,1)}
 request.onsuccess=function(evt){
 $B.tasks.splice(0,0,[idb_get,module])
 loop()}}
 function idb_get(module){
 var db=$B.idb_cx.result,tx=db.transaction("modules","readonly")
 try{var store=tx.objectStore("modules")
 req=store.get(module)
 req.onsuccess=function(evt){idb_load(evt,module)}}catch(err){console.info('error',err)}}
 $B.idb_open=function(obj){$B.idb_name="brython-cache"
 var idb_cx=$B.idb_cx=indexedDB.open($B.idb_name)
 idb_cx.onsuccess=function(){var db=idb_cx.result
 if(!db.objectStoreNames.contains("modules")){var version=db.version
 db.close()
 console.info('create object store',version)
 idb_cx=indexedDB.open($B.idb_name,version+1)
 idb_cx.onupgradeneeded=function(){console.info("upgrade needed")
 var db=$B.idb_cx.result,store=db.createObjectStore("modules",{"keyPath":"name"})
 store.onsuccess=loop}
 idb_cx.onversionchanged=function(){console.log("version changed")}
 idb_cx.onsuccess=function(){console.info("db opened",idb_cx)
 var db=idb_cx.result,store=db.createObjectStore("modules",{"keyPath":"name"})
 store.onsuccess=loop}}else{if($B.debug > 1){console.info("using indexedDB for stdlib modules cache")}
 var tx=db.transaction("modules","readwrite"),store=tx.objectStore("modules"),record,outdated=[]
 var openCursor=store.openCursor()
 openCursor.onerror=function(evt){console.log("open cursor error",evt)}
 openCursor.onsuccess=function(evt){cursor=evt.target.result
 if(cursor){record=cursor.value
 if(record.timestamp==$B.timestamp){if(!$B.VFS ||!$B.VFS[record.name]||
 $B.VFS[record.name].timestamp==record.source_ts){
 if(record.is_package){$B.precompiled[record.name]=[record.content]}else{$B.precompiled[record.name]=record.content}
 if($B.debug > 1){console.info("load from cache",record.name)}}else{
 outdated.push(record.name)}}else{outdated.push(record.name)}
 cursor.continue()}else{if($B.debug > 1){console.log("done")}
 $B.outdated=outdated
 loop()}}}}
 idb_cx.onupgradeneeded=function(){console.info("upgrade needed")
 var db=idb_cx.result,store=db.createObjectStore("modules",{"keyPath":"name"})
 store.onsuccess=loop}
 idb_cx.onerror=function(){console.info('could not open indexedDB database')
 $B.idb_cx=null
 $B.idb_name=null
 $B.$options.indexedDB=false
 loop()}}
 $B.ajax_load_script=function(script){var url=script.url,name=script.name
 if($B.files && $B.files.hasOwnProperty(name)){$B.tasks.splice(0,0,[$B.run_script,$B.files[name],name,true])}else if($B.protocol !="file"){var req=new XMLHttpRequest(),qs=$B.$options.cache ? '' :
 (url.search(/\?/)>-1 ? '&' :'?')+Date.now()
 req.open("GET",url+qs,true)
 req.onreadystatechange=function(){if(this.readyState==4){if(this.status==200){var src=this.responseText
 if(script.is_ww){$B.webworkers[name]=src}else{$B.tasks.splice(0,0,[$B.run_script,src,name,true])}
 loop()}else if(this.status==404){throw Error(url+" not found")}}}
 req.send()}else{throw _b_.IOError.$factory("can't load external script at "+
 script.url+" (Ajax calls not supported with protocol file:///)")}}
 function add_jsmodule(module,source){
 source+="\nvar $locals_"+
 module.replace(/\./g,"_")+" = $module"
 $B.precompiled[module]=source}
 var inImported=$B.inImported=function(module){if($B.imported.hasOwnProperty(module)){}else if(__BRYTHON__.VFS && __BRYTHON__.VFS.hasOwnProperty(module)){var elts=__BRYTHON__.VFS[module]
 if(elts===undefined){console.log('bizarre',module)}
 var ext=elts[0],source=elts[1],is_package=elts.length==4
 if(ext==".py"){if($B.idb_cx && !$B.idb_cx.$closed){$B.tasks.splice(0,0,[idb_get,module])}}else{add_jsmodule(module,source)}}else{console.log("bizarre",module)}
 loop()}
 var loop=$B.loop=function(){if($B.tasks.length==0){
 if($B.idb_cx && ! $B.idb_cx.$closed){var db=$B.idb_cx.result,tx=db.transaction("modules","readwrite"),store=tx.objectStore("modules")
 while($B.outdated.length > 0){var module=$B.outdated.pop(),req=store.delete(module)
 req.onsuccess=function(event){if($B.debug > 1){console.info("delete outdated",module)}
 document.dispatchEvent(new CustomEvent('precompile',{detail:'remove outdated '+module+
 ' from cache'}))}}
 document.dispatchEvent(new CustomEvent('precompile',{detail:"close"}))
 $B.idb_cx.result.close()
 $B.idb_cx.$closed=true}
 return}
 var task=$B.tasks.shift(),func=task[0],args=task.slice(1)
 if(func=="execute"){try{var script=task[1],script_id=script.__name__.replace(/\./g,"_"),module=$B.module.$factory(script.__name__)
 module.$src=script.$src
 module.__file__=script.__file__
 $B.imported[script_id]=module
 new Function("$locals_"+script_id,script.js)(module)}catch(err){
 if(err.__class__===undefined){console.log('Javascript error',err)
 if($B.is_recursion_error(err)){err=_b_.RecursionError.$factory("too much recursion")}else{$B.print_stack()
 err=_b_.RuntimeError.$factory(err+'')}}
 if($B.debug > 1){console.log("handle error",err.__class__,err.args,err.$stack)
 console.log($B.frames_stack.slice())}
 $B.handle_error(err)}
 loop()}else{
 try{func.apply(null,args)}catch(err){$B.handle_error(err)}}}
 $B.tasks=[]
 $B.has_indexedDB=self.indexedDB !==undefined
 $B.handle_error=function(err){
 if($B.debug > 1){console.log("handle error",err.__class__,err.args)}
 if(err.__class__ !==undefined){var name=$B.class_name(err),trace=$B.$getattr(err,'info')
 if(name=='SyntaxError' ||name=='IndentationError'){var offset=err.args[3]
 trace+='\n    '+' '.repeat(offset)+'^'+
 '\n'+name+': '+err.args[0]}else{trace+='\n'+name
 if(err.args[0]&& err.args[0]!==_b_.None){trace+=': '+_b_.str.$factory(err.args[0])}}}else{console.log(err)
 trace=err+""}
 try{$B.$getattr($B.stderr,'write')(trace)
 try{$B.$getattr($B.stderr,'flush')()}catch(err){console.log(err)}}catch(print_exc_err){console.log(trace)}
 throw err}
 function required_stdlib_imports(imports,start){
 var nb_added=0
 start=start ||0
 for(var i=start;i < imports.length;i++){var module=imports[i]
 if($B.imported.hasOwnProperty(module)){continue}
 var mod_obj=$B.VFS[module]
 if(mod_obj===undefined){console.log("undef",module)}
 if(mod_obj[0]==".py"){var subimports=mod_obj[2]
 subimports.forEach(function(subimport){if(!$B.imported.hasOwnProperty(subimport)&&
 imports.indexOf(subimport)==-1){if($B.VFS.hasOwnProperty(subimport)){imports.push(subimport)
 nb_added++}}})}}
 if(nb_added){required_stdlib_imports(imports,imports.length-nb_added)}
 return imports}})(__BRYTHON__)
 ;
 __BRYTHON__.builtins.object=(function($B){var _b_=$B.builtins
 var object={
 $infos:{__name__:"object"},$is_class:true,$native:true}
 var opnames=["add","sub","mul","truediv","floordiv","mod","pow","lshift","rshift","and","xor","or"]
 var opsigns=["+","-","*","/","//","%","**","<<",">>","&","^","|"]
 object.__delattr__=function(self,attr){attr=$B.from_alias(attr)
 if(self.__dict__ && self.__dict__.$string_dict &&
 self.__dict__.$string_dict[attr]!==undefined){delete self.__dict__.$string_dict[attr]
 return _b_.None}else if(self.__dict__===undefined && self[attr]!==undefined){delete self[attr]
 return _b_.None}else{
 var klass=self.__class__
 if(klass){var prop=$B.$getattr(klass,attr)
 if(prop.__class__===_b_.property){if(prop.__delete__ !==undefined){prop.__delete__(self)
 return _b_.None}}}}
 throw _b_.AttributeError.$factory(attr)}
 object.__dir__=function(self){var objects
 if(self.$is_class){objects=[self].concat(self.__mro__)}else{var klass=self.__class__ ||$B.get_class(self)
 objects=[self,klass].concat(klass.__mro__)}
 var res=[]
 for(var i=0,len=objects.length;i < len;i++){for(var attr in objects[i]){if(attr.charAt(0)=="$"){if(attr.charAt(1)=="$"){
 res.push(attr.substr(2))}
 continue}
 if(! isNaN(parseInt(attr.charAt(0)))){
 continue}
 if(attr=="__mro__"){continue}
 res.push(attr)}}
 if(self.__dict__){for(var attr in self.__dict__.$string_dict){if(attr.substr(0,2)=="$$"){res.push(attr.substr(2))}
 else if(attr.charAt(0)!="$"){res.push(attr)}}}
 res=_b_.list.$factory(_b_.set.$factory(res))
 _b_.list.sort(res)
 return res}
 object.__eq__=function(self,other){
 if(self===other){return true}
 return _b_.NotImplemented}
 object.__format__=function(){var $=$B.args("__format__",2,{self:null,spec:null},["self","spec"],arguments,{},null,null)
 if($.spec !==""){throw _b_.TypeError.$factory(
 "non-empty format string passed to object.__format__")}
 return _b_.getattr($.self,"__str__")()}
 object.__ge__=function(){return _b_.NotImplemented}
 object.__getattribute__=function(obj,attr){var klass=obj.__class__ ||$B.get_class(obj),is_own_class_instance_method=false
 var $test=false 
 if($test){console.log("attr",attr,"de",obj,"klass",klass)}
 if(attr==="__class__"){return klass}
 var res=obj[attr]
 if(Array.isArray(obj)&& Array.prototype[attr]!==undefined){
 res=undefined}
 if(res===undefined && obj.__dict__){var dict=obj.__dict__
 if(dict.$string_dict.hasOwnProperty(attr)){if($test){console.log("__dict__ hasOwnProperty",attr,dict.$string_dict[attr])}
 return dict.$string_dict[attr][0]}}
 if(res===undefined){
 function check(obj,kl,attr){var v=kl[attr]
 if(v !==undefined){return v}}
 res=check(obj,klass,attr)
 if(res===undefined){var mro=klass.__mro__
 for(var i=0,len=mro.length;i < len;i++){res=check(obj,mro[i],attr)
 if(res !==undefined){if($test){console.log("found in",mro[i])}
 break}}}else{if(res.__class__ !==$B.method && res.__get__===undefined){
 is_own_class_instance_method=true}}}else{if(res.__set__===undefined){
 return res}}
 if(res !==undefined){if($test){console.log(res)}
 if(res.__class__===_b_.property){return res.__get__(res,obj,klass)}
 if(res.__class__===$B.method){if($test){console.log("res is method")}
 if(res.__get__===undefined){console.log("bizarre",obj,attr,res)}
 return res.__get__(obj,klass)}
 var get=res.__get__
 if(get===undefined && res.__class__){var get=res.__class__.__get__
 for(var i=0;i < res.__class__.__mro__.length &&
 get===undefined;i++){get=res.__class__.__mro__[i].__get__}}
 if($test){console.log("get",get)}
 var __get__=get===undefined ? null :
 $B.$getattr(res,"__get__",null)
 if($test){console.log("__get__",__get__)}
 if(__get__ !==null){try{return __get__.apply(null,[obj,klass])}
 catch(err){console.log('error in get.apply',err)
 console.log("get attr",attr,"of",obj)
 console.log(__get__+'')
 throw err}}
 if(typeof res=="object"){if(__get__ &&(typeof __get__=="function")){get_func=function(x,y){return __get__.apply(x,[y,klass.$factory])}}}
 if(__get__===null &&(typeof res=="function")){__get__=function(x){return x}}
 if(__get__ !==null){
 res.__name__=attr
 if(attr=="__new__"){res.$type="staticmethod"}
 var res1=__get__.apply(null,[res,obj,klass])
 if($test){console.log("res",res,"res1",res1)}
 if(typeof res1=="function"){
 if(res1.__class__===$B.method){return res}
 if(res.$type=="staticmethod"){return res}
 else{var self=res.__class__===$B.method ? klass :obj,method=function(){var args=[self]
 for(var i=0,len=arguments.length;i < len;i++){args.push(arguments[i])}
 return res.apply(this,args)}
 method.__class__=$B.method
 method.__get__=function(obj,cls){var clmethod=res.bind(null,cls)
 clmethod.__class__=$B.method
 clmethod.$infos={__self__:cls,__func__:res,__name__:res.$infos.__name__,__qualname__:cls.$infos.__name__+"."+
 res.$infos.__name__}
 return clmethod}
 method.__get__.__class__=$B.method_wrapper
 method.__get__.$infos=res.$infos
 if(klass.$infos===undefined){console.log("no $infos",klass)
 console.log($B.last($B.frames_stack))}
 method.$infos={__self__:self,__func__:res,__name__:attr,__qualname__:klass.$infos.__name__+"."+attr}
 if($test){console.log("return method",method)}
 if(is_own_class_instance_method){obj.$method_cache=obj.$method_cache ||{}
 obj.$method_cache[attr]=[method,res]}
 return method}}else{
 return res1}}
 return res}else{
 var _ga=obj["__getattr__"]
 if(_ga===undefined){_ga=klass["__getattr__"]
 if(_ga===undefined){var mro=klass.__mro__
 for(var i=0,len=mro.length;i < len;i++){_ga=mro[i]["__getattr__"]
 if(_ga !==undefined){break}}}}
 if(_ga !==undefined){if(klass===$B.module){return _ga(attr)}
 return _ga(obj,attr)}else{throw _b_.AttributeError.$factory(attr)}}}
 object.__gt__=function(){return _b_.NotImplemented}
 object.__hash__=function(self){var hash=self.__hashvalue__
 if(hash !==undefined){return hash}
 return self.__hashvalue__=$B.$py_next_hash--}
 object.__init__=function(){if(arguments.length==0){throw _b_.TypeError.$factory("descriptor '__init__' of 'object' "+
 "object needs an argument")}
 return _b_.None}
 object.__init_subclass__=function(){
 var $=$B.args("__init_subclass__",0,{},[],arguments,{},null,null)
 return _b_.None}
 object.__init_subclass__.$type="staticmethod"
 object.__le__=function(){return _b_.NotImplemented}
 object.__lt__=function(){return _b_.NotImplemented}
 object.__mro__=[]
 object.__new__=function(cls,...args){if(cls===undefined){throw _b_.TypeError.$factory("object.__new__(): not enough arguments")}
 var init_func=$B.$getattr(cls,"__init__")
 if(init_func===object.__init__){if(args.length > 0){throw _b_.TypeError.$factory("object() takes no parameters")}}
 return{
 __class__ :cls,__dict__:$B.empty_dict()}}
 object.__ne__=function(self,other){
 if(self===other){return false}
 var eq=$B.$getattr(self,"__eq__",null)
 if(eq !==null){var res=$B.$call(eq)(other)
 if(res===_b_.NotImplemented){return res}
 return ! $B.$bool(res)}
 return _b_.NotImplemented}
 object.__reduce__=function(self){function _reconstructor(cls){return $B.$call(cls)()}
 _reconstructor.$infos={__qualname__:"_reconstructor"}
 var res=[_reconstructor]
 res.push(_b_.tuple.$factory([self.__class__].
 concat(self.__class__.__mro__)))
 var d=$B.empty_dict()
 for(var attr in self.__dict__.$string_dict){_b_.dict.$setitem(d.$string_dict,attr,self.__dict__.$string_dict[attr][0])}
 console.log("object.__reduce__, d",d)
 res.push(d)
 return _b_.tuple.$factory(res)}
 function __newobj__(cls){return $B.$getattr(cls,"__new__").apply(null,arguments)}
 __newobj__.$infos={__name__:"__newobj__",__qualname__:"__newobj__"}
 _b_.__newobj__=__newobj__
 object.__reduce_ex__=function(self){var res=[__newobj__]
 var arg2=_b_.tuple.$factory([self.__class__])
 if(Array.isArray(self)){self.forEach(function(item){arg2.push(item)})}
 res.push(arg2)
 var d=$B.empty_dict(),nb=0
 if(self.__dict__===undefined){throw _b_.TypeError.$factory("cannot pickle '"+
 $B.class_name(self)+"' object")}
 for(var attr in self.__dict__.$string_dict){if(attr=="__class__" ||attr.startsWith("$")){continue}
 _b_.dict.$setitem(d,attr,self.__dict__.$string_dict[attr][0])
 nb++}
 if(nb==0){d=_b_.None}
 res.push(d)
 res.push(_b_.None)
 return _b_.tuple.$factory(res)}
 object.__repr__=function(self){if(self===object){return "<class 'object'>"}
 if(self.__class__===_b_.type){return "<class '"+self.__name__+"'>"}
 var module=self.__class__.$infos.__module__
 if(module !==undefined && !module.startsWith("$")&&
 module !=="builtins"){return "<"+self.__class__.$infos.__module__+"."+
 $B.class_name(self)+" object>"}else{return "<"+$B.class_name(self)+" object>"}}
 object.__setattr__=function(self,attr,val){if(val===undefined){
 throw _b_.TypeError.$factory(
 "can't set attributes of built-in/extension type 'object'")}else if(self.__class__===object){
 if(object[attr]===undefined){throw _b_.AttributeError.$factory(
 "'object' object has no attribute '"+attr+"'")}else{throw _b_.AttributeError.$factory(
 "'object' object attribute '"+attr+"' is read-only")}}
 if($B.aliased_names[attr]){attr="$$"+attr}
 if(self.__dict__){_b_.dict.$setitem(self.__dict__,attr,val)}else{
 self[attr]=val}
 return _b_.None}
 object.__setattr__.__get__=function(obj){return function(attr,val){object.__setattr__(obj,attr,val)}}
 object.__setattr__.__str__=function(){return "method object.setattr"}
 object.__str__=function(self){var repr_func=$B.$getattr(self,"__repr__")
 return $B.$call(repr_func)()}
 object.__subclasshook__=function(){return _b_.NotImplemented}
 object.$factory=function(){var res={__class__:object},args=[res].concat(Array.prototype.slice.call(arguments))
 object.__init__.apply(null,args)
 return res}
 $B.set_func_names(object,"builtins")
 $B.make_class=function(name,factory){
 var A={__class__:_b_.type,__mro__:[object],$infos:{__name__:name},$is_class:true}
 A.$factory=factory
 return A}
 return object})(__BRYTHON__)
 ;
 ;(function($B){var _b_=$B.builtins
 $B.$class_constructor=function(class_name,class_obj,bases,parents_names,kwargs){bases=bases ||[]
 var metaclass
 var module=class_obj.__module__
 if(module===undefined){
 module=class_obj.__module__=$B.last($B.frames_stack)[2]}
 for(var i=0;i < bases.length;i++){if(bases[i]===undefined){
 $B.line_info=class_obj.$def_line
 throw _b_.NameError.$factory("name '"+parents_names[i]+
 "' is not defined")}}
 var extra_kwargs={},prepare_kwargs={}
 if(kwargs){for(var i=0;i < kwargs.length;i++){var key=kwargs[i][0],val=kwargs[i][1]
 if(key=="metaclass"){
 metaclass=val}else{
 extra_kwargs[key]=val}
 prepare_kwargs[key]=val}}
 var mro0=class_obj
 if(class_obj.__eq__ !==undefined && class_obj.__hash__===undefined){class_obj.__hash__=_b_.None}
 var orig_bases=bases.slice(),use_mro_entries=false
 for(var i=0;i < bases.length;i++){if(bases[i]===undefined ||
 (bases[i].__mro__===undefined)){var mro_entries=$B.$getattr(bases[i],"__mro_entries__",_b_.None)
 if(mro_entries !==_b_.None){var entries=_b_.list.$factory(mro_entries(bases))
 bases.splice(i,1,...entries)
 use_mro_entries=true
 i--
 continue}}}
 if(metaclass===undefined){if(bases && bases.length > 0){metaclass=bases[0].__class__
 if(metaclass===undefined){
 if(typeof bases[0]=="function"){if(bases.length !=1){throw _b_.TypeError.$factory("A Brython class "+
 "can inherit at most 1 Javascript constructor")}
 metaclass=bases[0].__class__=$B.JSMeta
 $B.set_func_names(bases[0],module)}else{throw _b_.TypeError.$factory("Argument of "+class_name+
 "is not a class (type '"+$B.class_name(bases[0])+
 "')")}}
 for(var i=1;i < bases.length;i++){var mc=bases[i].__class__
 if(mc===metaclass ||_b_.issubclass(metaclass,mc)){}else if(_b_.issubclass(mc,metaclass)){metaclass=mc}else if(metaclass.__bases__ &&
 metaclass.__bases__.indexOf(mc)==-1){throw _b_.TypeError.$factory("metaclass conflict: the "+
 "metaclass of a derived class must be a (non-"+
 "strict) subclass of the metaclasses of all its bases")}}}else{metaclass=_b_.type}}
 var prepare=$B.$getattr(metaclass,"__prepare__",_b_.None),cl_dict=$B.$call(prepare)(class_name,bases)
 if(cl_dict.__class__ !==_b_.dict){set_class_item=$B.$getattr(cl_dict,"__setitem__")}else{set_class_item=function(attr,value){cl_dict.$string_dict[attr]=[value,cl_dict.$order++]}}
 for(var attr in class_obj){if(attr=="__annotations__"){if(cl_dict.$string_dict[attr]===undefined){cl_dict.$string_dict[attr]=[$B.empty_dict(),cl_dict.$order++]}
 for(var key in class_obj[attr].$string_dict){$B.$setitem(cl_dict.$string_dict[attr][0],key,class_obj[attr].$string_dict[key][0])}}else{if(attr.charAt(0)!="$" ||attr.substr(0,2)=="$$"){set_class_item(attr,class_obj[attr])}}}
 if(use_mro_entries){set_class_item("__orig_bases__",_b_.tuple.$factory(orig_bases))}
 var class_dict={__bases__:bases,__class__:metaclass,__dict__:cl_dict}
 if(cl_dict.__class__===_b_.dict){for(var key in cl_dict.$string_dict){class_dict[key]=cl_dict.$string_dict[key][0]}}else{var get_class_item=$B.$getattr(cl_dict,"__getitem__")
 var it=_b_.iter(cl_dict)
 while(true){try{var key=_b_.next(it)
 class_dict[key]=get_class_item(key)}catch(err){break}}}
 class_dict.__mro__=_b_.type.mro(class_dict).slice(1)
 var is_instanciable=true,non_abstract_methods={},abstract_methods={},mro=[class_dict].concat(class_dict.__mro__)
 for(var i=0;i < mro.length;i++){var kdict=i==0 ? mro0 :mro[i]
 for(var attr in kdict){if(non_abstract_methods[attr]){continue}
 var v=kdict[attr]
 if(typeof v=="function"){if(v.__isabstractmethod__===true ||
 (v.$attrs && v.$attrs.__isabstractmethod__)){is_instanciable=false
 abstract_methods[attr]=true}else{non_abstract_methods[attr]=true}}}}
 var _slots=class_obj.__slots__
 if(_slots !==undefined){if(typeof _slots=="string"){_slots=[_slots]}else{_slots=_b_.list.$factory(_slots)}
 cl_dict.__slots__=_slots}
 for(var i=0;i < mro.length-1;i++){for(var attr in mro[i]){if(attr=="__setattr__"){cl_dict.$has_setattr=true
 break}else if(mro[i][attr]){if(mro[i][attr].__get__ ||(mro[i][attr].__class__ &&
 mro[i][attr].__class__.__get__)){
 cl_dict.$has_setattr=true
 break}}}}
 var meta_new=_b_.type.__getattribute__(metaclass,"__new__")
 var kls=meta_new(metaclass,class_name,bases,cl_dict)
 kls.__module__=module
 kls.$infos={__module__:module,__name__:$B.from_alias(class_name),__qualname__:class_obj.$qualname}
 kls.$subclasses=[]
 for(var attr in class_obj){if(attr.charAt(0)!="$" ||attr.substr(0,2)=="$$"){if(typeof class_obj[attr]=="function"){class_obj[attr].$infos.$class=kls}}}
 if(kls.__class__===metaclass){
 var meta_init=_b_.type.__getattribute__(metaclass,"__init__")
 meta_init(kls,class_name,bases,cl_dict)}
 for(var i=0;i < bases.length;i++){bases[i].$subclasses=bases[i].$subclasses ||[]
 bases[i].$subclasses.push(kls)}
 var sup=_b_.$$super.$factory(kls,kls)
 var init_subclass=_b_.$$super.__getattribute__(sup,"__init_subclass__")
 init_subclass({$nat:"kw",kw:extra_kwargs})
 if(!is_instanciable){function nofactory(){throw _b_.TypeError.$factory("Can't instantiate abstract class "+
 "interface with abstract methods "+
 Object.keys(abstract_methods).join(", "))}
 kls.$factory=nofactory}
 kls.__qualname__=class_name.replace("$$","")
 return kls}
 var type=$B.make_class("type",function(obj,bases,cl_dict){if(arguments.length==1){if(obj===undefined){return $B.UndefinedClass}
 return obj.__class__ ||$B.get_class(obj)}
 return type.__new__(type,obj,bases,cl_dict)}
 )
 type.__call__=function(){var extra_args=[],klass=arguments[0]
 for(var i=1,len=arguments.length;i < len;i++){extra_args.push(arguments[i])}
 var new_func=_b_.type.__getattribute__(klass,"__new__")
 var instance=new_func.apply(null,arguments)
 if(instance.__class__===klass){
 var init_func=_b_.type.__getattribute__(klass,"__init__")
 if(init_func !==_b_.object.__init__){
 var args=[instance].concat(extra_args)
 init_func.apply(null,args)}}
 return instance}
 type.__class__=type
 type.__format__=function(klass,fmt_spec){
 return _b_.str.$factory(klass)}
 type.__getattribute__=function(klass,attr){switch(attr){case "__annotations__":
 var mro=[klass].concat(klass.__mro__),res
 for(var i=0,len=mro.length;i < len;i++){if(mro[i].__dict__){var ann=mro[i].__dict__.$string_dict.__annotations__[0]
 if(ann){if(res===undefined){res=ann}else if(res.__class__===_b_.dict &&
 ann.__class__===_b_.dict){
 for(var key in ann.$string_dict){res.$string_dict[key]=ann.$string_dict[key]}}}}}
 if(res===undefined){res=$B.empty_dict()}
 return res
 case "__bases__":
 var res=klass.__bases__ ||_b_.tuple.$factory()
 res.__class__=_b_.tuple
 if(res.length==0){res.push(_b_.object)}
 return res
 case "__class__":
 return klass.__class__
 case "__doc__":
 return klass.__doc__ ||_b_.None
 case "__setattr__":
 if(klass["__setattr__"]!==undefined){var func=klass["__setattr__"]}else{var func=function(obj,key,value){obj[key]=value}}
 return method_wrapper.$factory(attr,klass,func)
 case "__delattr__":
 if(klass["__delattr__"]!==undefined){return klass["__delattr__"]}
 return method_wrapper.$factory(attr,klass,function(key){delete klass[key]})}
 var res=klass[attr]
 var $test=false 
 if($test){console.log("attr",attr,"of",klass,res,res+"")}
 if(res===undefined && klass.__slots__ &&
 klass.__slots__.indexOf(attr)>-1){return member_descriptor.$factory(attr,klass)}
 if(klass.__class__ &&
 klass.__class__[attr]&&
 klass.__class__[attr].__get__ &&
 klass.__class__[attr].__set__){
 if($test){console.log("data descriptor")}
 return klass.__class__[attr].__get__(klass)}
 if(res===undefined){
 var v=klass[attr]
 if(v===undefined){var mro=klass.__mro__
 if(mro===undefined){console.log("pas de mro pour",klass)}
 for(var i=0;i < mro.length;i++){var v=mro[i][attr]
 if(v !==undefined){res=v
 break}}}else{res=v}
 if(res===undefined){
 var meta=klass.__class__ ||$B.get_class(klass),res=meta[attr]
 if($test){console.log("search in meta",meta,res)}
 if(res===undefined){var meta_mro=meta.__mro__
 for(var i=0;i < meta_mro.length;i++){var res=meta_mro[i][attr]
 if(res !==undefined){break}}}
 if(res !==undefined){if($test){console.log("found in meta",res,typeof res)}
 if(res.__class__===_b_.property){return res.fget(klass)}
 if(typeof res=="function"){
 var meta_method=res.bind(null,klass)
 meta_method.__class__=$B.method
 meta_method.$infos={__self__:klass,__func__:res,__name__:attr,__qualname__:klass.$infos.__name__+"."+attr,__module__:res.$infos ? res.$infos.__module__ :""}
 return meta_method}}
 if(res===undefined){
 var getattr=meta.__getattr__
 if(getattr===undefined){for(var i=0;i < meta_mro.length;i++){if(meta_mro[i].__getattr__ !==undefined){getattr=meta_mro[i].__getattr__
 break}}}
 if(getattr !==undefined){return getattr(klass,attr)}}}}
 if(res !==undefined){if($test){console.log("res",res)}
 if(res.__class__===_b_.property){return res}
 if(res.__get__){if(res.__class__===method){var result=res.__get__(res.__func__,klass)
 result.$infos={__func__:res,__name__:res.$infos.__name__,__qualname__:klass.$infos.__name__+"."+res.$infos.__name__,__self__:klass}}else{result=res.__get__(klass)}
 return result}else if(res.__class__ && res.__class__.__get__){
 if(!(attr.startsWith("__")&& attr.endsWith("__"))){return res.__class__.__get__(res,_b_.None,klass)}}
 if(typeof res=="function"){
 if(res.$infos===undefined && $B.debug > 1){console.log("warning: no attribute $infos for",res,"klass",klass,"attr",attr)}
 if($test){console.log("res is function",res)}
 if(attr=="__new__"){res.$type="staticmethod"}
 if(attr=="__class_getitem__" && res.__class__ !==$B.method){res=_b_.classmethod.$factory(res)}
 if(attr=="__init_subclass__"){res=_b_.classmethod.$factory(res)}
 if(res.__class__===$B.method){return res.__get__(null,klass)}else{if($test){console.log("return res",res)}
 return res}}else{return res}}}
 type.__hash__=function(cls){return _b_.hash(cls)}
 type.__init__=function(){}
 type.__init_subclass__=function(){
 var $=$B.args("__init_subclass__",1,{},[],arguments,{},"args","kwargs")
 if($.kwargs !==undefined){if($.kwargs.__class__ !==_b_.dict ||
 Object.keys($.kwargs.$string_dict).length > 0){throw _b_.TypeError.$factory(
 "__init_subclass__() takes no keyword arguments")}}
 return _b_.None}
 type.__instancecheck__=function(cls,instance){var kl=instance.__class__ ||$B.get_class(instance)
 if(kl===cls){return true}
 else{for(var i=0;i < kl.__mro__.length;i++){if(kl.__mro__[i]===cls){return true}}}
 return false}
 type.__instancecheck__.$type="staticmethod"
 type.__name__={__get__:function(self){return self.$infos.__name__},__set__:function(self,value){self.$infos.__name__=value},__str__:function(self){return "type"},__eq__:function(self,other){return self.$infos.__name__==other}}
 type.__new__=function(meta,name,bases,cl_dict){
 var module=cl_dict.$string_dict.__module__
 if(module){module=module[0]}
 var class_dict={__class__ :meta,__bases__ :bases,__dict__ :cl_dict,$infos:{__name__:name.replace("$$",""),__module__:module},$is_class:true,$has_setattr:cl_dict.$has_setattr}
 class_dict.__mro__=type.mro(class_dict).slice(1)
 var items=$B.dict_to_list(cl_dict)
 for(var i=0;i < items.length;i++){var key=$B.to_alias(items[i][0]),v=items[i][1]
 if(key==="__module__"){continue}
 if(v===undefined){continue}
 class_dict[key]=v
 if(v.__class__){
 var set_name=$B.$getattr(v.__class__,"__set_name__",_b_.None)
 if(set_name !==_b_.None){set_name(v,class_dict,key)}}
 if(typeof v=="function"){if(v.$infos===undefined){console.log("type new",v,v+"")
 console.log($B.frames_stack.slice())}
 v.$infos.$class=class_dict
 v.$infos.__qualname__=name+'.'+v.$infos.__name__
 if(v.$infos.$defaults){
 var $defaults=v.$infos.$defaults
 $B.Function.__setattr__(v,"__defaults__",$defaults)}}}
 return class_dict}
 type.__repr__=type.__str__=function(kls){if(kls.$infos===undefined){console.log("no $infos",kls)}
 var qualname=kls.$infos.__qualname__
 if(kls.$infos.__module__ &&
 kls.$infos.__module__ !="builtins" &&
 !kls.$infos.__module__.startsWith("$")){qualname=kls.$infos.__module__+"."+qualname}
 return "<class '"+qualname+"'>"}
 type.__prepare__=function(){return $B.empty_dict()}
 type.__qualname__={__get__:function(self){return self.$infos.__qualname__ ||self.$infos.__name__},__set__:function(self,value){self.$infos.__qualname__=value},__str__:function(self){console.log("type.__qualname__")},__eq__:function(self,other){return self.$infos.__qualname__==other}}
 type.mro=function(cls){
 var bases=cls.__bases__,seqs=[],pos1=0
 for(var i=0;i < bases.length;i++){
 if(bases[i]===_b_.str){bases[i]=$B.StringSubclass}
 var bmro=[],pos=0
 if(bases[i]===undefined ||
 bases[i].__mro__===undefined){if(bases[i].__class__===undefined){
 return[_b_.object]}else{throw _b_.TypeError.$factory(
 "Object passed as base class is not a class")}}
 bmro[pos++]=bases[i]
 var _tmp=bases[i].__mro__
 if(_tmp[0]===bases[i]){_tmp.splice(0,1)}
 for(var k=0;k < _tmp.length;k++){bmro[pos++]=_tmp[k]}
 seqs[pos1++]=bmro}
 if(bases.indexOf(_b_.object)==-1){bases=bases.concat(_b_.tuple.$factory([_b_.object]))}
 seqs[pos1++]=bases.slice()
 var mro=[cls],mpos=1
 while(1){var non_empty=[],pos=0
 for(var i=0;i < seqs.length;i++){if(seqs[i].length > 0){non_empty[pos++]=seqs[i]}}
 if(non_empty.length==0){break}
 for(var i=0;i < non_empty.length;i++){var seq=non_empty[i],candidate=seq[0],not_head=[],pos=0
 for(var j=0;j < non_empty.length;j++){var s=non_empty[j]
 if(s.slice(1).indexOf(candidate)>-1){not_head[pos++]=s}}
 if(not_head.length > 0){candidate=null}
 else{break}}
 if(candidate===null){throw _b_.TypeError.$factory(
 "inconsistent hierarchy, no C3 MRO is possible")}
 mro[mpos++]=candidate
 for(var i=0;i < seqs.length;i++){var seq=seqs[i]
 if(seq[0]===candidate){
 seqs[i].shift()}}}
 if(mro[mro.length-1]!==_b_.object){mro[mpos++]=_b_.object}
 return mro}
 type.__subclasscheck__=function(self,subclass){
 var klass=self
 if(klass===_b_.str){klass=$B.StringSubclass}else if(klass===_b_.float){klass=$B.FloatSubclass}
 if(subclass.__bases__===undefined){return self===_b_.object}
 return subclass.__bases__.indexOf(klass)>-1}
 $B.set_func_names(type,"builtins")
 _b_.type=type
 var wrapper_descriptor=$B.make_class("wrapper_descriptor")
 $B.set_func_names(wrapper_descriptor,"builtins")
 type.__call__.__class__=wrapper_descriptor
 var $instance_creator=$B.$instance_creator=function(klass){
 if(klass.$instanciable !==undefined){return function(){throw _b_.TypeError.$factory(
 "Can't instantiate abstract class interface "+
 "with abstract methods")}}
 var metaclass=klass.__class__,call_func,factory
 if(metaclass===_b_.type &&(!klass.__bases__ ||klass.__bases__.length==0)){if(klass.hasOwnProperty("__new__")){if(klass.hasOwnProperty("__init__")){factory=function(){
 var obj=klass.__new__.bind(null,klass).
 apply(null,arguments)
 klass.__init__.bind(null,obj).apply(null,arguments)
 return obj}}else{factory=function(){return klass.__new__.bind(null,klass).
 apply(null,arguments)}}}else if(klass.hasOwnProperty("__init__")){factory=function(){var obj={__class__:klass,__dict__:$B.empty_dict()}
 klass.__init__.bind(null,obj).apply(null,arguments)
 return obj}}else{factory=function(){if(arguments.length > 0){if(arguments.length==1 && arguments[0].$nat &&
 Object.keys(arguments[0].kw).length==0){}else{throw _b_.TypeError.$factory("object() takes no parameters")}}
 return{__class__:klass,__dict__:$B.empty_dict()}}}}else{call_func=_b_.type.__getattribute__(metaclass,"__call__")
 var factory=function(){return call_func.bind(null,klass).apply(null,arguments)}}
 factory.__class__=$B.Function
 factory.$infos={__name__:klass.$infos.__name__,__module__:klass.$infos.__module__}
 return factory}
 var method_wrapper=$B.method_wrapper=$B.make_class("method_wrapper",function(attr,klass,method){var f=function(){return method.apply(null,arguments)}
 f.$infos={__name__:attr,__module__:klass.__module__}
 return f}
 )
 method_wrapper.__str__=method_wrapper.__repr__=function(self){return "<method '"+self.$infos.__name__+"' of function object>"}
 var member_descriptor=$B.make_class("member_descriptor",function(attr,cls){return{__class__:member_descriptor,cls:cls,attr:attr}}
 )
 member_descriptor.__str__=member_descriptor.__repr__=function(self){return "<member '"+self.attr+"' of '"+self.cls.$infos.__name__+
 "' objects>"}
 $B.set_func_names(member_descriptor,"builtins")
 var method=$B.method=$B.make_class("method",function(func,cls){var f=function(){return $B.$call(func).bind(null,cls).apply(null,arguments)}
 f.__class__=method
 f.$infos=func.$infos
 return f}
 )
 method.__eq__=function(self,other){return self.$infos !==undefined &&
 other.$infos !==undefined &&
 self.$infos.__func__===other.$infos.__func__ &&
 self.$infos.__self__===other.$infos.__self__}
 method.__ne__=function(self,other){return ! $B.method.__eq__(self,other)}
 method.__get__=function(self){var f=function(){return self(arguments)}
 f.__class__=$B.method_wrapper
 f.$infos=method.$infos
 return f}
 method.__getattribute__=function(self,attr){
 var infos=self.$infos
 if(infos && infos[attr]){if(attr=="__code__"){var res={__class__:$B.Code}
 for(var attr in infos.__code__){res[attr]=infos.__code__[attr]}
 return res}else{return infos[attr]}}else if(method.hasOwnProperty(attr)){return _b_.object.__getattribute__(self,attr)}else{
 return $B.Function.__getattribute__(self.$infos.__func__,attr)}}
 method.__repr__=method.__str__=function(self){return "<bound method "+self.$infos.__qualname__+
 " of "+_b_.str.$factory(self.$infos.__self__)+">"}
 method.__setattr__=function(self,key,value){
 if(key=="__class__"){throw _b_.TypeError.$factory("__class__ assignment only supported "+
 "for heap types or ModuleType subclasses")}
 throw _b_.AttributeError.$factory("'method' object has no attribute '"+
 key+"'")}
 $B.set_func_names(method,"builtins")
 $B.method_descriptor=$B.make_class("method_descriptor")
 $B.classmethod_descriptor=$B.make_class("classmethod_descriptor")
 $B.GenericAlias=$B.make_class("GenericAlias",function(origin_class,items){return{
 __class__:$B.GenericAlias,origin_class,items}}
 )
 $B.GenericAlias.__args__={__get__:function(self){return $B.fast_tuple(self.items)}}
 $B.GenericAlias.__call__=function(self,...args){return self.origin_class.$factory.apply(null,args)}
 $B.GenericAlias.__eq__=function(self,other){return $B.rich_comp("__eq__",self.origin_class,other.origin_class)&&
 $B.rich_comp("__eq__",self.items,other.items)}
 $B.GenericAlias.__getitem__=function(self,item){throw _b_.TypeError.$factory("descriptor '__getitem__' for '"+
 self.origin_class.$infos.__name__+"' objects doesn't apply to a '"+
 $B.class_name(item)+"' object")}
 $B.GenericAlias.__origin__={__get__:function(self){return self.origin_class}}
 $B.GenericAlias.__parameters__={__get__:function(self){
 return $B.fast_tuple([])}}
 $B.GenericAlias.__repr__=function(self){var items=self.items
 for(var i=0,len=items.length;i < len;i++){if(items[i]===_b_.Ellipsis){items[i]='...'}else{items[i]=items[i].$infos.__name__}}
 return self.origin_class.$infos.__qualname__+'['+
 items.join(", ")+']'}
 _b_.object.__class__=type})(__BRYTHON__)
 ;
 ;(function($B){var _b_=$B.builtins,_window=self,isWebWorker=('undefined' !==typeof WorkerGlobalScope)&&
 ("function"===typeof importScripts)&&
 (navigator instanceof WorkerNavigator)
 $B.args=function($fname,argcount,slots,var_names,args,$dobj,extra_pos_args,extra_kw_args){
 if($fname.startsWith("lambda_"+$B.lambda_magic)){$fname="<lambda>"}
 var has_kw_args=false,nb_pos=args.length,filled=0,extra_kw,only_positional
 var end_positional=var_names.indexOf("/")
 if(end_positional !=-1){var_names.splice(end_positional,1)
 only_positional=var_names.slice(0,end_positional)}
 if(nb_pos > 0 && args[nb_pos-1].$nat){nb_pos--
 if(Object.keys(args[nb_pos].kw).length > 0){has_kw_args=true
 var kw_args=args[nb_pos].kw
 if(Array.isArray(kw_args)){var kwa=kw_args[0]
 for(var i=1,len=kw_args.length;i < len;i++){var kw_arg=kw_args[i]
 if(kw_arg.__class__===_b_.dict){for(var k in kw_arg.$numeric_dict){throw _b_.TypeError.$factory($fname+
 "() keywords must be strings")}
 for(var k in kw_arg.$object_dict){throw _b_.TypeError.$factory($fname+
 "() keywords must be strings")}
 for(var k in kw_arg.$string_dict){if(kwa[k]!==undefined){throw _b_.TypeError.$factory($fname+
 "() got multiple values for argument '"+
 k+"'")}
 kwa[k]=kw_arg.$string_dict[k][0]}}else{var it=_b_.iter(kw_arg),getitem=$B.$getattr(kw_arg,'__getitem__')
 while(true){try{var k=_b_.next(it)
 if(typeof k !=="string"){throw _b_.TypeError.$factory($fname+
 "() keywords must be strings")}
 if(kwa[k]!==undefined){throw _b_.TypeError.$factory($fname+
 "() got multiple values for argument '"+
 k+"'")}
 kwa[k]=getitem(k)}catch(err){if($B.is_exc(err,[_b_.StopIteration])){break}
 throw err}}}}
 kw_args=kwa}}}
 if(extra_pos_args){slots[extra_pos_args]=[]
 slots[extra_pos_args].__class__=_b_.tuple}
 if(extra_kw_args){
 extra_kw=$B.empty_dict()}
 if(nb_pos > argcount){
 if(extra_pos_args===null ||extra_pos_args=="*"){
 msg=$fname+"() takes "+argcount+" positional argument"+
 (argcount > 1 ? "s" :"")+" but more were given"
 throw _b_.TypeError.$factory(msg)}else{
 for(var i=argcount;i < nb_pos;i++){slots[extra_pos_args].push(args[i])}
 nb_pos=argcount}}
 for(var i=0;i < nb_pos;i++){slots[var_names[i]]=args[i]
 filled++}
 if(filled==argcount && argcount===var_names.length &&
 ! has_kw_args){if(extra_kw_args){slots[extra_kw_args]=extra_kw}
 return slots}
 if(has_kw_args){for(var key in kw_args){var value=kw_args[key],key1=$B.to_alias(key)
 if(slots[key1]===undefined){
 if(extra_kw_args){
 if(key.substr(0,2)=="$$"){key=key.substr(2)}
 extra_kw.$string_dict[key]=[value,extra_kw.$order++]}else{throw _b_.TypeError.$factory($fname+
 "() got an unexpected keyword argument '"+key+"'")}}else if(slots[key1]!==null){
 throw _b_.TypeError.$factory($fname+
 "() got multiple values for argument '"+key+"'")}else if(only_positional && only_positional.indexOf(key1)>-1){throw _b_.TypeError.$factory($fname+"() got an "+
 "unexpected keyword argument '"+key+"'")}else{
 slots[key1]=value}}}
 var missing=[]
 for(var attr in slots){if(slots[attr]===null){if($dobj[attr]!==undefined){slots[attr]=$dobj[attr]}
 else{missing.push("'"+attr+"'")}}}
 if(missing.length > 0){if(missing.length==1){throw _b_.TypeError.$factory($fname+
 " missing 1 positional argument: "+missing[0])}else{var msg=$fname+" missing "+missing.length+
 " positional arguments: "
 msg+=missing.join(" and ")
 throw _b_.TypeError.$factory(msg)}}
 if(extra_kw_args){slots[extra_kw_args]=extra_kw}
 return slots}
 $B.wrong_nb_args=function(name,received,expected,positional){if(received < expected){var missing=expected-received
 throw _b_.TypeError.$factory(name+"() missing "+missing+
 " positional argument"+(missing > 1 ? "s" :"")+": "+
 positional.slice(received))}else{throw _b_.TypeError.$factory(name+"() takes "+expected+
 " positional argument"+(expected > 1 ? "s" :"")+
 " but more were given")}}
 $B.get_class=function(obj){
 if(obj===null){return $B.$NoneDict}
 if(obj===undefined){return $B.UndefinedClass}
 var klass=obj.__class__
 if(klass===undefined){switch(typeof obj){case "number":
 if(obj % 1===0){
 return _b_.int}
 return _b_.float
 case "string":
 return _b_.str
 case "boolean":
 return _b_.bool
 case "function":
 if(obj.$is_js_func){
 return $B.JSObj}
 obj.__class__=$B.Function
 return $B.Function
 case "object":
 if(Array.isArray(obj)){if(Object.getPrototypeOf(obj)===Array.prototype){obj.__class__=_b_.list
 return _b_.list}}else if(obj.constructor===Number){return _b_.float}else if(typeof Node !=="undefined" 
 && obj instanceof Node){return $B.DOMNode}
 break}}
 if(klass===undefined){return $B.JSObj}
 return klass}
 $B.class_name=function(obj){var klass=$B.get_class(obj)
 if(klass===$B.JSObj){return 'Javascript '+obj.constructor.name}else{return klass.$infos.__name__}}
 $B.$list_comp=function(items){
 var ix=$B.UUID(),py="x"+ix+" = []\n",indent=0
 for(var i=1,len=items.length;i < len;i++){var item=items[i].replace(/\s+$/,"").replace(/\n/g,"")
 py+=" ".repeat(indent)+item+":\n"
 indent+=4}
 py+=" ".repeat(indent)
 py+="x"+ix+".append("+items[0]+")\n"
 return[py,ix]}
 $B.$dict_comp=function(module_name,parent_scope,items,line_num){
 var ix=$B.UUID(),res="comp_result_"+$B.lambda_magic+ix,py=res+" = {}\n",
 indent=0
 for(var i=1,len=items.length;i < len;i++){var item=items[i].replace(/\s+$/,"").replace(/\n/g,"")
 py+="    ".repeat(indent)+item+":\n"
 indent++}
 py+="    ".repeat(indent)+res+".update({"+items[0]+"})"
 var line_info=line_num+','+module_name
 var dictcomp_name="dc"+ix,root=$B.py2js(
 {src:py,is_comp:true,line_info:line_info},module_name,dictcomp_name,parent_scope,line_num),outer_expr=root.outermost_expr.to_js(),js=root.to_js()
 js+='\nreturn '+res+'\n'
 js="(function(expr){"+js+"})("+outer_expr+")"
 $B.clear_ns(dictcomp_name)
 delete $B.$py_src[dictcomp_name]
 return js}
 $B.$gen_expr=function(module_name,parent_scope,items,line_num,set_comp){
 var ix=$B.UUID(),genexpr_name=(set_comp ? "set_comp"+$B.lambda_magic :"__ge")+ix,py=`def ${genexpr_name}(expr):\n`,
 indent=1
 for(var i=1,len=items.length;i < len;i++){var item=items[i].replace(/\s+$/,"").replace(/\n/g,"")
 py+=" ".repeat(indent)+item+":\n"
 indent+=4}
 py+=" ".repeat(indent)
 py+="yield ("+items[0]+")"
 var line_info=line_num+','+module_name
 var root=$B.py2js({src:py,is_comp:true,line_info:line_info,ix:ix},genexpr_name,genexpr_name,parent_scope,line_num),js=root.to_js(),lines=js.split("\n")
 if(root.outermost_expr===undefined){console.log("no outermost",module_name,parent_scope)}
 var outer_expr=root.outermost_expr.to_js()
 js=lines.join("\n")
 js+="\nvar $res = $B.generator.$factory("+genexpr_name+
 ')('+outer_expr+');\nreturn $res\n'
 js="(function($locals_"+genexpr_name+"){"+js+"})($locals)\n"
 return js}
 $B.copy_namespace=function(){var ns={}
 for(const frame of $B.frames_stack){for(const kv of[frame[1],frame[3]]){for(var key in kv){if(key.startsWith('$$')||!key.startsWith('$')){ns[key]=kv[key]}}}}
 return ns}
 $B.clear_ns=function(name){
 if(name.startsWith("__ge")){console.log("clear ns",name)}
 var len=name.length
 for(var key in $B.$py_module_path){if(key.substr(0,len)==name){$B.$py_module_path[key]=null
 delete $B.$py_module_path[key]}}
 $B.$py_src[name]=null
 delete $B.$py_src[name]
 var alt_name=name.replace(/\./g,"_")
 if(alt_name !=name){$B.clear_ns(alt_name)}}
 $B.from_alias=function(attr){if(attr.substr(0,2)=="$$" && $B.aliased_names[attr.substr(2)]){return attr.substr(2)}
 return attr}
 $B.$search=function(name,global_ns){
 var frame=$B.last($B.frames_stack)
 if(frame[1][name]!==undefined){return frame[1][name]}
 else if(frame[3][name]!==undefined){return frame[3][name]}
 else if(_b_[name]!==undefined){return _b_[name]}
 else{if(frame[0]==frame[2]||frame[1].$type=="class" ||
 frame[1].$exec_locals){throw _b_.NameError.$factory(
 "name '"+name+"' is not defined")}
 else{throw _b_.UnboundLocalError.$factory("local variable '"+
 name+"' referenced before assignment")}}}
 $B.$global_search=function(name,search_ids){
 var ns={}
 for(var i=0;i< $B.frames_stack.length;i++){var frame=$B.frames_stack[i]
 if(search_ids.indexOf(frame[0])>-1 &&
 frame[1][name]!==undefined){return frame[1][name]}
 if(search_ids.indexOf(frame[2])>-1 &&
 frame[3][name]!==undefined){return frame[3][name]}}
 for(var i=0;i < search_ids.length;i++){var search_id=search_ids[i]
 if($B.imported[search_id]&& $B.imported[search_id][name]){return $B.imported[search_id][name]}}
 throw _b_.NameError.$factory("name '"+$B.from_alias(name)+
 "' is not defined")}
 $B.$local_search=function(name){
 var frame=$B.last($B.frames_stack)
 if(frame[1][name]!==undefined){return frame[1][name]}
 else{throw _b_.UnboundLocalError.$factory("local variable '"+
 $B.from_alias(name)+"' referenced before assignment")}}
 $B.$check_def=function(name,value){
 if(value !==undefined){return value}else if(_b_[name]!==undefined){
 return _b_[name]}else{var frame=$B.last($B.frames_stack)
 if(frame[3][name]!==undefined){return frame[3][name]}}
 throw _b_.NameError.$factory("name '"+$B.from_alias(name)+
 "' is not defined")}
 $B.$check_def_local=function(name,value){
 if(value !==undefined){return value}
 throw _b_.UnboundLocalError.$factory("local variable '"+
 $B.from_alias(name)+"' referenced before assignment")}
 $B.$check_def_free=function(name,value){
 if(value !==undefined){return value}
 var res
 for(var i=$B.frames_stack.length-1;i >=0;i--){res=$B.frames_stack[i][1][name]
 if(res !==undefined){return res}
 res=$B.frames_stack[i][3][name]
 if(res !==undefined){return res}}
 throw _b_.NameError.$factory("free variable '"+$B.from_alias(name)+
 "' referenced before assignment in enclosing scope")}
 $B.$check_def_free1=function(name,scope_id){
 var res
 for(var i=$B.frames_stack.length-1;i >=0;i--){var frame=$B.frames_stack[i]
 res=frame[1][name]
 if(res !==undefined){return res}
 if(frame[1].$parent){res=frame[1].$parent[name]
 if(res !==undefined){return res}}
 if(frame[2]==scope_id){res=frame[3][name]
 if(res !==undefined){return res}}}
 throw _b_.NameError.$factory("free variable '"+$B.from_alias(name)+
 "' referenced before assignment in enclosing scope")}
 $B.$JS2Py=function(src){if(typeof src==="number"){if(src % 1===0){return src}
 return _b_.float.$factory(src)}
 if(src===null ||src===undefined){return _b_.None}
 if(Array.isArray(src)&&
 Object.getPrototypeOf(src)===Array.prototype){src.$brython_class="js" }
 return src}
 $B.list_key=function(obj,key){key=$B.$GetInt(key)
 if(key < 0){key+=obj.length}
 var res=obj[key]
 if(res===undefined){throw _b_.IndexError.$factory("list index out of range")}
 return res}
 $B.list_slice=function(obj,start,stop){if(start===null){start=0}
 else{start=$B.$GetInt(start)
 if(start < 0){start=Math.max(0,start+obj.length)}}
 if(stop===null){return obj.slice(start)}
 stop=$B.$GetInt(stop)
 if(stop < 0){stop=Math.max(0,stop+obj.length)}
 return obj.slice(start,stop)}
 $B.list_slice_step=function(obj,start,stop,step){if(step===null ||step==1){return $B.list_slice(obj,start,stop)}
 if(step==0){throw _b_.ValueError.$factory("slice step cannot be zero")}
 step=$B.$GetInt(step)
 if(start===null){start=step >=0 ? 0 :obj.length-1}
 else{start=$B.$GetInt(start)
 if(start < 0){start=Math.min(0,start+obj.length)}}
 if(stop===null){stop=step >=0 ? obj.length :-1}
 else{stop=$B.$GetInt(stop)
 if(stop < 0){stop=Math.max(0,stop+obj.length)}}
 var res=[]
 if(step > 0){for(var i=start;i < stop;i+=step){res.push(obj[i])}}else{for(var i=start;i > stop;i+=step){res.push(obj[i])}}
 return res}
 function index_error(obj){var type=typeof obj=="string" ? "string" :"list"
 throw _b_.IndexError.$factory(type+" index out of range")}
 $B.$getitem=function(obj,item){var is_list=Array.isArray(obj)&& obj.__class__===_b_.list
 if(typeof item=="number"){if(is_list ||typeof obj=="string"){item=item >=0 ? item :obj.length+item
 if(obj[item]!==undefined){return obj[item]}
 else{index_error(obj)}}}
 try{item=$B.$GetInt(item)}catch(err){}
 if((is_list ||typeof obj=="string")
 && typeof item=="number"){item=item >=0 ? item :obj.length+item
 if(obj[item]!==undefined){return obj[item]}
 else{index_error(obj)}}
 if(obj.$is_class){var class_gi=$B.$getattr(obj,"__class_getitem__",_b_.None)
 if(class_gi !==_b_.None){return class_gi(item)}else if(obj.__class__){class_gi=$B.$getattr(obj.__class__,"__getitem__",_b_.None)
 if(class_gi !==_b_.None){return class_gi(obj,item)}}}
 if(is_list){return _b_.list.$getitem(obj,item)}
 var gi=$B.$getattr(obj,"__getitem__",_b_.None)
 if(gi !==_b_.None){return gi(item)}
 throw _b_.TypeError.$factory("'"+$B.class_name(obj)+
 "' object is not subscriptable")}
 $B.getitem_slice=function(obj,slice){var res
 if(Array.isArray(obj)){if(slice.start===_b_.None && slice.stop===_b_.None){if(slice.step===_b_.None ||slice.step==1){res=obj.slice()}else if(slice.step==-1){res=obj.slice().reverse()}}else if(slice.step===_b_.None){if(slice.start===_b_.None){slice.start=0}
 if(slice.stop===_b_.None){slice.stop=obj.length}
 if(typeof slice.start=="number" &&
 typeof slice.stop=="number"){if(slice.start < 0){slice.start+=obj.length}
 if(slice.stop < 0){slice.stop+=obj.length}
 res=obj.slice(slice.start,slice.stop)}}
 if(res){res.__class__=obj.__class__ 
 return res}else{return _b_.list.$getitem(obj,slice)}}
 return $B.$getattr(obj,"__getitem__")(slice)}
 $B.set_list_key=function(obj,key,value){try{key=$B.$GetInt(key)}
 catch(err){if(_b_.isinstance(key,_b_.slice)){var s=_b_.slice.$conv_for_seq(key,obj.length)
 return $B.set_list_slice_step(obj,s.start,s.stop,s.step,value)}}
 if(key < 0){key+=obj.length}
 if(obj[key]===undefined){console.log(obj,key)
 throw _b_.IndexError.$factory("list assignment index out of range")}
 obj[key]=value}
 $B.set_list_slice=function(obj,start,stop,value){if(start===null){start=0}
 else{start=$B.$GetInt(start)
 if(start < 0){start=Math.max(0,start+obj.length)}}
 if(stop===null){stop=obj.length}
 stop=$B.$GetInt(stop)
 if(stop < 0){stop=Math.max(0,stop+obj.length)}
 var res=_b_.list.$factory(value)
 obj.splice.apply(obj,[start,stop-start].concat(res))}
 $B.set_list_slice_step=function(obj,start,stop,step,value){if(step===null ||step==1){return $B.set_list_slice(obj,start,stop,value)}
 if(step==0){throw _b_.ValueError.$factory("slice step cannot be zero")}
 step=$B.$GetInt(step)
 if(start===null){start=step > 0 ? 0 :obj.length-1}else{start=$B.$GetInt(start)}
 if(stop===null){stop=step > 0 ? obj.length :-1}else{stop=$B.$GetInt(stop)}
 var repl=_b_.list.$factory(value),j=0,test,nb=0
 if(step > 0){test=function(i){return i < stop}}
 else{test=function(i){return i > stop}}
 for(var i=start;test(i);i+=step){nb++}
 if(nb !=repl.length){throw _b_.ValueError.$factory(
 "attempt to assign sequence of size "+repl.length+
 " to extended slice of size "+nb)}
 for(var i=start;test(i);i+=step){obj[i]=repl[j]
 j++}}
 $B.$setitem=function(obj,item,value){if(Array.isArray(obj)&& obj.__class__===undefined &&
 typeof item=="number" &&
 !_b_.isinstance(obj,_b_.tuple)){if(item < 0){item+=obj.length}
 if(obj[item]===undefined){throw _b_.IndexError.$factory("list assignment index out of range")}
 obj[item]=value
 return}else if(obj.__class__===_b_.dict){_b_.dict.$setitem(obj,item,value)
 return}else if(obj.__class__===_b_.list){return _b_.list.$setitem(obj,item,value)}
 $B.$getattr(obj,"__setitem__")(item,value)}
 $B.augm_item_add=function(obj,item,incr){if(Array.isArray(obj)&& typeof item=="number" &&
 obj[item]!==undefined){if(Array.isArray(obj[item])&& Array.isArray(incr)){for(var i=0,len=incr.length;i < len;i++){obj[item].push(incr[i])}
 return}else if(typeof obj[item]=="string" && typeof incr=="string"){obj[item]+=incr
 return}}
 var ga=$B.$getattr
 try{var augm_func=ga(ga(obj,"__getitem__")(item),"__iadd__")}catch(err){ga(obj,"__setitem__")(item,ga(ga(obj,"__getitem__")(item),"__add__")(incr))
 return}
 augm_func(incr)}
 var augm_item_src=""+$B.augm_item_add
 var augm_ops=[["-=","sub"],["*=","mul"]]
 for(var i=0,len=augm_ops.length;i < len;i++){var augm_code=augm_item_src.replace(/add/g,augm_ops[i][1])
 augm_code=augm_code.replace(/\+=/g,augm_ops[i][0])
 eval("$B.augm_item_"+augm_ops[i][1]+"="+augm_code)}
 $B.extend=function(fname,arg){
 for(var i=2;i < arguments.length;i++){var mapping=arguments[i]
 var it=_b_.iter(mapping),getter=$B.$getattr(mapping,"__getitem__")
 while(true){try{var key=_b_.next(it)
 if(typeof key !=="string"){throw _b_.TypeError.$factory(fname+
 "() keywords must be strings")}
 if(arg[key]!==undefined){throw _b_.TypeError.$factory(fname+
 "() got multiple values for argument '"+key+"'")}
 arg[key]=getter(key)}catch(err){if(_b_.isinstance(err,[_b_.StopIteration])){break}
 throw err}}}
 return arg}
 $B.extend_list=function(){
 var res=Array.prototype.slice.call(arguments,0,arguments.length-1),last=$B.last(arguments)
 var it=_b_.iter(last)
 while(true){try{res.push(_b_.next(it))}catch(err){if(_b_.isinstance(err,[_b_.StopIteration])){break}
 throw err}}
 return res}
 $B.$test_item=function(expr){
 $B.$test_result=expr
 return _b_.bool.$factory(expr)}
 $B.$test_expr=function(){
 return $B.$test_result}
 $B.$is=function(a,b){
 if(a instanceof Number && b instanceof Number){return a.valueOf()==b.valueOf()}
 if((a===_b_.int && b==$B.long_int)||
 (a===$B.long_int && b===_b_.int)){return true}
 return a===b}
 $B.$is_member=function(item,_set){
 var f,_iter,method
 try{method=$B.$getattr(_set.__class__ ||$B.get_class(_set),"__contains__")}
 catch(err){}
 if(method){return $B.$call(method)(_set,item)}
 try{_iter=_b_.iter(_set)}
 catch(err){}
 if(_iter){while(1){try{var elt=_b_.next(_iter)
 if($B.rich_comp("__eq__",elt,item)){return true}}catch(err){return false}}}
 try{f=$B.$getattr(_set,"__getitem__")}
 catch(err){throw _b_.TypeError.$factory("'"+$B.class_name(_set)+
 "' object is not iterable")}
 if(f){var i=-1
 while(1){i++
 try{var elt=f(i)
 if($B.rich_comp("__eq__",elt,item)){return true}}catch(err){if(err.__class__===_b_.IndexError){return false}
 throw err}}}}
 $B.$call=function(callable){if(callable.__class__===$B.method){return callable}
 else if(callable.$is_func ||typeof callable=="function"){return callable}else if(callable.$factory){return callable.$factory}else if(callable.$is_class){
 return callable.$factory=$B.$instance_creator(callable)}
 try{return $B.$getattr(callable,"__call__")}catch(err){throw _b_.TypeError.$factory("'"+$B.class_name(callable)+
 "' object is not callable")}}
 var $io=$B.make_class("io",function(out){return{
 __class__:$io,out}}
 )
 $io.flush=function(){}
 $io.write=function(self,msg){
 console[self.out](msg)
 return _b_.None}
 if(console.error !==undefined){$B.stderr=$io.$factory("error")}else{$B.stderr=$io.$factory("log")}
 $B.stdout=$io.$factory("log")
 $B.stdin={__class__:$io,__original__:true,closed:false,len:1,pos:0,read:function(){return ""},readline:function(){return ""}}
 $B.make_iterator_class=function(name){
 var klass={__class__:_b_.type,__mro__:[_b_.object],$factory:function(items){return{
 __class__:klass,__dict__:$B.empty_dict(),counter:-1,items:items,len:items.length}},$infos:{__name__:name},$is_class:true,__iter__:function(self){self.counter=self.counter===undefined ?-1 :self.counter
 self.len=self.items.length
 return self},__len__:function(self){return self.items.length},__next__:function(self){if(typeof self.len_func=="function" &&
 self.len_func()!=self.len){throw _b_.RuntimeError.$factory(
 "dictionary changed size during iteration")}
 self.counter++
 if(self.counter < self.items.length){var item=self.items[self.counter]
 if(self.items.$brython_class=="js"){
 item=$B.$JS2Py(item)}
 return item}
 throw _b_.StopIteration.$factory("StopIteration")},__reduce_ex__:function(self,protocol){return $B.fast_tuple([_b_.iter,_b_.tuple.$factory([self.items])])}}
 $B.set_func_names(klass,"builtins")
 return klass}
 function $err(op,klass,other){var msg="unsupported operand type(s) for "+op+" : '"+
 klass.$infos.__name__+"' and '"+$B.class_name(other)+"'"
 throw _b_.TypeError.$factory(msg)}
 var ropnames=["add","sub","mul","truediv","floordiv","mod","pow","lshift","rshift","and","xor","or"]
 var ropsigns=["+","-","*","/","//","%","**","<<",">>","&","^","|"]
 $B.make_rmethods=function(klass){for(var j=0,_len_j=ropnames.length;j < _len_j;j++){if(klass["__"+ropnames[j]+"__"]===undefined){klass["__"+ropnames[j]+"__"]=(function(name,sign){return function(self,other){try{return $B.$getattr(other,"__r"+name+"__")(self)}
 catch(err){$err(sign,klass,other)}}})(ropnames[j],ropsigns[j])}}}
 $B.UUID=function(){return $B.$py_UUID++}
 $B.InjectBuiltins=function(){var _str=["var _b_ = $B.builtins"],pos=1
 for(var $b in $B.builtins){_str[pos++]="var "+$b+'=_b_["'+$b+'"]'}
 return _str.join(";")}
 $B.$GetInt=function(value){
 if(typeof value=="number" ||value.constructor===Number){return value}
 else if(typeof value==="boolean"){return value ? 1 :0}
 else if(_b_.isinstance(value,_b_.int)){return value}
 else if(_b_.isinstance(value,_b_.float)){return value.valueOf()}
 if(! value.$is_class){try{var v=$B.$getattr(value,"__int__")();return v}catch(e){}
 try{var v=$B.$getattr(value,"__index__")();return v}catch(e){}}
 throw _b_.TypeError.$factory("'"+$B.class_name(value)+
 "' object cannot be interpreted as an integer")}
 $B.to_num=function(obj,methods){
 var expected_class={"__complex__":_b_.complex,"__float__":_b_.float,"__index__":_b_.int,"__int__":_b_.int}
 var klass=obj.__class__ ||$B.get_class(obj)
 for(var i=0;i < methods.length;i++){var missing={},method=$B.$getattr(klass,methods[i],missing)
 if(method !==missing){var res=method(obj)
 if(!_b_.isinstance(res,expected_class[methods[i]])){console.log(res,methods[i],expected_class[methods[i]])
 throw _b_.TypeError.$factory(methods[i]+"returned non-"+
 expected_class[methods[i]].$infos.__name__+
 "(type "+$B.get_class(res)+")")}
 return res}}
 return null}
 $B.PyNumber_Index=function(item){switch(typeof item){case "boolean":
 return item ? 1 :0
 case "number":
 return item
 case "object":
 if(item.__class__===$B.long_int){return item}
 if(_b_.isinstance(item,_b_.int)){
 return item.$brython_value}
 var method=$B.$getattr(item,"__index__",_b_.None)
 if(method !==_b_.None){method=typeof method=="function" ?
 method :$B.$getattr(method,"__call__")
 return $B.int_or_bool(method())}
 default:
 throw _b_.TypeError.$factory("'"+$B.class_name(item)+
 "' object cannot be interpreted as an integer")}}
 $B.int_or_bool=function(v){switch(typeof v){case "boolean":
 return v ? 1 :0
 case "number":
 return v
 case "object":
 if(v.__class__===$B.long_int){return v}
 else{throw _b_.TypeError.$factory("'"+$B.class_name(v)+
 "' object cannot be interpreted as an integer")}
 default:
 throw _b_.TypeError.$factory("'"+$B.class_name(v)+
 "' object cannot be interpreted as an integer")}}
 $B.enter_frame=function(frame){
 $B.frames_stack.push(frame)
 if($B.tracefunc && $B.tracefunc !==_b_.None){if(frame[4]===$B.tracefunc ||
 ($B.tracefunc.$infos && frame[4]&&
 frame[4]===$B.tracefunc.$infos.__func__)){
 $B.tracefunc.$frame_id=frame[0]
 return _b_.None}else{
 for(var i=$B.frames_stack.length-1;i >=0;i--){if($B.frames_stack[i][0]==$B.tracefunc.$frame_id){return _b_.None}}
 return $B.tracefunc($B._frame.$factory($B.frames_stack,$B.frames_stack.length-1),'call',_b_.None)}}
 return _b_.None}
 $B.trace_exception=function(){var top_frame=$B.last($B.frames_stack)
 if(top_frame[0]==$B.tracefunc.$current_frame_id){return _b_.None}
 var trace_func=top_frame[1].$f_trace,exc=top_frame[1].$current_exception,frame_obj=$B._frame.$factory($B.frames_stack,$B.frames_stack.length-1)
 return trace_func(frame_obj,'exception',$B.fast_tuple([exc.__class__,exc,$B.traceback.$factory(exc)]))}
 $B.trace_line=function(){var top_frame=$B.last($B.frames_stack)
 if(top_frame[0]==$B.tracefunc.$current_frame_id){return _b_.None}
 var trace_func=top_frame[1].$f_trace,frame_obj=$B._frame.$factory($B.frames_stack,$B.frames_stack.length-1)
 return trace_func(frame_obj,'line',_b_.None)}
 $B.set_line=function(line_info){
 var top_frame=$B.last($B.frames_stack)
 if($B.tracefunc && top_frame[0]==$B.tracefunc.$current_frame_id){return _b_.None}
 top_frame[1].$line_info=line_info
 var trace_func=top_frame[1].$f_trace
 if(trace_func !==_b_.None){var frame_obj=$B._frame.$factory($B.frames_stack,$B.frames_stack.length-1)
 top_frame[1].$ftrace=trace_func(frame_obj,'line',_b_.None)}
 return true}
 $B.trace_return=function(value){var top_frame=$B.last($B.frames_stack),trace_func=top_frame[1].$f_trace,frame_obj=$B._frame.$factory($B.frames_stack,$B.frames_stack.length-1)
 if(top_frame[0]==$B.tracefunc.$current_frame_id){
 return _b_.None}
 trace_func(frame_obj,'return',value)}
 function exit_ctx_managers_in_generators(frame){
 for(key in frame[1]){if(frame[1][key]&& frame[1][key].__class__==$B.generator){
 var gen_obj=frame[1][key]
 gen_obj.return()}}}
 $B.set_cm_in_generator=function(cm_exit){if(cm_exit !==undefined){$B.frames_stack.forEach(function(frame){frame[1].$cm_in_gen=frame[1].$cm_in_gen ||new Set()
 frame[1].$cm_in_gen.add(cm_exit)})}}
 $B.leave_frame=function(arg){
 if($B.frames_stack.length==0){console.log("empty stack");return}
 if(arg && arg.value !==undefined && $B.tracefunc){if($B.last($B.frames_stack)[1].$f_trace===undefined){$B.last($B.frames_stack)[1].$f_trace=$B.tracefunc}
 if($B.last($B.frames_stack)[1].$f_trace !==_b_.None){$B.trace_return(arg.value)}}
 var frame=$B.frames_stack.pop()
 frame[1].$current_exception=undefined
 if(frame[1].$close_generators){
 for(var i=0,len=frame[1].$close_generators.length;i < len;i++){var gen=frame[1].$close_generators[i]
 if(gen.$has_run){gen.return()}}}
 return _b_.None}
 $B.leave_frame_exec=function(arg){
 if($B.profile > 0){$B.$profile.return()}
 if($B.frames_stack.length==0){console.log("empty stack");return}
 var frame=$B.frames_stack.pop()
 exit_ctx_managers_in_generators(frame)
 for(var i=$B.frames_stack.length-1;i >=0;i--){if($B.frames_stack[i][2]==frame[2]){$B.frames_stack[i][3]=frame[3]}}}
 var min_int=Math.pow(-2,53),max_int=Math.pow(2,53)-1
 $B.is_safe_int=function(){for(var i=0;i < arguments.length;i++){var arg=arguments[i]
 if(arg < min_int ||arg > max_int){return false}}
 return true}
 $B.add=function(x,y){if(typeof x.valueOf()=="number" && typeof y.valueOf()=="number"){if(typeof x=="number" && typeof y=="number"){
 var z=x+y
 if(z < $B.max_int && z > $B.min_int){return z}else if(z===Infinity){return _b_.float.$factory("inf")}else if(z===-Infinity){return _b_.float.$factory("-inf")}else if(isNaN(z)){return _b_.float.$factory('nan')}
 return $B.long_int.__add__($B.long_int.$factory(x),$B.long_int.$factory(y))}else{
 return new Number(x+y)}}else if(typeof x=="string" && typeof y=="string"){
 return x+y}
 try{var method=$B.$getattr(x.__class__ ||$B.get_class(x),"__add__")}catch(err){if(err.__class__===_b_.AttributeError){throw _b_.TypeError.$factory("unsupported operand type(s) for "+
 "+: '"+$B.class_name(x)+"' and '"+$B.class_name(y)+"'")}
 throw err}
 var res=$B.$call(method)(x,y)
 if(res===_b_.NotImplemented){
 return $B.rich_op("add",x,y)}
 return res}
 $B.div=function(x,y){var z=x/y
 if(x > min_int && x < max_int && y > min_int && y < max_int
 && z > min_int && z < max_int){return z}
 else{return $B.long_int.__truediv__($B.long_int.$factory(x),$B.long_int.$factory(y))}}
 $B.eq=function(x,y){if(x > min_int && x < max_int && y > min_int && y < max_int){return x==y}
 return $B.long_int.__eq__($B.long_int.$factory(x),$B.long_int.$factory(y))}
 $B.floordiv=function(x,y){var z=x/y
 if(x > min_int && x < max_int && y > min_int && y < max_int
 && z > min_int && z < max_int){return Math.floor(z)}
 else{return $B.long_int.__floordiv__($B.long_int.$factory(x),$B.long_int.$factory(y))}}
 $B.mul=function(x,y){var z=(typeof x !="number" ||typeof y !="number")?
 new Number(x*y):x*y
 if(x > min_int && x < max_int && y > min_int && y < max_int
 && z > min_int && z < max_int){return z}
 else if((typeof x=="number" ||x.__class__===$B.long_int)
 &&(typeof y=="number" ||y.__class__===$B.long_int)){if((typeof x=="number" && isNaN(x))||
 (typeof y=="number" && isNaN(y))){return _b_.float.$factory("nan")}
 switch(x){case Infinity:
 case-Infinity:
 if(y==0){return _b_.float.$factory("nan")}else{return y > 0 ? x :-x}}
 return $B.long_int.__mul__($B.long_int.$factory(x),$B.long_int.$factory(y))}else{return z}}
 $B.sub=function(x,y){var z=(typeof x !="number" ||typeof y !="number")?
 new Number(x-y):x-y
 if(x > min_int && x < max_int && y > min_int && y < max_int
 && z > min_int && z < max_int){return z}else if((typeof x=="number" ||x.__class__===$B.long_int)
 &&(typeof y=="number" ||y.__class__===$B.long_int)){if((typeof x=="number" && isNaN(x))||
 (typeof y=="number" && isNaN(y))){return _b_.float.$factory("nan")}
 return $B.long_int.__sub__($B.long_int.$factory(x),$B.long_int.$factory(y))}else{return z}}
 $B.ge=function(x,y){if(typeof x=="number" && typeof y=="number"){return x >=y}
 else if(typeof x=="number" && typeof y !="number"){return ! y.pos}
 else if(typeof x !="number" && typeof y=="number"){return x.pos===true}else{return $B.long_int.__ge__(x,y)}}
 $B.gt=function(x,y){if(typeof x=="number" && typeof y=="number"){return x > y}
 else if(typeof x=="number" && typeof y !="number"){return ! y.pos}
 else if(typeof x !="number" && typeof y=="number"){return x.pos===true}else{return $B.long_int.__gt__(x,y)}}
 var reversed_op={"__lt__":"__gt__","__le__":"__ge__","__gt__":"__lt__","__ge__":"__le__"}
 var method2comp={"__lt__":"<","__le__":"<=","__gt__":">","__ge__":">="}
 $B.rich_comp=function(op,x,y){var x1=x.valueOf(),y1=y.valueOf()
 if(typeof x1=="number" && typeof y1=="number" &&
 x.__class__===undefined && y.__class__===undefined){switch(op){case "__eq__":
 return x1==y1
 case "__ne__":
 return x1 !=y1
 case "__le__":
 return x1 <=y1
 case "__lt__":
 return x1 < y1
 case "__ge__":
 return x1 >=y1
 case "__gt__":
 return x1 > y1}}
 var res,rev_op
 if(x.$is_class ||x.$factory){if(op=="__eq__"){return(x===y)}else if(op=="__ne__"){return !(x===y)}else{throw _b_.TypeError.$factory("'"+method2comp[op]+
 "' not supported between instances of '"+$B.class_name(x)+
 "' and '"+$B.class_name(y)+"'")}}
 if(x.__class__ && y.__class__){
 if(y.__class__.__mro__.indexOf(x.__class__)>-1){rev_op=reversed_op[op]||op
 var rev_func=$B.$getattr(y,rev_op)
 res=$B.$call($B.$getattr(y,rev_op))(x)
 if(res !==_b_.NotImplemented){return res}}}
 res=$B.$call($B.$getattr(x,op))(y)
 if(res !==_b_.NotImplemented){return res}
 rev_op=reversed_op[op]||op
 res=$B.$call($B.$getattr(y,rev_op))(x)
 if(res !==_b_.NotImplemented ){return res}
 if(op=="__eq__"){return _b_.False}
 else if(op=="__ne__"){return _b_.True}
 throw _b_.TypeError.$factory("'"+method2comp[op]+
 "' not supported between instances of '"+$B.class_name(x)+
 "' and '"+$B.class_name(y)+"'")}
 var opname2opsign={sub:"-",xor:"^",mul:"*"}
 $B.rich_op=function(op,x,y){var x_class=x.__class__ ||$B.get_class(x),y_class=y.__class__ ||$B.get_class(y),method
 if(x_class===y_class){
 if(x_class===_b_.int){return _b_.int["__"+op+"__"](x,y)}
 try{method=$B.$call($B.$getattr(x,"__"+op+"__"))}catch(err){if(err.__class__===_b_.AttributeError){var kl_name=$B.class_name(x)
 throw _b_.TypeError.$factory("unsupported operand type(s) "+
 "for "+opname2opsign[op]+" : '"+kl_name+"' and '"+
 kl_name+"'")}
 throw err}
 return method(y)}
 var res
 try{method=$B.$call($B.$getattr(x,"__"+op+"__"))}catch(err){if(err.__class__ !==_b_.AttributeError){throw err}
 res=$B.$call($B.$getattr(y,"__r"+op+"__"))(x)
 if(res !==_b_.NotImplemented){return res}
 throw _b_.TypeError.$factory("'"+(opname2opsign[op]||op)+
 "' not supported between instances of '"+$B.class_name(x)+
 "' and '"+$B.class_name(y)+"'")}
 res=method(y)
 if(res===_b_.NotImplemented){res=$B.$call($B.$getattr(y,"__r"+op+"__"))(x)
 if(res !==_b_.NotImplemented){return res}
 throw _b_.TypeError.$factory("'"+(opname2opsign[op]||op)+
 "' not supported between instances of '"+$B.class_name(x)+
 "' and '"+$B.class_name(y)+"'")}else{return res}}
 $B.is_none=function(o){return o===undefined ||o===null ||o==_b_.None}
 var repr_stack=new Set()
 $B.repr={enter:function(obj){if(repr_stack.has(obj)){return true}else{repr_stack.add(obj)}},leave:function(obj){repr_stack.delete(obj)}}})(__BRYTHON__)
 ;
 
 ;(function($B){var _b_=$B.builtins
 _b_.__debug__=false
 $B.$comps={'>':'gt','>=':'ge','<':'lt','<=':'le'}
 $B.$inv_comps={'>':'lt','>=':'le','<':'gt','<=':'ge'}
 var check_nb_args=$B.check_nb_args=function(name,expected,args){
 var len=args.length,last=args[len-1]
 if(last && last.$nat=="kw"){var kw=last.kw
 if(Array.isArray(kw)&& kw[1]&& kw[1].__class__===_b_.dict){if(Object.keys(kw[1].$string_dict).length==0){len--}}}
 if(len !=expected){if(expected==0){throw _b_.TypeError.$factory(name+"() takes no argument"+
 " ("+len+" given)")}else{throw _b_.TypeError.$factory(name+"() takes exactly "+
 expected+" argument"+(expected < 2 ? '' :'s')+
 " ("+len+" given)")}}}
 var check_no_kw=$B.check_no_kw=function(name,x,y){
 if(x===undefined){console.log("x undef",name,x,y)}
 if((x.$nat && x.kw && x.kw[0]&& x.kw[0].length > 0)||
 (y !==undefined && y.$nat)){throw _b_.TypeError.$factory(name+"() takes no keyword arguments")}}
 var NoneType={$factory:function(){return None},$infos:{__name__:"NoneType",__module__:"builtins"},__bool__:function(self){return False},__class__:_b_.type,__hash__:function(self){return 0},__mro__:[_b_.object],__repr__:function(self){return 'None'},__str__:function(self){return 'None'},$is_class:true}
 NoneType.__setattr__=function(self,attr){return no_set_attr(NoneType,attr)}
 var None={__class__:NoneType,}
 for(var $op in $B.$comps){
 var key=$B.$comps[$op]
 switch(key){case 'ge':
 case 'gt':
 case 'le':
 case 'lt':
 NoneType['__'+key+'__']=(function(op){return function(other){return _b_.NotImplemented}})($op)}}
 for(var $func in None){if(typeof None[$func]=='function'){None[$func].__str__=(function(f){return function(){return "<method-wrapper "+f+
 " of NoneType object>"}})($func)}}
 $B.set_func_names(NoneType,"builtins")
 function abs(obj){check_nb_args('abs',1,arguments)
 check_no_kw('abs',obj)
 if(isinstance(obj,_b_.int)){if(obj.__class__===$B.long_int){return{
 __class__:$B.long_int,value:obj.value,pos:true}}else{return _b_.int.$factory(Math.abs(obj))}}
 if(isinstance(obj,_b_.float)){
 return _b_.float.$factory(Math.abs(_b_.float.numerator(obj)))}
 var klass=obj.__class__ ||$B.get_class(obj)
 try{var method=$B.$getattr(klass,"__abs__")}catch(err){if(err.__class__===_b_.AttributeError){throw _b_.TypeError.$factory("Bad operand type for abs(): '"+
 $B.class_name(obj)+"'")}
 throw err}
 return $B.$call(method)(obj)}
 function all(obj){check_nb_args('all',1,arguments)
 check_no_kw('all',obj)
 var iterable=iter(obj)
 while(1){try{var elt=next(iterable)
 if(!$B.$bool(elt)){return false}}catch(err){return true}}}
 function any(obj){check_nb_args('any',1,arguments)
 check_no_kw('any',obj)
 var iterable=iter(obj)
 while(1){try{var elt=next(iterable)
 if($B.$bool(elt)){return true}}catch(err){return false}}}
 function ascii(obj){check_nb_args('ascii',1,arguments)
 check_no_kw('ascii',obj)
 var res=repr(obj),res1='',cp
 for(var i=0;i < res.length;i++){cp=res.charCodeAt(i)
 if(cp < 128){res1+=res.charAt(i)}
 else if(cp < 256){res1+='\\x'+cp.toString(16)}
 else{var s=cp.toString(16)
 if(s.length % 2==1){s="0"+s}
 res1+='\\u'+s}}
 return res1}
 function $builtin_base_convert_helper(obj,base){var prefix="";
 switch(base){case 2:
 prefix='0b';break
 case 8:
 prefix='0o';break
 case 16:
 prefix='0x';break
 default:
 console.log('invalid base:'+base)}
 if(obj.__class__===$B.long_int){var res=prefix+$B.long_int.to_base(obj,base)
 if(! obj.pos){res="-"+res}
 return res}
 var value=$B.$GetInt(obj)
 if(value===undefined){
 throw _b_.TypeError.$factory('Error, argument must be an integer or'+
 ' contains an __index__ function')}
 if(value >=0){return prefix+value.toString(base)}
 return '-'+prefix+(-value).toString(base)}
 function bin_hex_oct(base,obj){
 if(isinstance(obj,_b_.int)){return $builtin_base_convert_helper(obj,base)}else{try{var klass=obj.__class__ ||$B.get_class(obj),method=$B.$getattr(klass,'__index__')}catch(err){if(err.__class__===_b_.AttributeError){throw _b_.TypeError.$factory("'"+$B.class_name(obj)+
 "' object cannot be interpreted as an integer")}
 throw err}
 var res=$B.$call(method)(obj)
 return $builtin_base_convert_helper(res,base)}}
 function bin(obj){check_nb_args('bin',1,arguments)
 check_no_kw('bin',obj)
 return bin_hex_oct(2,obj)}
 function breakpoint(){
 $B.$import('sys',[])
 var missing={},hook=$B.$getattr($B.imported.sys,'breakpointhook',missing)
 if(hook===missing){throw _b_.RuntimeError.$factory('lost sys.breakpointhook')}
 return $B.$call(hook).apply(null,arguments)}
 function callable(obj){check_nb_args('callable',1,arguments)
 check_no_kw('callable',obj)
 return hasattr(obj,'__call__')}
 function chr(i){check_nb_args('chr',1,arguments)
 check_no_kw('chr',i)
 if(i < 0 ||i > 1114111){throw _b_.ValueError.$factory('Outside valid range')}
 return String.fromCodePoint(i)}
 var classmethod=$B.make_class("classmethod",function(func){check_nb_args('classmethod',1,arguments)
 check_no_kw('classmethod',func)
 var f=function(){return func.apply(null,arguments)}
 f.__class__=$B.method
 if(func.$attrs){for(var key in func.$attrs){f[key]=func.$attrs[key]}}
 f.$infos={__func__:func,__name__:func.$infos.__name__}
 f.__get__=function(obj,cls){var method=function(){return f(cls,...arguments)}
 method.__class__=$B.method
 method.$infos={__self__:cls,__func__:f,__name__:func.$infos.__name__,__qualname__:cls.$infos.__name__+"."+func.$infos.__name__}
 return method}
 f.__get__.__class__=$B.method_wrapper
 f.__get__.$infos=func.$infos
 return f}
 )
 $B.set_func_names(classmethod,"builtins")
 var code=$B.code=$B.make_class("code")
 code.__repr__=code.__str__=function(self){return '<code object '+self.co_name+', file '+self.co_filename+'>'}
 code.__getattribute__=function(self,attr){return self[attr]}
 $B.set_func_names(code,"builtins")
 function compile(){var $=$B.args('compile',6,{source:null,filename:null,mode:null,flags:null,dont_inherit:null,optimize:null,_feature_version:null},['source','filename','mode','flags','dont_inherit','optimize','_feature_version'],arguments,{flags:0,dont_inherit:false,optimize:-1,_feature_version:0},null,null)
 var module_name='$exec_'+$B.UUID()
 $B.clear_ns(module_name)
 $.__class__=code
 $.co_flags=$.flags
 $.name="<module>"
 var interactive=$.mode=="single" &&($.flags & 0x200)
 if(interactive && ! $.source.endsWith("\n")){
 var lines=$.source.split("\n")
 if($B.last(lines).startsWith(" ")){throw _b_.SyntaxError.$factory("unexpected EOF while parsing")}}
 $B.py2js($.source,module_name,module_name)
 return $}
 var __debug__=$B.debug > 0
 function delattr(obj,attr){
 check_no_kw('delattr',obj,attr)
 check_nb_args('delattr',2,arguments)
 if(typeof attr !='string'){throw _b_.TypeError.$factory("attribute name must be string, not '"+
 $B.class_name(attr)+"'")}
 return $B.$getattr(obj,'__delattr__')(attr)}
 $B.$delete=function(name,is_global){
 function del(obj){if(obj.__class__===$B.generator){
 obj.return()}}
 var found=false,frame=$B.last($B.frames_stack)
 if(! is_global){if(frame[1][name]!==undefined){found=true
 del(frame[1][name])
 delete frame[1][name]}}else{if(frame[2]!=frame[0]&& frame[3][name]!==undefined){found=true
 del(frame[3][name])
 delete frame[3][name]}}
 if(!found){throw _b_.NameError.$factory(name)}}
 function dir(obj){if(obj===undefined){
 var frame=$B.last($B.frames_stack)
 locals_obj=frame[1],res=_b_.list.$factory(),pos=0
 for(var attr in locals_obj){if(attr.charAt(0)=='$' && attr.charAt(1)!='$'){
 continue}
 res[pos++]=attr}
 _b_.list.sort(res)
 return res}
 check_nb_args('dir',1,arguments)
 check_no_kw('dir',obj)
 var klass=obj.__class__ ||$B.get_class(obj)
 if(obj.$is_class){
 var dir_func=$B.$getattr(obj.__class__,"__dir__")
 return $B.$call(dir_func)(obj)}
 try{var res=$B.$call($B.$getattr(obj,'__dir__'))()
 res=_b_.list.$factory(res)
 return res}catch(err){}
 var res=[],pos=0
 for(var attr in obj){if(attr.charAt(0)!=='$' && attr !=='__class__' &&
 obj[attr]!==undefined){res[pos++]=attr}}
 res.sort()
 return res}
 function divmod(x,y){check_no_kw('divmod',x,y)
 check_nb_args('divmod',2,arguments)
 var klass=x.__class__ ||$B.get_class(x)
 var dm=$B.$getattr(klass,"__divmod__",_b_.None)
 if(dm !==_b_.None){return dm(x,y)}
 return _b_.tuple.$factory([$B.$getattr(klass,'__floordiv__')(x,y),$B.$getattr(klass,'__mod__')(x,y)])}
 var enumerate=$B.make_class("enumerate",function(){var $ns=$B.args("enumerate",2,{iterable:null,start:null},['iterable','start'],arguments,{start:0},null,null),_iter=iter($ns["iterable"]),start=$ns["start"]
 return{
 __class__:enumerate,__name__:'enumerate iterator',counter:start-1,iter:_iter,start:start}}
 )
 enumerate.__iter__=function(self){self.counter=self.start-1
 return self}
 enumerate.__next__=function(self){self.counter++
 return $B.fast_tuple([self.counter,next(self.iter)])}
 $B.set_func_names(enumerate,"builtins")
 $B.from_alias=function(attr){if(attr.substr(0,2)=='$$' && $B.aliased_names[attr.substr(2)]){return attr.substr(2)}
 return attr}
 $B.to_alias=function(attr){if($B.aliased_names[attr]){return '$$'+attr}
 return attr}
 function $$eval(src,_globals,_locals){var $=$B.args("eval",4,{src:null,globals:null,locals:null,mode:null},["src","globals","locals","mode"],arguments,{globals:_b_.None,locals:_b_.None,mode:"eval"},null,null),src=$.src,_globals=$.globals,_locals=$.locals,mode=$.mode
 if($.src.mode && $.src.mode=="single" &&
 ["<console>","<stdin>"].indexOf($.src.filename)>-1){
 _b_.print(">",$.src.source.trim())}
 var current_frame=$B.frames_stack[$B.frames_stack.length-1]
 if(current_frame !==undefined){var current_locals_id=current_frame[0].replace(/\./g,'_'),current_globals_id=current_frame[2].replace(/\./g,'_')}
 var stack_len=$B.frames_stack.length
 if(src.__class__===code){mode=src.mode
 src=src.source}else if(typeof src !=='string'){throw _b_.TypeError.$factory("eval() arg 1 must be a string, bytes "+
 "or code object")}
 var globals_id='$exec_'+$B.UUID(),globals_name=globals_id,locals_id='$exec_'+$B.UUID(),parent_scope
 if(_globals===_b_.None){if(current_locals_id==current_globals_id){locals_id=globals_id}
 var local_scope={module:globals_id,id:locals_id,binding:{},bindings:{}}
 for(var attr in current_frame[1]){local_scope.binding[attr]=true
 local_scope.bindings[attr]=true}
 var global_scope={module:globals_id,id:globals_id,binding:{},bindings:{}}
 for(var attr in current_frame[3]){global_scope.binding[attr]=true
 global_scope.bindings[attr]=true}
 local_scope.parent_block=global_scope
 global_scope.parent_block=$B.builtins_scope
 parent_scope=local_scope
 eval("$locals_"+parent_scope.id+" = current_frame[1]")}else{
 if(_globals.__class__ !=_b_.dict){throw _b_.TypeError.$factory("exec() globals must be a dict, not "+
 $B.class_name(_globals))}
 if(_globals.globals_id){globals_id=globals_name=_globals.globals_id}
 _globals.globals_id=globals_id
 if(_locals===_globals ||_locals===_b_.None){locals_id=globals_id
 parent_scope=$B.builtins_scope}else{
 var grandparent_scope={id:globals_id,parent_block:$B.builtins_scope,binding:{}}
 parent_scope={id:locals_id,parent_block:grandparent_scope,binding:{}}
 for(var attr in _globals.$string_dict){grandparent_scope.binding[attr]=true}
 for(var attr in _locals.$string_dict){parent_scope.binding[attr]=true}}}
 $B.$py_module_path[globals_id]=$B.$py_module_path[current_globals_id]
 eval('var $locals_'+globals_id+' = {}\nvar $locals_'+
 locals_id+' = {}')
 if(_globals===_b_.None){var gobj=current_frame[3],ex='var $locals_'+globals_id+' = gobj;',obj={}
 eval(ex)
 for(var attr in gobj){if(attr.startsWith("$")&& !attr.startsWith("$$")){continue}
 obj[attr]=gobj[attr]}
 eval("$locals_"+globals_id+" = obj")}else{var globals_is_dict=false
 if(_globals.$jsobj){var items=_globals.$jsobj}else{var items=_b_.dict.$to_obj(_globals)
 _globals.$jsobj=items
 globals_is_dict=true}
 eval("$locals_"+globals_id+" = _globals.$jsobj")
 for(var item in items){var item1=$B.to_alias(item)
 try{eval('$locals_'+globals_id+'["'+item+'"] = items.'+item)}catch(err){console.log(err)
 console.log('error setting',item)
 break}}}
 _globals.$is_namespace=true
 if(_locals===_b_.None){if(_globals !==_b_.None){eval('var $locals_'+locals_id+' = $locals_'+globals_id)}else{var lobj=current_frame[1],ex='',obj={}
 for(var attr in current_frame[1]){if(attr.startsWith("$")&& !attr.startsWith("$$")){continue}
 obj[attr]=lobj[attr]}
 eval('$locals_'+locals_id+" = obj")}}else{var locals_is_dict=false
 if(_locals.$jsobj){var items=_locals.$jsobj}else{locals_id_dict=true
 var items=_b_.dict.$to_obj(_locals)
 _locals.$jsobj=items}
 for(var item in items){var item1=$B.to_alias(item)
 try{eval('$locals_'+locals_id+'["'+item+'"] = items.'+item)}catch(err){console.log(err)
 console.log('error setting',item)
 break}}
 eval("$locals_"+locals_id+".$exec_locals = true")}
 _locals.$is_namespace=true
 if(_globals===_b_.None && _locals===_b_.None &&
 current_frame[0]==current_frame[2]){}else{eval("$locals_"+locals_id+".$src = src")}
 var root=$B.py2js(src,globals_id,locals_id,parent_scope),js,gns,lns
 if(_globals !==_b_.None && _locals==_b_.None){for(var attr in _globals.$string_dict){root.binding[attr]=true}}
 try{
 var try_node=root.children[root.children.length-2],instr=try_node.children[try_node.children.length-2]
 var type=instr.C.tree[0].type
 switch(type){case 'expr':
 case 'list_or_tuple':
 case 'op':
 case 'ternary':
 var children=try_node.children
 root.children.splice(root.children.length-2,2)
 for(var i=0;i < children.length-1;i++){root.add(children[i])}
 break
 default:
 if(mode=="eval"){throw _b_.SyntaxError.$factory(
 "eval() argument must be an expression",'<string>',1,1,src)}}
 if(mode !="eval"){
 var last=$B.last(root.children),js=last.to_js()
 if(["node_js"].indexOf(last.C.type)==-1){last.to_js=function(){while(js.endsWith("\n")){js=js.substr(0,js.length-1)}
 while(js.endsWith(";")){js=js.substr(0,js.length-1)}
 return "return ("+js+")"}}
 js=root.to_js()
 var locals_obj=eval("$locals_"+locals_id),globals_obj=eval("$locals_"+globals_id)
 if(_globals===_b_.None){var res=new Function("$locals_"+globals_id,"$locals_"+locals_id,js)(
 globals_obj,locals_obj)}else{current_globals_obj=current_frame[3]
 current_locals_obj=current_frame[1]
 var res=new Function("$locals_"+globals_id,"$locals_"+locals_id,"$locals_"+current_globals_id,"$locals_"+current_locals_id,js)(globals_obj,locals_obj,current_globals_obj,current_locals_obj)}
 if($.src.mode && $.src.mode=="single" &&
 $.src.filename=="<stdin>"){if(res !==_b_.None && res !==undefined){_b_.print(_b_.repr(res))}}}else{js=root.to_js()
 var res=eval(js)}
 if($.src.filename=="<console>" && $.src.mode=="single" &&
 res !==undefined && res !==_b_.None){_b_.print(res)}
 gns=eval("$locals_"+globals_id)
 if($B.frames_stack[$B.frames_stack.length-1][2]==globals_id){gns=$B.frames_stack[$B.frames_stack.length-1][3]}
 if(_locals !==_b_.None){lns=eval("$locals_"+locals_id)
 for(var attr in lns){var attr1=$B.from_alias(attr)
 if(attr1.charAt(0)!='$'){if(_locals.$jsobj){_locals.$jsobj[attr]=lns[attr]}else{_b_.dict.$setitem(_locals,attr1,lns[attr])}}}}else{for(var attr in lns){if(attr !=="$src"){current_frame[1][attr]=lns[attr]}}}
 if(_globals !==_b_.None){
 if(globals_is_dict){var jsobj=_globals.$jsobj
 delete _globals.$jsobj}
 for(var attr in gns){attr1=$B.from_alias(attr)
 if(attr1.charAt(0)!='$'){if(globals_is_dict){_b_.dict.$setitem(_globals,attr,gns[attr])}else{_globals.$jsobj[attr1]=gns[attr]}}}
 for(var attr in _globals.$string_dict){if(attr.startsWith("$")&& !attr.startsWith("$$")){delete _globals.$string_dict[attr]}}}else{for(var attr in gns){if(attr !=="$src"){current_frame[3][attr]=gns[attr]}}}
 if(res===undefined){return _b_.None}
 return res}catch(err){err.src=src
 err.module=globals_id
 if(err.$py_error===undefined){throw $B.exception(err)}
 throw err}finally{
 if($B.frames_stack.length==stack_len+1){$B.frames_stack.pop()}
 root=null
 js=null
 gns=null
 lns=null
 $B.clear_ns(globals_id)
 $B.clear_ns(locals_id)}}
 $$eval.$is_func=true
 function exec(src,globals,locals){var missing={}
 var $=$B.args("exec",3,{src:null,globals:null,locals:null},["src","globals","locals"],arguments,{globals:_b_.None,locals:_b_.None},null,null),src=$.src,globals=$.globals,locals=$.locals
 return $$eval(src,globals,locals,"exec")||_b_.None}
 exec.$is_func=true
 function exit(){throw _b_.SystemExit}
 exit.__repr__=exit.__str__=function(){return "Use exit() or Ctrl-Z plus Return to exit"}
 var filter=$B.make_class("filter",function(func,iterable){check_no_kw('filter',func,iterable)
 check_nb_args('filter',2,arguments)
 iterable=iter(iterable)
 if(func===_b_.None){func=$B.$bool}
 return{
 __class__:filter,func:func,iterable:iterable}}
 )
 filter.__iter__=function(self){return self}
 filter.__next__=function(self){while(true){var _item=next(self.iterable)
 if(self.func(_item)){return _item}}}
 $B.set_func_names(filter,"builtins")
 function format(value,format_spec){var $=$B.args("format",2,{value:null,format_spec:null},["value","format_spec"],arguments,{format_spec:''},null,null)
 var klass=value.__class__ ||$B.get_class(value)
 try{var method=$B.$getattr(klass,'__format__')}catch(err){if(err.__class__===_b_.AttributeError){throw _b_.NotImplementedError("__format__ is not implemented "+
 "for object '"+_b_.str.$factory(value)+"'")}
 throw err}
 return $B.$call(method)(value,$.format_spec)}
 function attr_error(attr,cname){var msg="bad operand type for unary #: '"+cname+"'"
 switch(attr){case '__neg__':
 throw _b_.TypeError.$factory(msg.replace('#','-'))
 case '__pos__':
 throw _b_.TypeError.$factory(msg.replace('#','+'))
 case '__invert__':
 throw _b_.TypeError.$factory(msg.replace('#','~'))
 case '__call__':
 throw _b_.TypeError.$factory("'"+cname+"'"+
 ' object is not callable')
 default:
 while(attr.charAt(0)=='$'){attr=attr.substr(1)}
 throw _b_.AttributeError.$factory("'"+cname+
 "' object has no attribute '"+attr+"'")}}
 function getattr(){var missing={}
 var $=$B.args("getattr",3,{obj:null,attr:null,_default:null},["obj","attr","_default"],arguments,{_default:missing},null,null)
 return $B.$getattr($.obj,$.attr,$._default===missing ? undefined :$._default)}
 function in_mro(klass,attr){if(klass===undefined){return false}
 if(klass.hasOwnProperty(attr)){return klass[attr]}
 var mro=klass.__mro__
 for(var i=0,len=mro.length;i < len;i++){if(mro[i].hasOwnProperty(attr)){return mro[i][attr]}}
 return false}
 $B.$getattr=function(obj,attr,_default){
 attr=$B.to_alias(attr)
 if(obj.$method_cache &&
 obj.$method_cache[attr]&&
 obj.__class__ &&
 obj.__class__[attr]==obj.$method_cache[attr][1]){
 return obj.$method_cache[attr][0]}
 var rawname=attr
 if(obj===undefined){console.log("get attr",attr,"of undefined")}
 var is_class=obj.$is_class ||obj.$factory
 var klass=obj.__class__
 var $test=false 
 if($test){console.log("$getattr",attr,obj,klass)}
 if(klass !==undefined && klass.__bases__ &&
 (klass.__bases__.length==0 ||
 (klass.__bases__.length==1 &&
 klass.__bases__[0]===_b_.object))){if(obj.hasOwnProperty(attr)){return obj[attr]}else if(obj.__dict__ &&
 obj.__dict__.$string_dict.hasOwnProperty(attr)&&
 !(klass.hasOwnProperty(attr)&&
 klass[attr].__get__)){return obj.__dict__.$string_dict[attr][0]}else if(klass.hasOwnProperty(attr)){if(typeof klass[attr]!="function" &&
 attr !="__dict__" &&
 klass[attr].__get__===undefined){var kl=klass[attr].__class__
 if(! in_mro(kl,"__get__")){return klass[attr]}}}}
 if($test){console.log("attr",attr,"of",obj,"class",klass,"isclass",is_class)}
 if(klass===undefined){
 if(typeof obj=='string'){klass=_b_.str}
 else if(typeof obj=='number'){klass=obj % 1==0 ? _b_.int :_b_.float}else if(obj instanceof Number){klass=_b_.float}else{klass=$B.get_class(obj)
 if(klass===undefined){
 if($test){console.log("no class",attr,obj.hasOwnProperty(attr),obj[attr])}
 var res=obj[attr]
 if(res !==undefined){if(typeof res=="function"){var f=function(){
 return res.apply(obj,arguments)}
 f.$infos={__name__:attr,__qualname__:attr}
 return f}else{return $B.$JS2Py(res)}}
 if(_default !==undefined){return _default}
 throw _b_.AttributeError.$factory('object has no attribute '+rawname)}}}
 switch(attr){case '__call__':
 if(typeof obj=='function'){var res=function(){return obj.apply(null,arguments)}
 res.__class__=method_wrapper
 res.$infos={__name__:"__call__"}
 return res}
 break
 case '__class__':
 return klass
 case '__dict__':
 if(is_class){var proxy={}
 for(var key in obj){var key1=$B.from_alias(key)
 if(! key1.startsWith("$")){proxy[key1]=obj[key]}}
 proxy.__dict__=$B.getset_descriptor.$factory(obj,"__dict__")
 return $B.mappingproxy.$factory(proxy)}else{if(obj.hasOwnProperty(attr)){return obj[attr]}else if(obj.$infos){if(obj.$infos.hasOwnProperty("__dict__")){return obj.$infos.__dict__}else if(obj.$infos.hasOwnProperty("__func__")){return obj.$infos.__func__.$infos.__dict__}}
 return $B.obj_dict(obj)}
 case '__doc__':
 for(var i=0;i < builtin_names.length;i++){if(obj===_b_[builtin_names[i]]){_get_builtins_doc()
 return $B.builtins_doc[builtin_names[i]]}}
 break
 case '__mro__':
 if(obj.$is_class){
 return _b_.tuple.$factory([obj].concat(obj.__mro__))}else if(obj.__dict__ &&
 obj.__dict__.$string_dict.__mro__ !==undefined){return obj.__dict__.$string_dict.__mro__}
 throw _b_.AttributeError.$factory(attr)
 case '__subclasses__':
 if(klass.$factory ||klass.$is_class){var subclasses=obj.$subclasses ||[]
 return function(){return subclasses}}
 break}
 if(typeof obj=='function'){var value=obj[attr]
 if(value !==undefined){if(attr=='__module__'){return value}}}
 if((! is_class)&& klass.$native){if(obj.$method_cache && obj.$method_cache[attr]){return obj.$method_cache[attr]}
 if($test){console.log("native class",klass,klass[attr])}
 if(attr=="__doc__" && klass[attr]===undefined && klass.$infos){_get_builtins_doc()
 klass[attr]=$B.builtins_doc[klass.$infos.__name__]}
 if(klass[attr]===undefined){var object_attr=_b_.object[attr]
 if($test){console.log("object attr",object_attr)}
 if(object_attr !==undefined){klass[attr]=object_attr}else{if($test){console.log("obj[attr]",obj[attr])}
 var attrs=obj.__dict__
 if(attrs &&
 (object_attr=attrs.$string_dict[attr])!==undefined){return object_attr[0]}
 if(_default===undefined){attr_error(attr,klass.$infos.__name__)}
 return _default}}
 if(klass.$descriptors && klass.$descriptors[attr]!==undefined){return klass[attr](obj)}
 if(typeof klass[attr]=='function'){var func=klass[attr]
 if(attr=='__new__'){func.$type="staticmethod"}
 if(func.$type=="staticmethod"){return func}
 var self=klass[attr].__class__==$B.method ? klass :obj,method=klass[attr].bind(null,self)
 method.__class__=$B.method
 method.$infos={__func__:func,__name__:attr,__self__:self,__qualname__:klass.$infos.__name__+"."+attr}
 if(typeof obj=="object"){
 obj.__class__=klass
 obj.$method_cache=obj.$method_cache ||{}
 obj.$method_cache[attr]=method}
 return method}else if(klass[attr]!==undefined){return klass[attr]}
 attr_error(rawname,klass.$infos.__name__)}
 var mro,attr_func
 if(is_class){attr_func=_b_.type.__getattribute__ }else{attr_func=klass.__getattribute__
 if(attr_func===undefined){var mro=klass.__mro__
 if(mro===undefined){console.log(obj,attr,"no mro, klass",klass)}
 for(var i=0,len=mro.length;i < len;i++){attr_func=mro[i]['__getattribute__']
 if(attr_func !==undefined){break}}}}
 if(typeof attr_func !=='function'){console.log(attr+' is not a function '+attr_func,klass)}
 var odga=_b_.object.__getattribute__
 if($test){console.log("attr_func is odga",attr_func,attr_func===odga,obj[attr])}
 if(attr_func===odga){var res=obj[attr]
 if(Array.isArray(obj)&& Array.prototype[attr]!==undefined){
 res=undefined}
 if(res===null){return null}
 else if(res===undefined && obj.hasOwnProperty(attr)){return res}else if(res !==undefined){if($test){console.log(obj,attr,obj[attr],res.__set__ ||res.$is_class)}
 if(res.__set__===undefined ||res.$is_class){if($test){console.log("return",res,res+'',res.__set__,res.$is_class)}
 return res}}}
 try{var res=attr_func(obj,attr)
 if($test){console.log("result of attr_func",res)}}catch(err){if(_default !==undefined){return _default}
 throw err}
 if(res !==undefined){return res}
 if(_default !==undefined){return _default}
 var cname=klass.$infos.__name__
 if(is_class){cname=obj.$infos.__name__}
 attr_error(rawname,cname)}
 function globals(){
 check_nb_args('globals',0,arguments)
 var res=$B.obj_dict($B.last($B.frames_stack)[3])
 res.$jsobj.__BRYTHON__=$B.JSObj.$factory($B)
 res.$is_namespace=true
 return res}
 function hasattr(obj,attr){check_no_kw('hasattr',obj,attr)
 check_nb_args('hasattr',2,arguments)
 try{$B.$getattr(obj,attr);return true}
 catch(err){return false}}
 var hash_cache={}
 function hash(obj){check_no_kw('hash',obj)
 check_nb_args('hash',1,arguments)
 if(obj.__hashvalue__ !==undefined){return obj.__hashvalue__}
 if(isinstance(obj,_b_.bool)){return _b_.int.$factory(obj)}
 if(isinstance(obj,_b_.int)){if(obj.$brython_value===undefined){return obj.valueOf()}else{
 return obj.__hashvalue__=obj.$brython_value}}
 if(obj.$is_class ||
 obj.__class__===_b_.type ||
 obj.__class__===$B.Function){return obj.__hashvalue__=$B.$py_next_hash--}
 if(typeof obj=="string"){var cached=hash_cache[obj]
 if(cached !==undefined){return cached}
 else{return hash_cache[obj]=_b_.str.__hash__(obj)}}
 var klass=obj.__class__ ||$B.get_class(obj)
 if(klass===undefined){throw _b_.TypeError.$factory("unhashable type: '"+
 _b_.str.$factory($B.JSObj.$factory(obj))+"'")}
 var hash_method=$B.$getattr(klass,'__hash__',_b_.None)
 if(hash_method===_b_.None){throw _b_.TypeError.$factory("unhashable type: '"+
 $B.class_name(obj)+"'")}
 if(hash_method.$infos.__func__===_b_.object.__hash__){if($B.$getattr(obj,'__eq__').$infos.__func__ !==_b_.object.__eq__){throw _b_.TypeError.$factory("unhashable type: '"+
 $B.class_name(obj)+"'",'hash')}else{return obj.__hashvalue__=_b_.object.__hash__(obj)}}else{return $B.$call(hash_method)(obj)}}
 function _get_builtins_doc(){if($B.builtins_doc===undefined){
 var url=$B.brython_path
 if(url.charAt(url.length-1)=='/'){url=url.substr(0,url.length-1)}
 url+='/builtins_docstrings.js'
 var f=_b_.open(url)
 eval(f.$string)
 $B.builtins_doc=docs}}
 function help(obj){if(obj===undefined){obj='help'}
 if(typeof obj=='string' && _b_[obj]!==undefined){_get_builtins_doc()
 var _doc=$B.builtins_doc[obj]
 if(_doc !==undefined && _doc !=''){_b_.print(_doc)
 return}}
 for(var i=0;i < builtin_names.length;i++){if(obj===_b_[builtin_names[i]]){_get_builtins_doc()
 _b_.print(_doc=$B.builtins_doc[builtin_names[i]])}}
 if(typeof obj=='string'){$B.$import("pydoc");
 var pydoc=$B.imported["pydoc"]
 $B.$getattr($B.$getattr(pydoc,"help"),"__call__")(obj)
 return}
 try{return $B.$getattr(obj,'__doc__')}
 catch(err){return ''}}
 help.__repr__=help.__str__=function(){return "Type help() for interactive help, or help(object) "+
 "for help about object."}
 function hex(obj){check_no_kw('hex',obj)
 check_nb_args('hex',1,arguments)
 return bin_hex_oct(16,obj)}
 function id(obj){check_no_kw('id',obj)
 check_nb_args('id',1,arguments)
 if(isinstance(obj,[_b_.str,_b_.int,_b_.float])&&
 !isinstance(obj,$B.long_int)){return $B.$getattr(_b_.str.$factory(obj),'__hash__')()}else if(obj.$id !==undefined){return obj.$id}
 else{return obj.$id=$B.UUID()}}
 function __import__(mod_name,globals,locals,fromlist,level){
 var $=$B.args('__import__',5,{name:null,globals:null,locals:null,fromlist:null,level:null},['name','globals','locals','fromlist','level'],arguments,{globals:None,locals:None,fromlist:_b_.tuple.$factory(),level:0},null,null)
 return $B.$__import__($.name,$.globals,$.locals,$.fromlist)}
 function input(msg){var res=prompt(msg ||'')||''
 if($B.imported["sys"]&& $B.imported["sys"].ps1){
 var ps1=$B.imported["sys"].ps1,ps2=$B.imported["sys"].ps2
 if(msg==ps1 ||msg==ps2){console.log(msg,res)}}
 return res}
 function isinstance(obj,cls){check_no_kw('isinstance',obj,cls)
 check_nb_args('isinstance',2,arguments)
 if(obj===null){return cls===None}
 if(obj===undefined){return false}
 if(cls.constructor===Array){for(var i=0;i < cls.length;i++){if(isinstance(obj,cls[i])){return true}}
 return false}
 if(cls.__class__===$B.GenericAlias){
 throw _b_.TypeError.$factory(
 'isinstance() arg 2 cannot be a parameterized generic')}
 if(!cls.__class__ ||
 !(cls.$factory !==undefined ||cls.$is_class !==undefined)){throw _b_.TypeError.$factory("isinstance() arg 2 must be a type "+
 "or tuple of types")}
 if(cls===_b_.int &&(obj===True ||obj===False)){return True}
 if(cls===_b_.bool){switch(typeof obj){case "string":
 return false
 case "number":
 return false
 case "boolean":
 return true}}
 var klass=obj.__class__
 if(klass==undefined){if(typeof obj=='string'){if(cls==_b_.str){return true}
 else if($B.builtin_classes.indexOf(cls)>-1){return false}}else if(obj.contructor===Number && Number.isFinite(obj)){if(cls==_b_.float){return true}}else if(typeof obj=='number' && Number.isFinite(obj)){if(Number.isFinite(obj)&& cls==_b_.int){return true}}
 klass=$B.get_class(obj)}
 if(klass===undefined){return false}
 function check(kl,cls){if(kl===cls){return true}
 else if(cls===_b_.str && kl===$B.StringSubclass){return true}
 else if(cls===_b_.int && kl===$B.IntSubclass){return true}}
 if(check(klass,cls)){return true}
 var mro=klass.__mro__
 for(var i=0;i < mro.length;i++){if(check(mro[i],cls)){return true}}
 var instancecheck=$B.$getattr(cls.__class__ ||$B.get_class(cls),'__instancecheck__',_b_.None)
 if(instancecheck !==_b_.None){return instancecheck(cls,obj)}
 return false}
 function issubclass(klass,classinfo){check_no_kw('issubclass',klass,classinfo)
 check_nb_args('issubclass',2,arguments)
 if(!klass.__class__ ||
 !(klass.$factory !==undefined ||klass.$is_class !==undefined)){throw _b_.TypeError.$factory("issubclass() arg 1 must be a class")}
 if(isinstance(classinfo,_b_.tuple)){for(var i=0;i < classinfo.length;i++){if(issubclass(klass,classinfo[i])){return true}}
 return false}
 if(classinfo.__class__===$B.GenericAlias){throw _b_.TypeError.$factory(
 'issubclass() arg 2 cannot be a parameterized generic')}
 if(classinfo.$factory ||classinfo.$is_class){if(klass===classinfo ||
 klass.__mro__.indexOf(classinfo)>-1){return true}}
 var sch=$B.$getattr(classinfo.__class__ ||$B.get_class(classinfo),'__subclasscheck__',_b_.None)
 if(sch==_b_.None){return false}
 return sch(classinfo,klass)}
 var iterator_class=$B.make_class("iterator",function(getitem,len){return{
 __class__:iterator_class,getitem:getitem,len:len,counter:-1}}
 )
 iterator_class.__next__=function(self){self.counter++
 if(self.len !==null && self.counter==self.len){throw _b_.StopIteration.$factory('')}
 try{return self.getitem(self.counter)}
 catch(err){throw _b_.StopIteration.$factory('')}}
 callable_iterator=$B.make_class("callable_iterator",function(func,sentinel){return{
 __class__:callable_iterator,func:func,sentinel:sentinel}}
 )
 callable_iterator.__iter__=function(self){return self}
 callable_iterator.__next__=function(self){var res=self.func()
 if($B.rich_comp("__eq__",res,self.sentinel)){throw _b_.StopIteration.$factory()}
 return res}
 $B.$iter=function(obj,sentinel){
 if(sentinel===undefined){var klass=obj.__class__ ||$B.get_class(obj)
 try{var _iter=$B.$call($B.$getattr(klass,'__iter__'))}catch(err){if(err.__class__===_b_.AttributeError){try{var gi_method=$B.$call($B.$getattr(klass,'__getitem__')),gi=function(i){return gi_method(obj,i)},ln=len(obj)
 return iterator_class.$factory(gi,len)}catch(err){throw _b_.TypeError.$factory("'"+$B.class_name(obj)+
 "' object is not iterable")}}
 throw err}
 var res=$B.$call(_iter)(obj)
 try{$B.$getattr(res,'__next__')}
 catch(err){if(isinstance(err,_b_.AttributeError)){throw _b_.TypeError.$factory(
 "iter() returned non-iterator of type '"+
 $B.class_name(res)+"'")}}
 return res}else{return callable_iterator.$factory(obj,sentinel)}}
 function iter(){
 var $=$B.args('iter',1,{obj:null},['obj'],arguments,{},'args','kw'),sentinel
 if($.args.length > 0){var sentinel=$.args[0]}
 return $B.$iter($.obj,sentinel)}
 function len(obj){check_no_kw('len',obj)
 check_nb_args('len',1,arguments)
 var klass=obj.__class__ ||$B.get_class(obj)
 try{var method=$B.$getattr(klass,'__len__')}catch(err){throw _b_.TypeError.$factory("object of type '"+
 $B.class_name(obj)+"' has no len()")}
 return $B.$call(method)(obj)}
 function locals(){
 check_nb_args('locals',0,arguments)
 var res=$B.obj_dict($B.last($B.frames_stack)[1])
 res.$is_namespace=true
 delete res.$jsobj.__annotations__
 return res}
 var map=$B.make_class("map",function(){var $=$B.args('map',2,{func:null,it1:null},['func','it1'],arguments,{},'args',null),func=$B.$call($.func)
 var iter_args=[$B.$iter($.it1)]
 $.args.forEach(function(item){iter_args.push($B.$iter(item))})
 var obj={__class__:map,args:iter_args,func:func}
 return obj}
 )
 map.__iter__=function(self){return self}
 map.__next__=function(self){var args=[]
 for(var i=0;i < self.args.length;i++){args.push(next(self.args[i]))}
 return self.func.apply(null,args)}
 $B.set_func_names(map,"builtins")
 function $extreme(args,op){
 var $op_name='min'
 if(op==='__gt__'){$op_name="max"}
 if(args.length==0){throw _b_.TypeError.$factory($op_name+
 " expected 1 arguments, got 0")}
 var last_arg=args[args.length-1],nb_args=args.length,has_default=false,func=false
 if(last_arg.$nat=='kw'){nb_args--
 last_arg=last_arg.kw
 for(var attr in last_arg){switch(attr){case 'key':
 func=last_arg[attr]
 break
 case '$$default':
 var default_value=last_arg[attr]
 has_default=true
 break
 default:
 throw _b_.TypeError.$factory("'"+attr+
 "' is an invalid keyword argument for this function")}}}
 if(!func){func=function(x){return x}}
 if(nb_args==0){throw _b_.TypeError.$factory($op_name+" expected 1 argument, got 0")}else if(nb_args==1){
 var $iter=iter(args[0]),res=null
 while(true){try{var x=next($iter)
 if(res===null ||$B.$bool($B.$getattr(func(x),op)(func(res)))){res=x}}catch(err){if(err.__class__==_b_.StopIteration){if(res===null){if(has_default){return default_value}
 else{throw _b_.ValueError.$factory($op_name+
 "() arg is an empty sequence")}}else{return res}}
 throw err}}}else{if(has_default){throw _b_.TypeError.$factory("Cannot specify a default for "+
 $op_name+"() with multiple positional arguments")}
 var res=null
 for(var i=0;i < nb_args;i++){var x=args[i]
 if(res===null ||$B.$bool($B.$getattr(func(x),op)(func(res)))){res=x}}
 return res}}
 function max(){return $extreme(arguments,'__gt__')}
 var memoryview=$B.make_class('memoryview',function(obj){check_no_kw('memoryview',obj)
 check_nb_args('memoryview',1,arguments)
 if(obj.__class__===memoryview){return obj}
 if($B.get_class(obj).$buffer_protocol){return{
 __class__:memoryview,obj:obj,
 format:'B',itemsize:1,ndim:1,shape:_b_.tuple.$factory([_b_.len(obj)]),strides:_b_.tuple.$factory([1]),suboffsets:_b_.tuple.$factory([]),c_contiguous:true,f_contiguous:true,contiguous:true}}else{throw _b_.TypeError.$factory("memoryview: a bytes-like object "+
 "is required, not '"+$B.class_name(obj)+"'")}}
 )
 memoryview.__eq__=function(self,other){if(other.__class__ !==memoryview){return false}
 return $B.$getattr(self.obj,'__eq__')(other.obj)}
 memoryview.__getitem__=function(self,key){if(isinstance(key,_b_.int)){var start=key*self.itemsize
 if(self.format=="I"){var res=self.obj.source[start],coef=256
 for(var i=1;i < 4;i++){res+=self.obj.source[start+i]*coef
 coef*=256}
 return res}else if("B".indexOf(self.format)>-1){if(key > self.obj.source.length-1){throw _b_.KeyError.$factory(key)}
 return self.obj.source[key]}else{
 return self.obj.source[key]}}
 var res=self.obj.__class__.__getitem__(self.obj,key)
 if(key.__class__===_b_.slice){return memoryview.$factory(res)}}
 memoryview.__len__=function(self){return len(self.obj)/self.itemsize}
 memoryview.cast=function(self,format){switch(format){case "B":
 return memoryview.$factory(self.obj)
 case "I":
 var res=memoryview.$factory(self.obj),objlen=len(self.obj)
 res.itemsize=4
 res.format="I"
 if(objlen % 4 !=0){throw _b_.TypeError.$factory("memoryview: length is not "+
 "a multiple of itemsize")}
 return res}}
 memoryview.hex=function(self){var res='',bytes=_b_.bytes.$factory(self)
 bytes.source.forEach(function(item){res+=item.toString(16)})
 return res}
 memoryview.tobytes=function(self){return _b_.bytes.$factory(self.obj)}
 memoryview.tolist=function(self){if(self.itemsize==1){return _b_.list.$factory(_b_.bytes.$factory(self.obj))}else if(self.itemsize==4){if(self.format=="I"){var res=[]
 for(var i=0;i < self.obj.source.length;i+=4){var item=self.obj.source[i],coef=256
 for(var j=1;j < 4;j++){item+=coef*self.obj.source[i+j]
 coef*=256}
 res.push(item)}
 return res}}}
 $B.set_func_names(memoryview,"builtins")
 function min(){return $extreme(arguments,'__lt__')}
 function next(obj){check_no_kw('next',obj)
 var missing={},$=$B.args("next",2,{obj:null,def:null},['obj','def'],arguments,{def:missing},null,null)
 var klass=obj.__class__ ||$B.get_class(obj),ga=$B.$call($B.$getattr(klass,"__next__"))
 if(ga !==undefined){try{return $B.$call(ga)(obj)}catch(err){if(err.__class__===_b_.StopIteration &&
 $.def !==missing){return $.def}
 throw err}}
 throw _b_.TypeError.$factory("'"+$B.class_name(obj)+
 "' object is not an iterator")}
 var NotImplementedType=$B.make_class("NotImplementedType",function(){return NotImplemented}
 )
 NotImplementedType.__repr__=NotImplementedType.__str__=function(self){return "NotImplemented"}
 var NotImplemented={__class__:NotImplementedType}
 function $not(obj){return !$B.$bool(obj)}
 function oct(obj){check_no_kw('oct',obj)
 check_nb_args('oct',1,arguments)
 return bin_hex_oct(8,obj)}
 function ord(c){check_no_kw('ord',c)
 check_nb_args('ord',1,arguments)
 if(typeof c=='string'){if(c.length==1){return c.charCodeAt(0)}
 throw _b_.TypeError.$factory('ord() expected a character, but '+
 'string of length '+c.length+' found')}
 switch($B.get_class(c)){case _b_.str:
 if(c.length==1){return c.charCodeAt(0)}
 throw _b_.TypeError.$factory('ord() expected a character, but '+
 'string of length '+c.length+' found')
 case _b_.str.$surrogate:
 if(c.items.length==1){return c.items[0].codePointAt(0)}
 throw _b_.TypeError.$factory('ord() expected a character, but '+
 'string of length '+c.items.length+' found')
 case _b_.bytes:
 case _b_.bytearray:
 if(c.source.length==1){return c.source[0]}
 throw _b_.TypeError.$factory('ord() expected a character, but '+
 'string of length '+c.source.length+' found')
 default:
 throw _b_.TypeError.$factory('ord() expected a character, but '+
 $B.class_name(c)+' was found')}}
 function pow(){var $=$B.args('pow',3,{x:null,y:null,mod:null},['x','y','mod'],arguments,{mod:None},null,null),x=$.x,y=$.y,z=$.mod
 var klass=x.__class__ ||$B.get_class(x)
 if(z===_b_.None){return $B.$call($B.$getattr(klass,'__pow__'))(x,y)}else{if(x !=_b_.int.$factory(x)||y !=_b_.int.$factory(y)){throw _b_.TypeError.$factory("pow() 3rd argument not allowed "+
 "unless all arguments are integers")}
 return $B.$call($B.$getattr(klass,'__pow__'))(x,y,z)}}
 function $print(){var $ns=$B.args('print',0,{},[],arguments,{},'args','kw')
 var ks=$ns['kw'].$string_dict
 var end=(ks['end']===undefined ||ks['end']===None)? '\n' :ks['end'][0],sep=(ks['sep']===undefined ||ks['sep']===None)? ' ' :ks['sep'][0],file=ks['file']===undefined ? $B.stdout :ks['file'][0],args=$ns['args']
 var items=[]
 args.forEach(function(arg){items.push(_b_.str.$factory(arg))})
 var res=items.join(sep)+end
 res=res.replace(new RegExp("\u0007","g"),"").
 replace(new RegExp("(.)\b","g"),"")
 $B.$getattr(file,'write')(res)
 var flush=$B.$getattr(file,'flush',None)
 if(flush !==None){flush()}
 return None}
 $print.__name__='print'
 $print.is_func=true
 var property=$B.make_class("property",function(fget,fset,fdel,doc){var res={__class__:property}
 property.__init__(res,fget,fset,fdel,doc)
 return res}
 )
 property.__init__=function(self,fget,fset,fdel,doc){self.__doc__=doc ||""
 self.$type=fget.$type
 self.fget=fget
 self.fset=fset
 self.fdel=fdel
 if(fget && fget.$attrs){for(var key in fget.$attrs){self[key]=fget.$attrs[key]}}
 self.__get__=function(self,obj,objtype){if(obj===undefined){return self}
 if(self.fget===undefined){throw _b_.AttributeError.$factory("unreadable attribute")}
 return $B.$call(self.fget)(obj)}
 if(fset !==undefined){self.__set__=function(self,obj,value){if(self.fset===undefined){throw _b_.AttributeError.$factory("can't set attribute")}
 $B.$getattr(self.fset,'__call__')(obj,value)}}
 self.__delete__=fdel;
 self.getter=function(fget){return property.$factory(fget,self.fset,self.fdel,self.__doc__)}
 self.setter=function(fset){return property.$factory(self.fget,fset,self.fdel,self.__doc__)}
 self.deleter=function(fdel){return property.$factory(self.fget,self.fset,fdel,self.__doc__)}}
 property.__repr__=function(self){return _b_.repr(self.fget(self))}
 property.__str__=function(self){return _b_.str.$factory(self.fget(self))}
 $B.set_func_names(property,"builtins")
 function quit(){throw _b_.SystemExit}
 quit.__repr__=quit.__str__=function(){return "Use quit() or Ctrl-Z plus Return to exit"}
 function repr(obj){check_no_kw('repr',obj)
 check_nb_args('repr',1,arguments)
 var klass=obj.__class__ ||$B.get_class(obj)
 return $B.$call($B.$getattr(klass,"__repr__"))(obj)}
 var reversed=$B.make_class("reversed",function(seq){
 check_no_kw('reversed',seq)
 check_nb_args('reversed',1,arguments)
 var klass=seq.__class__ ||$B.get_class(seq),rev_method=$B.$getattr(klass,'__reversed__',null)
 if(rev_method !==null){return $B.$call(rev_method)(seq)}
 try{var method=$B.$getattr(klass,'__getitem__')}catch(err){throw _b_.TypeError.$factory("argument to reversed() must be a sequence")}
 var res={__class__:reversed,$counter :_b_.len(seq),getter:function(i){return $B.$call(method)(seq,i)}}
 return res}
 )
 reversed.__iter__=function(self){return self}
 reversed.__next__=function(self){self.$counter--
 if(self.$counter < 0){throw _b_.StopIteration.$factory('')}
 return self.getter(self.$counter)}
 $B.set_func_names(reversed,"builtins")
 function round(){var $=$B.args('round',2,{number:null,ndigits:null},['number','ndigits'],arguments,{ndigits:None},null,null),arg=$.number,n=$.ndigits===None ? 0 :$.ndigits
 if(!isinstance(arg,[_b_.int,_b_.float])){var klass=arg.__class__ ||$B.get_class(arg)
 try{return $B.$call($B.$getattr(klass,"__round__")).apply(null,arguments)}catch(err){if(err.__class__===_b_.AttributeError){throw _b_.TypeError.$factory("type "+$B.class_name(arg)+
 " doesn't define __round__ method")}else{throw err}}}
 if(isinstance(arg,_b_.float)&&
 (arg.value===Infinity ||arg.value===-Infinity)){throw _b_.OverflowError.$factory("cannot convert float infinity to integer")}
 if(!isinstance(n,_b_.int)){throw _b_.TypeError.$factory(
 "'"+$B.class_name(n)+"' object cannot be interpreted as an integer")}
 var mult=Math.pow(10,n),x=arg*mult,floor=Math.floor(x),diff=Math.abs(x-floor),res
 if(diff==0.5){if(floor % 2){floor+=1}
 res=_b_.int.__truediv__(floor,mult)}else{res=_b_.int.__truediv__(Math.round(x),mult)}
 if($.ndigits===None){
 return res.valueOf()}else if(arg instanceof Number){return new Number(res)}else{return res.valueOf()}}
 function setattr(){var $=$B.args('setattr',3,{obj:null,attr:null,value:null},['obj','attr','value'],arguments,{},null,null),obj=$.obj,attr=$.attr,value=$.value
 if(!(typeof attr=='string')){throw _b_.TypeError.$factory("setattr(): attribute name must be string")}
 return $B.$setattr(obj,attr,value)}
 $B.$setattr=function(obj,attr,value){
 var $test=false 
 if($B.aliased_names[attr]){attr='$$'+attr}else if(attr=='__dict__'){
 if(! isinstance(value,_b_.dict)){throw _b_.TypeError.$factory("__dict__ must be set to a dictionary, "+
 "not a '"+$B.class_name(value)+"'")}
 if(obj.$infos){obj.$infos.__dict__=value
 return None}
 obj.__dict__=value
 return None}else if(attr=="__class__"){
 function error(msg){throw _b_.TypeError.$factory(msg)}
 if(value.__class__){if(value.__module__=="builtins"){error("__class__ assignement only "+
 "supported for heap types or ModuleType subclasses")}else if(Array.isArray(value.__bases__)){for(var i=0;i < value.__bases__.length;i++){if(value.__bases__[i].__module__=="builtins"){error("__class__ assignment: '"+$B.class_name(obj)+
 "' object layout differs from '"+
 $B.class_name(value)+"'")}}}}
 obj.__class__=value
 return None}else if(attr=="__doc__" && obj.__class__===_b_.property){obj[attr]=value}
 if($test){console.log("set attr",attr,"to",obj)}
 if(obj.$factory ||obj.$is_class){var metaclass=obj.__class__
 if($test){console.log("obj is class",metaclass,metaclass[attr])}
 if(metaclass && metaclass[attr]&& metaclass[attr].__get__ &&
 metaclass[attr].__set__){metaclass[attr].__set__(obj,value)
 return None}
 obj[attr]=value
 if(attr=="__init__" ||attr=="__new__"){
 obj.$factory=$B.$instance_creator(obj)}else if(attr=="__bases__"){
 obj.__mro__=_b_.type.mro(obj)}
 if($test){console.log("after setattr",obj)}
 return None}
 var res=obj[attr],klass=obj.__class__ ||$B.get_class(obj)
 if($test){console.log('set attr',attr,'of obj',obj,'class',klass,"obj[attr]",obj[attr])}
 if(res===undefined && klass){res=klass[attr]
 if(res===undefined){var mro=klass.__mro__,_len=mro.length
 for(var i=0;i < _len;i++){res=mro[i][attr]
 if(res !==undefined){break}}}}
 if($test){console.log('set attr',attr,'klass',klass,'found in class',res)}
 if(res !==undefined && res !==null){
 if(res.__set__ !==undefined){res.__set__(res,obj,value);return None}
 var rcls=res.__class__,__set1__
 if(rcls !==undefined){var __set1__=rcls.__set__
 if(__set1__===undefined){var mro=rcls.__mro__
 for(var i=0,_len=mro.length;i < _len;i++){__set1__=mro[i].__set__
 if(__set1__){break}}}}
 if(__set1__ !==undefined){var __set__=$B.$getattr(res,'__set__',null)
 if(__set__ &&(typeof __set__=='function')){__set__.apply(res,[obj,value])
 return None}}else if(klass && klass.$descriptors !==undefined &&
 klass[attr]!==undefined){var setter=klass[attr].setter
 if(typeof setter=='function'){setter(obj,value)
 return None}else{throw _b_.AttributeError.$factory('readonly attribute')}}}
 var _setattr=false
 if(klass !==undefined){_setattr=klass.__setattr__
 if(_setattr===undefined){var mro=klass.__mro__
 for(var i=0,_len=mro.length-1;i < _len;i++){_setattr=mro[i].__setattr__
 if(_setattr){break}}}}
 var special_attrs=["__module__"]
 if(klass && klass.__slots__ && special_attrs.indexOf(attr)==-1 &&
 ! _setattr){function mangled_slots(klass){if(klass.__slots__){if(Array.isArray(klass.__slots__)){return klass.__slots__.map(function(item){if(item.startsWith("__")&& ! item.endsWith("_")){return "_"+klass.$infos.__name__+item}else{return item}})}else{return klass.__slots__}}
 return[]}
 var has_slot=false
 if(mangled_slots(klass).indexOf(attr)>-1){has_slot=true}else{for(var i=0;i < klass.__mro__.length;i++){var kl=klass.__mro__[i]
 if(mangled_slots(kl).indexOf(attr)>-1){has_slot=true
 break}}}
 if(! has_slot){throw _b_.AttributeError.$factory("'"+klass.$infos.__name__+
 "' object has no attribute '"+attr+"'")}}
 if($test){console.log("attr",attr,"use _setattr",_setattr)}
 if(!_setattr){if(obj.__dict__===undefined){obj[attr]=value}else{_b_.dict.$setitem(obj.__dict__,attr,value)}
 if($test){console.log("no setattr, obj",obj)}}else{_setattr(obj,attr,value)}
 return None}
 function sorted(){var $=$B.args('sorted',1,{iterable:null},['iterable'],arguments,{},null,'kw')
 var _list=_b_.list.$factory(iter($.iterable)),args=[_list]
 for(var i=1;i < arguments.length;i++){args.push(arguments[i])}
 _b_.list.sort.apply(null,args)
 return _list}
 var staticmethod=$B.make_class("staticmethod",function(func){var f={$infos:func.$infos,__get__:function(){return func}}
 f.__get__.__class__=$B.method_wrapper
 f.__get__.$infos=func.$infos
 return f}
 )
 $B.set_func_names(staticmethod,"builtins")
 function sum(iterable,start){var $=$B.args('sum',2,{iterable:null,start:null},['iterable','start'],arguments,{start:0},null,null),iterable=$.iterable,start=$.start
 if(_b_.isinstance(start,[_b_.str,_b_.bytes])){throw _b_.TypeError.$factory("TypeError: sum() can't sum bytes"+
 " [use b''.join(seq) instead]")}
 var res=start,iterable=iter(iterable)
 while(1){try{var _item=next(iterable)
 res=$B.$getattr(res,'__add__')(_item)}catch(err){if(err.__class__===_b_.StopIteration){break}else{throw err}}}
 return res}
 $B.missing_super2=function(obj){obj.$missing=true
 return obj}
 var $$super=$B.make_class("super",function(_type,object_or_type){if(_type===undefined && object_or_type===undefined){var frame=$B.last($B.frames_stack),pyframe=$B.imported["_sys"].Getframe()
 if(pyframe.f_code && pyframe.f_code.co_varnames){_type=frame[1].__class__
 if(_type===undefined){throw _b_.RuntimeError.$factory("super(): no arguments")}
 object_or_type=frame[1][pyframe.f_code.co_varnames[0]]}else{throw _b_.RuntimeError.$factory("super(): no arguments")}}
 if(Array.isArray(object_or_type)){object_or_type=object_or_type[0]}
 return{
 __class__:$$super,__thisclass__:_type,__self_class__:object_or_type}}
 )
 $$super.__get__=function(self,instance,klass){
 return $$super.$factory(self.__thisclass__,instance)}
 $$super.__getattribute__=function(self,attr){var mro=self.__thisclass__.__mro__,res
 var sc=self.__self_class__
 if(sc !==undefined){if(!sc.$is_class){sc=sc.__class__ ||$B.get_class(sc)}
 var sc_mro=[sc].concat(sc.__mro__)
 for(var i=0;i < sc_mro.length;i++){if(sc_mro[i]===self.__thisclass__){mro=sc_mro.slice(i+1)
 break}}}
 var $test=false 
 var f
 for(var i=0,len=mro.length;i < len;i++){if(mro[i][attr]!==undefined){f=mro[i][attr]
 break}}
 if(f===undefined){if($$super[attr]!==undefined){return(function(x){return function(){var args=[x]
 for(var i=0,len=arguments.length;i < len;i++){args.push(arguments[i])}
 return $$super[attr].apply(null,args)}})(self)}
 if($test){console.log("no attr",attr,self,"mro",mro)}
 throw _b_.AttributeError.$factory(attr)}
 if($test){console.log("super",attr,self,"mro",mro,"found in mro[0]",mro[0],f,f+'')}
 if(f.$type=="staticmethod" ||attr=="__new__"){return f}else if(typeof f !="function"){return f}else{if(f.__class__===$B.method){
 f=f.$infos.__func__}
 var callable=$B.$call(f)
 var method=function(){var res=callable(self.__self_class__,...arguments)
 if($test){console.log("calling super",self.__self_class__,attr,f,"res",res)}
 return res}
 method.__class__=$B.method
 var module
 if(f.$infos !==undefined){module=f.$infos.__module__}else if(f.__class__===property){module=f.fget.$infos.__module}else if(f.$is_class){module=f.__module__}
 method.$infos={__self__:self.__self_class__,__func__:f,__name__:attr,__module__:module,__qualname__:self.__thisclass__.$infos.__name__+"."+attr}
 return method}
 throw _b_.AttributeError.$factory("object 'super' has no attribute '"+
 attr+"'")}
 $$super.__repr__=$$super.__str__=function(self){var res="<super: <class '"+self.__thisclass__.$infos.__name__+"'>"
 if(self.__self_class__ !==undefined){res+=', <'+self.__self_class__.__class__.$infos.__name__+' object>'}else{res+=', NULL'}
 return res+'>'}
 $B.set_func_names($$super,"builtins")
 function vars(){var def={},$=$B.args('vars',1,{obj:null},['obj'],arguments,{obj:def},null,null)
 if($.obj===def){return _b_.locals()}else{try{return $B.$getattr($.obj,'__dict__')}
 catch(err){if(err.__class__===_b_.AttributeError){throw _b_.TypeError.$factory("vars() argument must have __dict__ attribute")}
 throw err}}}
 var $Reader=$B.make_class("Reader")
 $Reader.__enter__=function(self){return self}
 $Reader.__exit__=function(self){return false}
 $Reader.__iter__=function(self){
 return iter($Reader.readlines(self))}
 $Reader.__len__=function(self){return self.lines.length}
 $Reader.close=function(self){self.closed=true}
 $Reader.flush=function(self){return None}
 $Reader.read=function(){var $=$B.args("read",2,{self:null,size:null},["self","size"],arguments,{size:-1},null,null),self=$.self,size=$B.$GetInt($.size)
 if(self.closed===true){throw _b_.ValueError.$factory('I/O operation on closed file')}
 make_content(self)
 var len=self.$binary ? self.$bytes.source.length :self.$string.length
 if(size < 0){size=len-self.$counter}
 if(self.$binary){res=_b_.bytes.$factory(self.$bytes.source.slice(self.$counter,self.$counter+size))}else{res=self.$string.substr(self.$counter,size)}
 self.$counter+=size
 return res}
 $Reader.readable=function(self){return true}
 function make_content(self){
 if(self.$binary && self.$bytes===undefined){self.$bytes=_b_.str.encode(self.$string,self.encoding)}else if((! self.$binary)&& self.$string===undefined){self.$string=_b_.bytes.decode(self.$bytes,self.encoding)}}
 function make_lines(self){
 if(self.$lines===undefined){make_content(self)
 if(! self.$binary){self.$lines=self.$string.split("\n")}else{console.log("make lines, binary")
 var lines=[],pos=0,source=self.$bytes.source
 while(true){var ix=source.indexOf(10)
 if(ix==-1){lines.push({__class__:_b_.bytes,source:source})
 break}else{lines.push({__class__:_b_.bytes,source:source.slice(0,ix+1)})
 source=source.slice(ix+1)}}
 self.$lines=lines}}}
 $Reader.readline=function(self,size){var $=$B.args("readline",2,{self:null,size:null},["self","size"],arguments,{size:-1},null,null),self=$.self,size=$B.$GetInt($.size)
 self.$lc=self.$lc===undefined ?-1 :self.$lc
 if(self.closed===true){throw _b_.ValueError.$factory('I/O operation on closed file')}
 make_content(self)
 if(self.$binary){var ix=self.$bytes.source.indexOf(10,self.$counter)
 if(ix==-1){return _b_.bytes.$factory()}else{var res={__class__:_b_.bytes,source :self.$bytes.source.slice(self.$counter,ix+1)}
 self.$counter=ix+1
 return res}}else{var ix=self.$string.indexOf("\n",self.$counter)
 if(ix==-1){return ''}else{var res=self.$string.substring(self.$counter,ix+1)
 self.$counter=ix+1
 self.$lc+=1
 return res}}}
 $Reader.readlines=function(){var $=$B.args("readlines",2,{self:null,hint:null},["self","hint"],arguments,{hint:-1},null,null),self=$.self,hint=$B.$GetInt($.hint)
 var nb_read=0
 if(self.closed===true){throw _b_.ValueError.$factory('I/O operation on closed file')}
 self.$lc=self.$lc===undefined ?-1 :self.$lc
 make_lines(self)
 if(hint < 0){var lines=self.$lines.slice(self.$lc+1)}else{var lines=[]
 while(self.$lc < self.$lines.length &&
 nb_read < hint){self.$lc++
 lines.push(self.$lines[self.$lc])}}
 while(lines[lines.length-1]==''){lines.pop()}
 return lines}
 $Reader.seek=function(self,offset,whence){if(self.closed===True){throw _b_.ValueError.$factory('I/O operation on closed file')}
 if(whence===undefined){whence=0}
 if(whence===0){self.$counter=offset}
 else if(whence===1){self.$counter+=offset}
 else if(whence===2){self.$counter=self.$content.length+offset}}
 $Reader.seekable=function(self){return true}
 $Reader.tell=function(self){return self.$counter}
 $Reader.writable=function(self){return false}
 $B.set_func_names($Reader,"builtins")
 var $BufferedReader=$B.make_class('_io.BufferedReader')
 $BufferedReader.__mro__=[$Reader,_b_.object]
 var $TextIOWrapper=$B.make_class('_io.TextIOWrapper',function(){var $=$B.args("TextIOWrapper",6,{buffer:null,encoding:null,errors:null,newline:null,line_buffering:null,write_through:null},["buffer","encoding","errors","newline","line_buffering","write_through"],arguments,{encoding:"utf-8",errors:_b_.None,newline:_b_.None,line_buffering:_b_.False,write_through:_b_.False},null,null)
 return{
 __class__:$TextIOWrapper,$bytes:$.buffer.$bytes,encoding:$.encoding,errors:$.errors,newline:$.newline}}
 )
 $TextIOWrapper.__mro__=[$Reader,_b_.object]
 $B.set_func_names($TextIOWrapper,"builtins")
 $B.Reader=$Reader
 $B.TextIOWrapper=$TextIOWrapper
 $B.BufferedReader=$BufferedReader
 function $url_open(){
 var $ns=$B.args('open',3,{file:null,mode:null,encoding:null},['file','mode','encoding'],arguments,{mode:'r',encoding:'utf-8'},'args','kw'),$bytes,$string,$res
 for(var attr in $ns){eval('var '+attr+'=$ns["'+attr+'"]')}
 if(args.length > 0){var mode=args[0]}
 if(args.length > 1){var encoding=args[1]}
 if(mode.search('w')>-1){throw _b_.IOError.$factory("Browsers cannot write on disk")}else if(['r','rb'].indexOf(mode)==-1){throw _b_.ValueError.$factory("Invalid mode '"+mode+"'")}
 if(isinstance(file,_b_.str)){
 var is_binary=mode.search('b')>-1
 if($B.file_cache.hasOwnProperty($ns.file)){$string=$B.file_cache[$ns.file]}else if($B.files && $B.files.hasOwnProperty($ns.file)){
 $res=atob($B.files[$ns.file].content)
 var source=[]
 for(const char of $res){source.push(char.charCodeAt(0))}
 $bytes=_b_.bytes.$factory()
 $bytes.source=source}else if($B.protocol !="file"){
 if(is_binary){throw _b_.IOError.$factory(
 "open() in binary mode is not supported")}
 var req=new XMLHttpRequest();
 req.onreadystatechange=function(){try{var status=this.status
 if(status==404){$res=_b_.FileNotFoundError.$factory(file)}else if(status !=200){$res=_b_.IOError.$factory('Could not open file '+
 file+' : status '+status)}else{$res=this.responseText}}catch(err){$res=_b_.IOError.$factory('Could not open file '+
 file+' : error '+err)}}
 var fake_qs=$B.$options.cache ? '' :
 '?foo='+(new Date().getTime())
 req.open('GET',file+fake_qs,false)
 req.overrideMimeType('text/plain; charset=utf-8')
 req.send()
 if($res.constructor===Error){throw $res}
 $string=$res}else{throw _b_.FileNotFoundError.$factory(
 "cannot use 'open()' with protocol 'file'")}
 if($string===undefined && $bytes===undefined){throw _b_.FileNotFoundError.$factory($ns.file)}
 var res={$binary:is_binary,$string:$string,$bytes:$bytes,$counter:0,closed:False,encoding:encoding,mode:mode,name:file}
 res.__class__=is_binary ? $BufferedReader :$TextIOWrapper
 return res}else{throw _b_.TypeError.$factory("invalid argument for open(): "+
 _b_.str.$factory(file))}}
 var zip=$B.make_class("zip",function(){var res={__class__:zip,items:[]}
 if(arguments.length==0)return res
 var $ns=$B.args('zip',0,{},[],arguments,{},'args','kw')
 var _args=$ns['args']
 var args=[]
 for(var i=0;i < _args.length;i++){args.push(iter(_args[i]))}
 var rank=0,items=[]
 while(1){var line=[],flag=true
 for(var i=0;i < args.length;i++){try{line.push(next(args[i]))}catch(err){if(err.__class__==_b_.StopIteration){flag=false
 break}else{throw err}}}
 if(!flag){break}
 items[rank++]=_b_.tuple.$factory(line)}
 res.items=items
 return res}
 )
 var zip_iterator=$B.make_iterator_class('zip_iterator')
 zip.__iter__=function(self){return zip_iterator.$factory(self.items)}
 $B.set_func_names(zip,"builtins")
 function no_set_attr(klass,attr){if(klass[attr]!==undefined){throw _b_.AttributeError.$factory("'"+klass.$infos.__name__+
 "' object attribute '"+attr+"' is read-only")}else{throw _b_.AttributeError.$factory("'"+klass.$infos.__name__+
 "' object has no attribute '"+attr+"'")}}
 var True=true
 var False=false
 var ellipsis=$B.make_class("ellipsis",function(){return Ellipsis}
 )
 var Ellipsis={__class__:ellipsis,__bool__:function(){return True},}
 for(var $key in $B.$comps){
 switch($B.$comps[$key]){case 'ge':
 case 'gt':
 case 'le':
 case 'lt':
 ellipsis['__'+$B.$comps[$key]+'__']=(function(k){return function(other){throw _b_.TypeError.$factory("unorderable types: ellipsis() "+
 k+" "+$B.class_name(other))}})($key)}}
 for(var $func in Ellipsis){if(typeof Ellipsis[$func]=='function'){Ellipsis[$func].__str__=(function(f){return function(){return "<method-wrapper "+f+
 " of Ellipsis object>"}})($func)}}
 $B.set_func_names(ellipsis)
 var FunctionCode=$B.make_class("function code")
 var FunctionGlobals=$B.make_class("function globals")
 $B.Function={__class__:_b_.type,__code__:{__class__:FunctionCode,__name__:'function code'},__globals__:{__class__:FunctionGlobals,__name__:'function globals'},__mro__:[_b_.object],$infos:{__name__:'function',__module__:"builtins"},$is_class:true}
 $B.Function.__delattr__=function(self,attr){if(attr=="__dict__"){throw _b_.TypeError.$factory("can't deleted function __dict__")}}
 $B.Function.__dir__=function(self){var infos=self.$infos ||{},attrs=self.$attrs ||{}
 return Object.keys(infos).concat(Object.keys(attrs))}
 $B.Function.__eq__=function(self,other){return self===other}
 $B.Function.__get__=function(self,obj){if(obj===_b_.None){return self}
 var method=function(){return self(obj,...arguments)}
 method.__class__=$B.method
 if(self.$infos===undefined){console.log("no $infos",self)
 console.log($B.last($B.frames_stack))}
 method.$infos={__name__:self.$infos.__name__,__qualname__:$B.class_name(obj)+"."+self.$infos.__name__,__self__:obj,__func__:self}
 return method}
 $B.Function.__getattribute__=function(self,attr){
 if(self.$infos && self.$infos[attr]!==undefined){if(attr=='__code__'){var res={__class__:code}
 for(var attr in self.$infos.__code__){res[attr]=self.$infos.__code__[attr]}
 res.name=self.$infos.__name__
 res.filename=self.$infos.__code__.co_filename
 res.co_code=self+"" 
 return res}else if(attr=='__annotations__'){
 return $B.obj_dict(self.$infos[attr])}else if(self.$infos.hasOwnProperty(attr)){return self.$infos[attr]}}else if(self.$infos && self.$infos.__dict__ &&
 self.$infos.__dict__.$string_dict[attr]!==undefined){return self.$infos.__dict__.$string_dict[attr][0]}else if(attr=="__closure__"){var free_vars=self.$infos.__code__.co_freevars
 if(free_vars.length==0){return None}
 var cells=[]
 for(var i=0;i < free_vars.length;i++){try{cells.push($B.cell.$factory($B.$check_def_free(free_vars[i])))}catch(err){
 cells.push($B.cell.$factory(None))}}
 return _b_.tuple.$factory(cells)}else if(attr=="__globals__"){return $B.obj_dict($B.imported[self.$infos.__module__])}else if(self.$attrs && self.$attrs[attr]!==undefined){return self.$attrs[attr]}else{return _b_.object.__getattribute__(self,attr)}}
 $B.Function.__repr__=$B.Function.__str__=function(self){if(self.$infos===undefined){return '<function '+self.name+'>'}else{return '<function '+self.$infos.__qualname__+'>'}}
 $B.Function.__mro__=[_b_.object]
 $B.Function.__setattr__=function(self,attr,value){if(attr=="__closure__"){throw _b_.AttributeError.$factory("readonly attribute")}else if(attr=="__defaults__"){
 if(value===_b_.None){value=[]}else if(! isinstance(value,_b_.tuple)){throw _b_.TypeError.$factory(
 "__defaults__ must be set to a tuple object")}
 var set_func=self.$set_defaults
 if(set_func===undefined){throw _b_.AttributeError.$factory("cannot set attribute "+attr+
 " of "+_b_.str.$factory(self))}
 if(self.$infos && self.$infos.__code__){
 var argcount=self.$infos.__code__.co_argcount,varnames=self.$infos.__code__.co_varnames,params=varnames.slice(0,argcount),$defaults={}
 for(var i=value.length-1;i >=0;i--){var pos=params.length-value.length+i
 if(pos < 0){break}
 $defaults[params[pos]]=value[i]}}else{throw _b_.AttributeError.$factory("cannot set attribute "+attr+
 " of "+_b_.str.$factory(self))}
 var klass=self.$infos.$class 
 var new_func=set_func($defaults)
 new_func.$set_defaults=set_func
 if(klass){klass[self.$infos.__name__]=new_func
 new_func.$infos.$class=klass
 new_func.$infos.__defaults__=value}else{
 self.$infos.$defaults=value
 self.$infos.__defaults__=value}
 return _b_.None}
 if(self.$infos[attr]!==undefined){self.$infos[attr]=value}
 else{self.$attrs=self.$attrs ||{};self.$attrs[attr]=value}}
 $B.Function.$factory=function(){}
 $B.set_func_names($B.Function,"builtins")
 _b_.__BRYTHON__=__BRYTHON__
 $B.builtin_funcs=["abs","all","any","ascii","bin","breakpoint","callable","chr","compile","delattr","dir","divmod","eval","exec","exit","format","getattr","globals","hasattr","hash","help","hex","id","input","isinstance","issubclass","iter","len","locals","max","min","next","oct","open","ord","pow","print","quit","repr","round","setattr","sorted","sum","vars"
 ]
 var builtin_function=$B.builtin_function=$B.make_class("builtin_function_or_method")
 builtin_function.__getattribute__=$B.Function.__getattribute__
 builtin_function.__reduce_ex__=builtin_function.__reduce__=function(self){return self.$infos.__name__}
 builtin_function.__repr__=builtin_function.__str__=function(self){return '<built-in function '+self.$infos.__name__+'>'}
 $B.set_func_names(builtin_function,"builtins")
 var method_wrapper=$B.make_class("method_wrapper")
 method_wrapper.__repr__=method_wrapper.__str__=function(self){return "<method wrapper '"+self.$infos.__name__+"' of function object>"}
 $B.set_func_names(method_wrapper,"builtins")
 var wrapper_descriptor=$B.wrapper_descriptor=
 $B.make_class("wrapper_descriptor")
 wrapper_descriptor.__getattribute__=$B.Function.__getattribute__
 wrapper_descriptor.__repr__=wrapper_descriptor.__str__=function(self){return "<slot wrapper '"+self.$infos.__name__+"' of '"+
 self.__objclass__.$infos.__name__+"' object>"}
 $B.set_func_names(wrapper_descriptor,"builtins")
 $B.builtin_classes=["bool","bytearray","bytes","classmethod","complex","dict","enumerate","filter","float","frozenset","int","list","map","memoryview","object","property","range","reversed","set","slice","staticmethod","str","super","tuple","type","zip"
 ]
 var other_builtins=['Ellipsis','False','None','True','__debug__','__import__','copyright','credits','license','NotImplemented'
 ]
 var builtin_names=$B.builtin_funcs.
 concat($B.builtin_classes).
 concat(other_builtins)
 for(var i=0;i < builtin_names.length;i++){var name=builtin_names[i],orig_name=name,name1=name
 if(name=='open'){name1='$url_open'}
 if(name=='super'){name=name1='$$super'}
 if(name=='eval'){name=name1='$$eval'}
 if(name=='print'){name1='$print'}
 try{_b_[name]=eval(name1)
 if($B.builtin_funcs.indexOf(orig_name)>-1){_b_[name].__class__=builtin_function
 _b_[name].$infos={__module__:'builtins',__name__:orig_name,__qualname__:orig_name}}}
 catch(err){}}
 _b_['open']=$url_open
 _b_['print']=$print
 _b_['$$super']=$$super
 _b_.object.__init__.__class__=wrapper_descriptor
 _b_.object.__new__.__class__=builtin_function})(__BRYTHON__)
 ;
 ;(function($B){var bltns=$B.InjectBuiltins()
 eval(bltns)
 $B.del_exc=function(){var frame=$B.last($B.frames_stack)
 frame[1].$current_exception=undefined}
 $B.set_exc=function(exc){var frame=$B.last($B.frames_stack)
 if(frame===undefined){console.log("no frame",exc)}
 frame[1].$current_exception=$B.exception(exc)}
 $B.get_exc=function(){var frame=$B.last($B.frames_stack)
 return frame[1].$current_exception}
 $B.$raise=function(arg){
 if(arg===undefined){var es=$B.get_exc()
 if(es !==undefined){throw es}
 throw _b_.RuntimeError.$factory("No active exception to reraise")}else if(isinstance(arg,BaseException)){if(arg.__class__===_b_.StopIteration &&
 $B.last($B.frames_stack)[1].$is_generator){
 arg=_b_.RuntimeError.$factory("generator raised StopIteration")}
 throw arg}else if(arg.$is_class && issubclass(arg,BaseException)){if(arg===_b_.StopIteration){if($B.last($B.frames_stack)[1].$is_generator){
 throw _b_.RuntimeError.$factory("generator raised StopIteration")}}
 throw $B.$call(arg)()}else{throw _b_.TypeError.$factory("exceptions must derive from BaseException")}}
 $B.$syntax_err_line=function(exc,module,src,pos,line_num){
 var pos2line={},lnum=1,module=module.charAt(0)=="$" ? "<string>" :module
 if(src===undefined){exc.$line_info=line_num+','+module
 exc.args=_b_.tuple.$factory([$B.$getitem(exc.args,0),module,line_num,0,0])}else{var line_pos={1:0}
 for(var i=0,len=src.length;i < len;i++){pos2line[i]=lnum
 if(src.charAt(i)=="\n"){line_pos[++lnum]=i}}
 while(line_num===undefined){line_num=pos2line[pos]
 pos--}
 exc.$line_info=line_num+","+module
 var lines=src.split("\n"),line=lines[line_num-1],lpos=pos-line_pos[line_num],len=line.length
 exc.text=line
 lpos-=len-line.length
 if(lpos < 0){lpos=0}
 while(line.charAt(0)==' '){line=line.substr(1)
 if(lpos > 0){lpos--}}
 exc.offset=lpos
 exc.args=_b_.tuple.$factory([$B.$getitem(exc.args,0),module,line_num,lpos,line])}
 exc.lineno=line_num
 exc.msg=exc.args[0]
 exc.filename=module}
 $B.$SyntaxError=function(module,msg,src,pos,line_num,root){if(root !==undefined && root.line_info !==undefined){
 line_num=root.line_info}
 var exc=_b_.SyntaxError.$factory(msg)
 $B.$syntax_err_line(exc,module,src,pos,line_num)
 throw exc}
 $B.$IndentationError=function(module,msg,src,pos,line_num,root){$B.frames_stack.push([module,{$line_info:line_num+","+module},module,{$src:src}])
 if(root !==undefined && root.line_info !==undefined){
 line_num=root.line_info}
 var exc=_b_.IndentationError.$factory(msg)
 $B.$syntax_err_line(exc,module,src,pos,line_num)
 throw exc}
 $B.print_stack=function(stack){stack=stack ||$B.frames_stack
 var trace=[]
 stack.forEach(function(frame){var line_info=frame[1].$line_info
 if(line_info !==undefined){var info=line_info.split(",")
 if(info[1].startsWith("$exec")){info[1]="<module>"}
 trace.push(info[1]+" line "+info[0])
 var src=$B.file_cache[frame[3].__file__]
 if(src){var lines=src.split("\n"),line=lines[parseInt(info[0])-1]
 trace.push("  "+line.trim())}}})
 console.log("print stack ok",trace)
 return trace.join("\n")}
 var traceback=$B.traceback=$B.make_class("traceback",function(exc,stack){var frame=$B.last($B.frames_stack)
 if(stack===undefined){stack=exc.$stack}
 return{
 __class__ :traceback,$stack:stack,exc:exc}}
 )
 traceback.__getattribute__=function(self,attr){var line_info
 if(attr==='tb_frame' ||
 attr==='tb_lineno' ||
 attr==='tb_lasti' ||
 attr==='tb_next'){if(self.$stack.length==0){console.log("no stack",attr)}
 var first_frame=self.$stack[0]
 line_info=self.exc.$line_infos[self.exc.$line_infos.length-
 self.$stack.length]}
 switch(attr){case "tb_frame":
 return frame.$factory(self.$stack)
 case "tb_lineno":
 var lineno
 if(line_info===undefined ||
 first_frame[0].startsWith($B.lambda_magic)){if(first_frame[4]&& first_frame[4].$infos &&
 first_frame[4].$infos.__code__){lineno=first_frame[4].$infos.__code__.co_firstlineno}else{lineno=-1}}else{lineno=parseInt(line_info.split(",")[0])}
 return lineno
 case "tb_lasti":
 if(line_info===undefined){console.log("no line info",self.$stack)
 return ""}else{var info=line_info.split(","),src,file
 for(var i=self.$stack.length-1;i >=0;i--){var fr=self.$stack[i]
 if(fr[2]==info[1].replace(/\./g,'_')){file=fr[3].__file__
 break}}
 if(src===undefined){if($B.file_cache.hasOwnProperty(file)){src=$B.file_cache[file]}else if($B.imported[info[1]]&& $B.imported[info[1]].__file__ ){src=$B.file_cache[$B.imported[info[1]].__file__]
 console.log("from filecache",line_info,$B.imported[info[1]].__file__)}}
 if(src !==undefined){try{return src.split("\n")[parseInt(info[0]-1)].trim()}catch(err){console.log("error in attr tb_lasti of",self)
 console.log(src,info)
 throw err}}else{console.log(file)
 console.log("no src for",info)
 return ""}}
 case "tb_next":
 if(self.$stack.length <=1){return None}
 else{return traceback.$factory(self.exc,self.$stack.slice(1))}
 default:
 return _b_.object.__getattribute__(self,attr)}}
 $B.set_func_names(traceback,"builtins")
 var frame=$B.make_class("frame",function(stack,pos){var fs=stack
 var res={__class__:frame,f_builtins :{},
 $stack:stack.slice()}
 if(pos===undefined){pos=0}
 res.$pos=pos
 if(fs.length){var _frame=fs[pos],locals_id=_frame[0],filename
 try{res.f_locals=$B.obj_dict(_frame[1])}catch(err){console.log("err "+err)
 throw err}
 res.f_globals=$B.obj_dict(_frame[3])
 if(_frame[3].__file__ !==undefined){filename=_frame[3].__file__}
 if(locals_id.startsWith("$exec")){filename="<string>"}
 if(_frame[1].$line_info===undefined){res.f_lineno=-1}else{var line_info=_frame[1].$line_info.split(",")
 res.f_lineno=parseInt(line_info[0])
 var module_name=line_info[1]
 if($B.imported.hasOwnProperty(module_name)){filename=$B.imported[module_name].__file__}
 res.f_lineno=parseInt(_frame[1].$line_info.split(',')[0])}
 var co_name=locals_id.startsWith("$exec")? "<module>" :
 locals_id
 if(locals_id==_frame[2]){co_name="<module>"}else if(locals_id.startsWith("lc"+$B.lambda_magic)){co_name="<listcomp>"}else{if(_frame[1].$name){co_name=_frame[1].$name}else if(_frame[1].$dict_comp){co_name='<dictcomp>'}else if(_frame[1].$list_comp){co_name='<listcomp>'}else if(_frame.length > 4){if(_frame[4].$infos){co_name=_frame[4].$infos.__name__}else{co_name=_frame[4].name}
 if(_frame[4].$infos===undefined){
 if(_frame[4].name.startsWith("__ge")){co_name="<genexpr>"}else if(_frame[4].name.startsWith("set_comp"+
 $B.lambda_magic)){co_name="<setcomp>"}else if(_frame[4].name.startsWith("lambda"+
 $B.lambda_magic)){co_name="<lambda>"}}else if(filename===undefined && _frame[4].$infos.__code__){filename=_frame[4].$infos.__code__.co_filename
 if(filename===undefined){filename=_frame[4].$infos.__module__}
 res.f_lineno=_frame[4].$infos.__code__.co_firstlineno}}}
 if(_frame.length > 4 && _frame[4].$infos !==undefined){res.f_code=_frame[4].$infos.__code__}else{res.f_code={co_name:co_name,co_filename:filename}}
 res.f_code.__class__=$B.code
 res.f_code.co_code=_b_.None
 if(filename===undefined){res.f_code.co_filename="<string>"}}
 return res}
 )
 frame.__delattr__=function(self,attr){if(attr=="f_trace"){$B.last(self.$stack)[1].$f_trace=_b_.None}}
 frame.__getattr__=function(self,attr){
 if(attr=="f_back"){if(self.$pos > 0){return frame.$factory(self.$stack.slice(0,self.$stack.length-1),self.$pos-1)}else{return _b_.None}}else if(attr=="clear"){return function(){}}else if(attr=="f_trace"){var locals=$B.last(self.$stack)[1]
 if(locals.$f_trace===undefined){return _b_.None}
 return locals.$f_trace}}
 frame.__setattr__=function(self,attr,value){if(attr=="f_trace"){
 $B.last(self.$stack)[1].$f_trace=value}}
 frame.__str__=frame.__repr__=function(self){return '<frame object, file '+self.f_code.co_filename+
 ', line '+self.f_lineno+', code '+self.f_code.co_name+'>'}
 $B.set_func_names(frame,"builtins")
 $B._frame=frame 
 var BaseException=_b_.BaseException={__class__:_b_.type,__bases__ :[_b_.object],__mro__:[_b_.object],args:[],$infos:{__name__:"BaseException",__module__:"builtins"},$is_class:true}
 BaseException.__init__=function(self){var args=arguments[1]===undefined ?[]:[arguments[1]]
 self.args=_b_.tuple.$factory(args)}
 BaseException.__repr__=function(self){var res=self.__class__.$infos.__name__
 if(self.args[0]){res+='('+repr(self.args[0])}
 if(self.args.length > 1){res+=', '+repr($B.fast_tuple(self.args.slice(1)))}
 return res+')'}
 BaseException.__str__=function(self){if(self.args.length > 0){return _b_.str.$factory(self.args[0])}
 return self.__class__.$infos.__name__}
 BaseException.__new__=function(cls){var err=_b_.BaseException.$factory()
 err.__class__=cls
 err.__dict__=$B.empty_dict()
 return err}
 var getExceptionTrace=function(exc,includeInternal){if(exc.__class__===undefined){if($B.debug > 1){console.log("no class",exc)}
 return exc+''}
 var info=''
 if(exc.$js_exc !==undefined && includeInternal){info+="\nJS stack:\n"+exc.$js_exc.stack+"\n"}
 info+="Traceback (most recent call last):"
 var line_info=exc.$line_info
 for(var i=0;i < exc.$stack.length;i++){var frame=exc.$stack[i]
 if(! frame[1]||! frame[1].$line_info){continue}
 var $line_info=frame[1].$line_info
 var line_info=$line_info.split(','),src
 if(exc.module==line_info[1]){src=exc.src}
 if(!includeInternal){var src=frame[3].$src
 if(src===undefined){if($B.VFS && $B.VFS.hasOwnProperty(frame[2])){src=$B.VFS[frame[2]][1]}else if(src=$B.file_cache[frame[3].__file__]){}else{continue}}}
 var file=frame[3].__file__ ||"<string>",module=line_info[1],is_exec=module.charAt(0)=="$"
 if(is_exec){module="<module>"}
 info+="\n  File "+file+" line "+line_info[0]
 if(frame.length > 4){if(frame[4].$infos){var name=frame[4].$infos.__name__
 if(name.startsWith("lc"+$B.lambda_magic)){info+=',in <listcomp>'}else{info+=', in '+name}}else if(frame[4].name.startsWith("__ge")){info+=', in <genexpr>'}else if(frame[4].name.startsWith("set_comp"+$B.lambda_magic)){info+=', in <setcomp>'}else if(frame[4].name.startsWith("lc"+$B.lambda_magic)){info+=', in <listcomp>'}else{console.log("frame[4]",frame[4])}}else if(frame[1].$list_comp){info+=', in <listcomp>'}else if(frame[1].$dict_comp){info+=', in <dictcomp>'}else{info+=', in <module>'}
 if(src !==undefined && ! is_exec){var lines=src.split("\n"),line=lines[parseInt(line_info[0])-1]
 if(line){line=line.replace(/^[ ]+/g,"")}
 info+="\n    "+line}}
 if(exc.__class__===_b_.SyntaxError){info+="\n  File "+exc.args[1]+", line "+exc.args[2]+
 "\n    "+exc.args[4]}
 return info}
 BaseException.__getattr__=function(self,attr){if(attr=="info"){return getExceptionTrace(self,false);}else if(attr=="infoWithInternal"){return getExceptionTrace(self,true);}else if(attr=="__traceback__"){
 if(self.$traceback !==undefined){return self.$traceback}
 return traceback.$factory(self)}else{throw _b_.AttributeError.$factory(self.__class__.$infos.__name__+
 " has no attribute '"+attr+"'")}}
 BaseException.with_traceback=function(self,tb){self.$traceback=tb
 return self}
 $B.deep_copy=function(stack){var res=[]
 for(const s of stack){var item=[s[0],{},s[2],{}]
 if(s[4]!==undefined){item.push(s[4])}
 for(const i of[1,3]){for(var key in s[i]){item[i][key]=s[i][key]}}
 res.push(item)}
 return res}
 $B.save_stack=function(){return $B.deep_copy($B.frames_stack)}
 $B.restore_stack=function(stack,locals){$B.frames_stack=stack
 $B.frames_stack[$B.frames_stack.length-1][1]=locals}
 $B.freeze=function(err){
 if(err.$stack===undefined){err.$line_infos=[]
 for(var i=0,len=$B.frames_stack.length;i < len;i++){err.$line_infos.push($B.frames_stack[i][1].$line_info)}
 err.$stack=$B.frames_stack.slice()
 if($B.frames_stack.length){err.$line_info=$B.last($B.frames_stack)[1].$line_info}}}
 var show_stack=$B.show_stack=function(stack){stack=stack ||$B.frames_stack
 for(const frame of stack){console.log(frame[0],frame[1].$line_info)}}
 BaseException.$factory=function(){var err=Error()
 err.args=$B.fast_tuple(Array.prototype.slice.call(arguments))
 err.__class__=_b_.BaseException
 err.$py_error=true
 $B.freeze(err)
 eval("//placeholder//")
 err.__cause__=_b_.None 
 err.__context__=_b_.None 
 err.__suppress_context__=false 
 return err}
 BaseException.$factory.$infos={__name__:"BaseException",__qualname__:"BaseException"}
 $B.set_func_names(BaseException)
 _b_.BaseException=BaseException
 $B.exception=function(js_exc,in_ctx_manager){
 if(! js_exc.__class__){console.log("Javascript exception:",js_exc)
 console.log($B.last($B.frames_stack))
 console.log("recursion error ?",$B.is_recursion_error(js_exc))
 var exc=Error()
 exc.__name__="Internal Javascript error: "+
 (js_exc.__name__ ||js_exc.name)
 exc.__class__=_b_.Exception
 exc.$js_exc=js_exc
 if($B.is_recursion_error(js_exc)){return _b_.RecursionError.$factory("too much recursion")}else if(js_exc.name=="ReferenceError"){exc.__name__="NameError"
 exc.__class__=_b_.NameError
 js_exc.message=js_exc.message.replace("$$","")}else if(js_exc.name=="InternalError"){exc.__name__="RuntimeError"
 exc.__class__=_b_.RuntimeError}
 exc.__cause__=_b_.None
 exc.__context__=_b_.None
 exc.__suppress_context__=false
 var $message="<Javascript "+js_exc.name+">: "+
 (js_exc.message ||"<"+js_exc+">")
 exc.args=_b_.tuple.$factory([$message])
 exc.$py_error=true
 $B.freeze(exc)}else{var exc=js_exc
 $B.freeze(exc)
 if(in_ctx_manager){
 var current_locals=$B.last($B.frames_stack)[0]
 for(var i=0,len=exc.$stack.length;i < len;i++){if(exc.$stack[i][0]==current_locals){exc.$stack=exc.$stack.slice(i)
 exc.$traceback=traceback.$factory(exc)
 break}}}}
 return exc}
 $B.is_exc=function(exc,exc_list){
 if(exc.__class__===undefined){exc=$B.exception(exc)}
 var this_exc_class=exc.$is_class ? exc :exc.__class__
 for(var i=0;i < exc_list.length;i++){var exc_class=exc_list[i]
 if(this_exc_class===undefined){console.log("exc class undefined",exc)}
 if(issubclass(this_exc_class,exc_class)){return true}}
 return false}
 $B.is_recursion_error=function(js_exc){
 console.log("test is js exc is recursion error",js_exc,js_exc+"")
 var msg=js_exc+"",parts=msg.split(":"),err_type=parts[0].trim(),err_msg=parts[1].trim()
 return(err_type=='InternalError' && err_msg=='too much recursion')||
 (err_type=='Error' && err_msg=='Out of stack space')||
 (err_type=='RangeError' && err_msg=='Maximum call stack size exceeded')}
 function $make_exc(names,parent){
 var _str=[],pos=0
 for(var i=0;i < names.length;i++){var name=names[i],code=""
 if(Array.isArray(name)){
 var code=name[1],name=name[0]}
 $B.builtins_scope[name]=true
 var $exc=(BaseException.$factory+"").replace(/BaseException/g,name)
 $exc=$exc.replace("//placeholder//",code)
 _str[pos++]="_b_."+name+' = {__class__:_b_.type, '+
 '__mro__: [_b_.'+parent.$infos.__name__+
 "].concat(parent.__mro__), $is_class: true,"+
 "$infos: {__name__:'"+name+"'}}"
 _str[pos++]="_b_."+name+".$factory = "+$exc
 _str[pos++]="_b_."+name+'.$factory.$infos = {__name__: "'+
 name+'", __qualname__: "'+name+'"}'
 _str[pos++]="$B.set_func_names(_b_."+name+", 'builtins')"}
 try{eval(_str.join(";"))}catch(err){console.log("--err"+err)
 throw err}}
 $make_exc(["SystemExit","KeyboardInterrupt","GeneratorExit","Exception"],BaseException)
 $make_exc([["StopIteration","err.value = arguments[0]"],["StopAsyncIteration","err.value = arguments[0]"],"ArithmeticError","AssertionError","AttributeError","BufferError","EOFError",["ImportError","err.name = arguments[0]"],"LookupError","MemoryError","NameError","OSError","ReferenceError","RuntimeError",["SyntaxError","err.msg = arguments[0]"],"SystemError","TypeError","ValueError","Warning"],_b_.Exception)
 $make_exc(["FloatingPointError","OverflowError","ZeroDivisionError"],_b_.ArithmeticError)
 $make_exc([["ModuleNotFoundError","err.name = arguments[0]"]],_b_.ImportError)
 $make_exc(["IndexError","KeyError"],_b_.LookupError)
 $make_exc(["UnboundLocalError"],_b_.NameError)
 $make_exc(["BlockingIOError","ChildProcessError","ConnectionError","FileExistsError","FileNotFoundError","InterruptedError","IsADirectoryError","NotADirectoryError","PermissionError","ProcessLookupError","TimeoutError"],_b_.OSError)
 $make_exc(["BrokenPipeError","ConnectionAbortedError","ConnectionRefusedError","ConnectionResetError"],_b_.ConnectionError)
 $make_exc(["NotImplementedError","RecursionError"],_b_.RuntimeError)
 $make_exc(["IndentationError"],_b_.SyntaxError)
 $make_exc(["TabError"],_b_.IndentationError)
 $make_exc(["UnicodeError"],_b_.ValueError)
 $make_exc(["UnicodeDecodeError","UnicodeEncodeError","UnicodeTranslateError"],_b_.UnicodeError)
 $make_exc(["DeprecationWarning","PendingDeprecationWarning","RuntimeWarning","SyntaxWarning","UserWarning","FutureWarning","ImportWarning","UnicodeWarning","BytesWarning","ResourceWarning"],_b_.Warning)
 $make_exc(["EnvironmentError","IOError","VMSError","WindowsError"],_b_.OSError)
 $B.$TypeError=function(msg){throw _b_.TypeError.$factory(msg)}
 var se=_b_.SyntaxError.$factory
 _b_.SyntaxError.$factory=function(){var arg=arguments[0]
 if(arg.__class__===_b_.SyntaxError){return arg}
 var exc=se.apply(null,arguments),frame=$B.last($B.frames_stack)
 if(frame){line_info=frame[1].$line_info
 exc.filename=frame[3].__file__
 exc.lineno=parseInt(line_info.split(",")[0])
 var src=$B.file_cache[frame[3].__file__]
 if(src){lines=src.split("\n")
 exc.text=lines[exc.lineno-1]}
 exc.offset=arg.offset}
 return exc}
 _b_.SyntaxError})(__BRYTHON__)
 ;
 
 ;(function($B){var _b_=$B.builtins,None=_b_.None,range={__class__:_b_.type,__mro__:[_b_.object],$infos:{__module__:"builtins",__name__:"range"},$is_class:true,$native:true,$descriptors:{start:true,step:true,stop:true}}
 range.__contains__=function(self,other){if(range.__len__(self)==0){return false}
 try{other=$B.int_or_bool(other)}
 catch(err){
 try{range.index(self,other);return true}
 catch(err){return false}}
 var sub=$B.sub(other,self.start),fl=$B.floordiv(sub,self.step),res=$B.mul(self.step,fl)
 if($B.eq(res,sub)){if($B.gt(self.stop,self.start)){return $B.ge(other,self.start)&& $B.gt(self.stop,other)}else{return $B.ge(self.start,other)&& $B.gt(other,self.stop)}}else{return false}}
 range.__delattr__=function(self,attr,value){throw _b_.AttributeError.$factory("readonly attribute")}
 range.__eq__=function(self,other){if(_b_.isinstance(other,range)){var len=range.__len__(self)
 if(! $B.eq(len,range.__len__(other))){return false}
 if(len==0){return true}
 if(! $B.eq(self.start,other.start)){return false}
 if(len==1){return true}
 return $B.eq(self.step,other.step)}
 return false}
 function compute_item(r,i){var len=range.__len__(r)
 if(len==0){return r.start}
 else if(i > len){return r.stop}
 return $B.add(r.start,$B.mul(r.step,i))}
 range.__getitem__=function(self,rank){if(_b_.isinstance(rank,_b_.slice)){var norm=_b_.slice.$conv_for_seq(rank,range.__len__(self)),substep=$B.mul(self.step,norm.step),substart=compute_item(self,norm.start),substop=compute_item(self,norm.stop)
 return range.$factory(substart,substop,substep)}
 if(typeof rank !="number"){rank=$B.$GetInt(rank)}
 if($B.gt(0,rank)){rank=$B.add(rank,range.__len__(self))}
 var res=$B.add(self.start,$B.mul(rank,self.step))
 if(($B.gt(self.step,0)&&
 ($B.ge(res,self.stop)||$B.gt(self.start,res)))||
 ($B.gt(0,self.step)&&
 ($B.ge(self.stop,res)||$B.gt(res,self.start)))){throw _b_.IndexError.$factory("range object index out of range")}
 return res}
 range.__hash__=function(self){var len=range.__len__(self)
 if(len==0){return _b_.hash(_b_.tuple.$factory([0,None,None]))}
 if(len==1){return _b_.hash(_b_.tuple.$factory([1,self.start,None]))}
 return _b_.hash(_b_.tuple.$factory([len,self.start,self.step]))}
 var RangeIterator={__class__:_b_.type,__mro__:[_b_.object],__iter__:function(self){return self},__next__:function(self){return _b_.next(self.obj)},$infos:{__name__:"range_iterator",__module__:"builtins"},$is_class:true}
 RangeIterator.$factory=function(obj){return{__class__:RangeIterator,obj:obj}}
 $B.set_func_names(RangeIterator,"builtins")
 range.__iter__=function(self){var res={__class__ :range,start:self.start,stop:self.stop,step:self.step}
 if(self.$safe){res.$counter=self.start-self.step}else{res.$counter=$B.sub(self.start,self.step)}
 return RangeIterator.$factory(res)}
 range.__len__=function(self){var len
 if($B.gt(self.step,0)){if($B.ge(self.start,self.stop)){return 0}
 var n=$B.sub(self.stop,$B.add(1,self.start)),q=$B.floordiv(n,self.step)
 len=$B.add(1,q)}else{if($B.ge(self.stop,self.start)){return 0}
 var n=$B.sub(self.start,$B.add(1,self.stop)),q=$B.floordiv(n,$B.mul(-1,self.step))
 len=$B.add(1,q)}
 if($B.maxsize===undefined){$B.maxsize=$B.long_int.__pow__($B.long_int.$factory(2),63)
 $B.maxsize=$B.long_int.__sub__($B.maxsize,1)}
 return len}
 range.__next__=function(self){if(self.$safe){self.$counter+=self.step
 if((self.step > 0 && self.$counter >=self.stop)
 ||(self.step < 0 && self.$counter <=self.stop)){throw _b_.StopIteration.$factory("")}}else{self.$counter=$B.add(self.$counter,self.step)
 if(($B.gt(self.step,0)&& $B.ge(self.$counter,self.stop))
 ||($B.gt(0,self.step)&& $B.ge(self.stop,self.$counter))){throw _b_.StopIteration.$factory("")}}
 return self.$counter}
 range.__reversed__=function(self){var n=$B.sub(range.__len__(self),1)
 return range.$factory($B.add(self.start,$B.mul(n,self.step)),$B.sub(self.start,self.step),$B.mul(-1,self.step))}
 range.__repr__=range.__str__=function(self){var res="range("+_b_.str.$factory(self.start)+", "+
 _b_.str.$factory(self.stop)
 if(self.step !=1){res+=", "+_b_.str.$factory(self.step)}
 return res+")"}
 range.__setattr__=function(self,attr,value){throw _b_.AttributeError.$factory("readonly attribute")}
 range.start=function(self){return self.start}
 range.step=function(self){return self.step},range.stop=function(self){return self.stop}
 range.count=function(self,ob){if(_b_.isinstance(ob,[_b_.int,_b_.float,_b_.bool])){return _b_.int.$factory(range.__contains__(self,ob))}else{var comp=function(other){return $B.rich_comp("__eq__",ob,other)},it=range.__iter__(self),_next=RangeIterator.__next__,nb=0
 while(true){try{if(comp(_next(it))){nb++}}catch(err){if(_b_.isinstance(err,_b_.StopIteration)){return nb}
 throw err}}}}
 range.index=function(self,other){var $=$B.args("index",2,{self:null,other:null},["self","other"],arguments,{},null,null),self=$.self,other=$.other
 try{other=$B.int_or_bool(other)}catch(err){var comp=function(x){return $B.rich_comp("__eq__",other,x)},it=range.__iter__(self),_next=RangeIterator.__next__,nb=0
 while(true){try{if(comp(_next(it))){return nb}
 nb++}catch(err){if(_b_.isinstance(err,_b_.StopIteration)){throw _b_.ValueError.$factory(_b_.str.$factory(other)+
 " not in range")}
 throw err}}}
 var sub=$B.sub(other,self.start),fl=$B.floordiv(sub,self.step),res=$B.mul(self.step,fl)
 if($B.eq(res,sub)){if(($B.gt(self.stop,self.start)&& $B.ge(other,self.start)
 && $B.gt(self.stop,other))||
 ($B.ge(self.start,self.stop)&& $B.ge(self.start,other)
 && $B.gt(other,self.stop))){return fl}else{throw _b_.ValueError.$factory(_b_.str.$factory(other)+
 ' not in range')}}else{throw _b_.ValueError.$factory(_b_.str.$factory(other)+
 " not in range")}}
 range.$factory=function(){var $=$B.args("range",3,{start:null,stop:null,step:null},["start","stop","step"],arguments,{start:null,stop:null,step:null},null,null),start=$.start,stop=$.stop,step=$.step,safe
 if(stop===null && step===null){if(start==null){throw _b_.TypeError.$factory("range expected 1 arguments, got 0")}
 stop=$B.PyNumber_Index(start)
 safe=typeof stop==="number"
 return{__class__:range,start:0,stop:stop,step:1,$is_range:true,$safe:safe}}
 if(step===null){step=1}
 start=$B.PyNumber_Index(start)
 stop=$B.PyNumber_Index(stop)
 step=$B.PyNumber_Index(step)
 if(step==0){throw _b_.ValueError.$factory("range arg 3 must not be zero")}
 safe=(typeof start=="number" && typeof stop=="number" &&
 typeof step=="number")
 return{__class__:range,start:start,stop:stop,step:step,$is_range:true,$safe:safe}}
 $B.set_func_names(range,"builtins")
 var slice={__class__:_b_.type,__mro__:[_b_.object],$infos:{__module__:"builtins",__name__:"slice"},$is_class:true,$native:true,$descriptors:{start:true,step:true,stop:true}}
 slice.__eq__=function(self,other){var conv1=conv_slice(self),conv2=conv_slice(other)
 return conv1[0]==conv2[0]&&
 conv1[1]==conv2[1]&&
 conv1[2]==conv2[2]}
 slice.__repr__=slice.__str__=function(self){return "slice("+_b_.str.$factory(self.start)+", "+
 _b_.str.$factory(self.stop)+", "+_b_.str.$factory(self.step)+")"}
 slice.__setattr__=function(self,attr,value){throw _b_.AttributeError.$factory("readonly attribute")}
 function conv_slice(self){
 var attrs=["start","stop","step"],res=[]
 for(var i=0;i < attrs.length;i++){var val=self[attrs[i]]
 if(val===_b_.None){res.push(val)}else{try{res.push($B.PyNumber_Index(val))}catch(err){throw _b_.TypeError.$factory("slice indices must be "+
 "integers or None or have an __index__ method")}}}
 return res}
 slice.$conv_for_seq=function(self,len){
 var step=self.step===None ? 1 :$B.PyNumber_Index(self.step),step_is_neg=$B.gt(0,step),len_1=$B.sub(len,1)
 if(step==0){throw _b_.ValueError.$factory('slice step cannot be zero')}
 var start
 if(self.start===None){start=step_is_neg ? len_1 :0}else{start=$B.PyNumber_Index(self.start)
 if($B.gt(0,start)){start=$B.add(start,len)
 if($B.gt(0,start)){start=0}}
 if($B.ge(start,len)){start=step < 0 ? len_1 :len}}
 if(self.stop===None){stop=step_is_neg ?-1 :len}else{stop=$B.PyNumber_Index(self.stop)
 if($B.gt(0,stop)){stop=$B.add(stop,len)}
 if($B.ge(stop,len)){stop=step_is_neg ? len_1 :len}}
 return{start:start,stop:stop,step:step}}
 slice.start=function(self){return self.start}
 slice.step=function(self){return self.step}
 slice.stop=function(self){return self.stop}
 slice.indices=function(self,length){
 var $=$B.args("indices",2,{self:null,length:null},["self","length"],arguments,{},null,null)
 var len=$B.$GetInt($.length)
 if(len < 0){_b_.ValueError.$factory("length should not be negative")}
 var _step=(self.step==_b_.None)? 1 :self.step
 if(_step < 0){var _start=self.start,_stop=self.stop
 _start=(_start==_b_.None)? len-1 :
 (_start < 0)? _b_.max(-1,_start+len):_b_.min(len-1,self.start)
 _stop=(self.stop==_b_.None)?-1 :
 (_stop < 0)? _b_.max(-1,_stop+len):_b_.min(len-1,self.stop)}else{var _start=(self.start==_b_.None)? 0 :_b_.min(len,self.start)
 var _stop=(self.stop==_b_.None)? len :_b_.min(len,self.stop)
 if(_start < 0){_start=_b_.max(0,_start+len)}
 if(_stop < 0){_stop=_b_.max(0,_stop+len)}}
 return _b_.tuple.$factory([_start,_stop,_step])}
 slice.$factory=function(){var $=$B.args("slice",3,{start:null,stop:null,step:null},["start","stop","step"],arguments,{stop:null,step:null},null,null),start,stop,step
 if($.stop===null && $.step===null){start=_b_.None
 stop=$.start
 step=_b_.None}else{start=$.start
 stop=$.stop
 step=$.step===null ? _b_.None :$.step}
 var res={__class__ :slice,start:start,stop:stop,step:step}
 conv_slice(res)
 return res}
 $B.set_func_names(slice,"builtins")
 _b_.range=range
 _b_.slice=slice})(__BRYTHON__)
 ;
 ;(function($B){var _b_=$B.builtins
 var from_unicode={},to_unicode={}
 $B.to_bytes=function(obj){var res
 if(_b_.isinstance(obj,[bytes,bytearray])){res=obj.source}else{var ga=$B.$getattr(obj,"tobytes",null)
 if(ga !==null){res=$B.$call(ga)().source}
 else{throw _b_.TypeError.$factory("object doesn't support the buffer protocol")}}
 return res}
 function _strip(self,cars,lr){if(cars===undefined){cars=[]
 var ws='\r\n \t'
 for(var i=0,len=ws.length;i < len;i++){cars.push(ws.charCodeAt(i))}}else if(_b_.isinstance(cars,bytes)){cars=cars.source}else{throw _b_.TypeError.$factory("Type str doesn't support the buffer API")}
 if(lr=='l'){for(var i=0,len=self.source.length;i < len;i++){if(cars.indexOf(self.source[i])==-1){break}}
 return bytes.$factory(self.source.slice(i))}
 for(var i=self.source.length-1;i >=0;i--){if(cars.indexOf(self.source[i])==-1){break}}
 return bytes.$factory(self.source.slice(0,i+1))}
 function invalid(other){return ! _b_.isinstance(other,[bytes,bytearray])}
 var bytearray={__class__:_b_.type,__mro__:[_b_.object],$buffer_protocol:true,$infos:{__module__:"builtins",__name__:"bytearray"},$is_class:true}
 var mutable_methods=["__delitem__","clear","copy","count","index","pop","remove","reverse","sort"]
 mutable_methods.forEach(function(method){bytearray[method]=(function(m){return function(self){var args=[self.source],pos=1
 for(var i=1,len=arguments.length;i < len;i++){args[pos++]=arguments[i]}
 return _b_.list[m].apply(null,args)}})(method)})
 var bytearray_iterator=$B.make_iterator_class('bytearray_iterator')
 bytearray.__iter__=function(self){return bytearray_iterator.$factory(self.source)}
 bytearray.__mro__=[_b_.object]
 bytearray.__repr__=bytearray.__str__=function(self){return 'bytearray('+bytes.__repr__(self)+")"}
 bytearray.__setitem__=function(self,arg,value){if(_b_.isinstance(arg,_b_.int)){if(! _b_.isinstance(value,_b_.int)){throw _b_.TypeError.$factory('an integer is required')}else if(value > 255){throw _b_.ValueError.$factory("byte must be in range(0, 256)")}
 var pos=arg
 if(arg < 0){pos=self.source.length+pos}
 if(pos >=0 && pos < self.source.length){self.source[pos]=value}
 else{throw _b_.IndexError.$factory('list index out of range')}}else if(_b_.isinstance(arg,_b_.slice)){var start=arg.start===_b_.None ? 0 :arg.start
 var stop=arg.stop===_b_.None ? self.source.length :arg.stop
 if(start < 0){start=self.source.length+start}
 if(stop < 0){stop=self.source.length+stop}
 self.source.splice(start,stop-start)
 try{var $temp=_b_.list.$factory(value)
 for(var i=$temp.length-1;i >=0;i--){if(! _b_.isinstance($temp[i],_b_.int)){throw _b_.TypeError.$factory('an integer is required')}else if($temp[i]> 255){throw ValueError.$factory("byte must be in range(0, 256)")}
 self.source.splice(start,0,$temp[i])}}catch(err){throw _b_.TypeError.$factory("can only assign an iterable")}}else{throw _b_.TypeError.$factory('list indices must be integer, not '+
 $B.class_name(arg))}}
 bytearray.append=function(self,b){if(arguments.length !=2){throw _b_.TypeError.$factory(
 "append takes exactly one argument ("+(arguments.length-1)+
 " given)")}
 if(! _b_.isinstance(b,_b_.int)){throw _b_.TypeError.$factory("an integer is required")}
 if(b > 255){throw ValueError.$factory("byte must be in range(0, 256)")}
 self.source[self.source.length]=b}
 bytearray.extend=function(self,b){if(b.__class__===bytearray ||b.__class__===bytes){b.source.forEach(function(item){self.source.push(item)})
 return _b_.None}
 var it=_b_.iter(b)
 while(true){try{bytearray.__add__(self,_b_.next(it))}catch(err){if(err===_b_.StopIteration){break}
 throw err}}
 return _b_.None}
 bytearray.insert=function(self,pos,b){if(arguments.length !=3){throw _b_.TypeError.$factory(
 "insert takes exactly 2 arguments ("+(arguments.length-1)+
 " given)")}
 if(! _b_.isinstance(b,_b_.int)){throw _b_.TypeError.$factory("an integer is required")}
 if(b > 255){throw ValueError.$factory("byte must be in range(0, 256)")}
 _b_.list.insert(self.source,pos,b)}
 bytearray.$factory=function(){var args=[bytearray]
 for(var i=0,len=arguments.length;i < len;i++){args.push(arguments[i])}
 return bytearray.__new__.apply(null,args)}
 var bytes={__class__ :_b_.type,__mro__:[_b_.object],$buffer_protocol:true,$infos:{__module__:"builtins",__name__:"bytes"},$is_class:true}
 bytes.__add__=function(self,other){if(_b_.isinstance(other,bytes)){return self.__class__.$factory(self.source.concat(other.source))}else if(_b_.isinstance(other,bytearray)){return self.__class__.$factory(bytes.__add__(self,bytes.$factory(other)))}else if(_b_.isinstance(other,_b_.memoryview)){return self.__class__.$factory(bytes.__add__(self,_b_.memoryview.tobytes(other)))}
 throw _b_.TypeError.$factory("can't concat bytes to "+
 _b_.str.$factory(other))}
 bytes.__contains__=function(self,other){if(typeof other=="number"){return self.source.indexOf(other)>-1}
 if(self.source.length < other.source.length){return false}
 var len=other.source.length
 for(var i=0;i < self.source.length-other.source.length+1;i++){var flag=true
 for(var j=0;j < len;j++){if(other.source[i+j]!=self.source[j]){flag=false
 break}}
 if(flag){return true}}
 return false}
 var bytes_iterator=$B.make_iterator_class("bytes_iterator")
 bytes.__iter__=function(self){return bytes_iterator.$factory(self.source)}
 bytes.__eq__=function(self,other){if(invalid(other)){return false}
 return $B.$getattr(self.source,'__eq__')(other.source)}
 bytes.__ge__=function(self,other){if(invalid(other)){return _b_.NotImplemented}
 return _b_.list.__ge__(self.source,other.source)}
 bytes.__getitem__=function(self,arg){var i
 if(_b_.isinstance(arg,_b_.int)){var pos=arg
 if(arg < 0){pos=self.source.length+pos}
 if(pos >=0 && pos < self.source.length){return self.source[pos]}
 throw _b_.IndexError.$factory("index out of range")}else if(_b_.isinstance(arg,_b_.slice)){var s=_b_.slice.$conv_for_seq(arg,self.source.length),start=s.start,stop=s.stop,step=s.step
 var res=[],i=null,pos=0
 if(step > 0){stop=Math.min(stop,self.source.length)
 if(stop <=start){return bytes.$factory([])}
 for(var i=start;i < stop;i+=step){res[pos++]=self.source[i]}}else{if(stop >=start){return bytes.$factory([])}
 stop=Math.max(0,stop)
 for(var i=start;i >=stop;i+=step){res[pos++]=self.source[i]}}
 return bytes.$factory(res)}else if(_b_.isinstance(arg,_b_.bool)){return self.source.__getitem__(_b_.int.$factory(arg))}}
 bytes.__gt__=function(self,other){if(invalid(other)){return _b_.NotImplemented}
 return _b_.list.__gt__(self.source,other.source)}
 bytes.__hash__=function(self){if(self===undefined){return bytes.__hashvalue__ ||$B.$py_next_hash--}
 var hash=1
 for(var i=0,len=self.source.length;i < len;i++){hash=(101*hash+self.source[i])& 0xFFFFFFFF}
 return hash}
 bytes.__init__=function(){return _b_.None}
 bytes.__le__=function(self,other){if(invalid(other)){return _b_.NotImplemented}
 return _b_.list.__le__(self.source,other.source)}
 bytes.__len__=function(self){return self.source.length}
 bytes.__lt__=function(self,other){if(invalid(other)){return _b_.NotImplemented}
 return _b_.list.__lt__(self.source,other.source)}
 bytes.__mod__=function(self,args){
 var s=decode(self,"ascii","strict"),res=_b_.str.__mod__(s,args)
 return _b_.str.encode(res,"ascii")}
 bytes.__mul__=function(){var $=$B.args('__mul__',2,{self:null,other:null},['self','other'],arguments,{},null,null),other=$B.PyNumber_Index($.other)
 var t=[],source=$.self.source,slen=source.length
 for(var i=0;i < other;i++){for(var j=0;j < slen;j++){t.push(source[j])}}
 var res=bytes.$factory()
 res.source=t
 return res}
 bytes.__ne__=function(self,other){return ! bytes.__eq__(self,other)}
 bytes.__new__=function(cls,source,encoding,errors){var $=$B.args("__new__",4,{cls:null,source:null,encoding:null,errors:null},["cls","source","encoding","errors"],arguments,{source:[],encoding:"utf-8",errors:"strict"},null,null)
 return bytes.$new($.cls,$.source,$.encoding,$.errors)}
 bytes.$new=function(cls,source,encoding,errors){
 var self={__class__:cls},int_list=[],pos=0
 if(source===undefined){}else if(typeof source=="number" ||_b_.isinstance(source,_b_.int)){var i=source
 while(i--){int_list[pos++]=0}}else{if(typeof source=="string" ||_b_.isinstance(source,_b_.str)){if(encoding===undefined){throw _b_.TypeError.$factory("string argument without an encoding")}
 int_list=encode(source,encoding ||"utf-8",errors ||"strict")}else{
 int_list=_b_.list.$factory(source)
 for(var i=0;i < int_list.length;i++){try{var item=_b_.int.$factory(int_list[i])}catch(err){throw _b_.TypeError.$factory("'"+
 $B.class_name(int_list[i])+"' object "+
 "cannot be interpreted as an integer")}
 if(item < 0 ||item > 255){throw _b_.ValueError.$factory("bytes must be in range"+
 "(0, 256)")}}}}
 self.source=int_list
 self.encoding=encoding
 self.errors=errors
 return self}
 bytes.__repr__=bytes.__str__=function(self){var res=""
 for(var i=0,len=self.source.length;i < len;i++){var s=self.source[i]
 if(s==10){res+='\\n'}else if(s < 32 ||s >=128){var hx=s.toString(16)
 hx=(hx.length==1 ? '0' :'')+hx
 res+='\\x'+hx}else if(s=="\\".charCodeAt(0)){res+="\\\\"}else{res+=String.fromCharCode(s)}}
 if(res.indexOf("'")>-1 && res.indexOf('"')==-1){return 'b"'+res+'"'}else{return "b'"+res.replace(new RegExp("'","g"),"\\'")+"'"}}
 bytes.__reduce_ex__=function(self){return bytes.__repr__(self)}
 bytes.capitalize=function(self){var src=self.source,len=src.length,buffer=src.slice()
 if(buffer[0]> 96 && buffer[0]< 123){buffer[0]-=32}
 for(var i=1;i < len;++i){if(buffer[i]> 64 && buffer[i]< 91){buffer[i]+=32}}
 return bytes.$factory(buffer)}
 bytes.center=function(){var $=$B.args('center',3,{self:null,width:null,fillbyte:null},['self','width','fillbyte'],arguments,{fillbyte:bytes.$factory([32])},null,null)
 var diff=$.width-$.self.source.length
 if(diff <=0){return bytes.$factory($.self.source)}
 var ljust=bytes.ljust($.self,$.self.source.length+Math.floor(diff/2),$.fillbyte)
 return bytes.rjust(ljust,$.width,$.fillbyte)}
 bytes.count=function(){var $=$B.args('count',4,{self:null,sub:null,start:null,end:null},['self','sub','start','end'],arguments,{start:0,end:-1},null,null)
 var n=0,index=-1,len=0
 if(typeof $.sub=="number"){if($.sub < 0 ||$.sub > 255)
 throw _b_.ValueError.$factory("byte must be in range(0, 256)")
 len=1}else if(!$.sub.__class__){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name($.sub)+"'")}else if(!$.sub.__class__.$buffer_protocol){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name($.sub)+"'")}else{len=$.sub.source.length}
 do{index=bytes.find($.self,$.sub,Math.max(index+len,$.start),$.end)
 if(index !=-1){n++}}while(index !=-1)
 return n}
 bytes.decode=function(self,encoding,errors){var $=$B.args("decode",3,{self:null,encoding:null,errors:null},["self","encoding","errors"],arguments,{encoding:"utf-8",errors:"strict"},null,null)
 switch($.errors){case 'strict':
 case 'ignore':
 case 'replace':
 case 'surrogateescape':
 case 'surrogatepass':
 case 'xmlcharrefreplace':
 case 'backslashreplace':
 return decode($.self,$.encoding,$.errors)
 default:}}
 bytes.endswith=function(){var $=$B.args('endswith',4,{self:null,suffix:null,start:null,end:null},['self','suffix','start','end'],arguments,{start:-1,end:-1},null,null)
 if(_b_.isinstance($.suffix,bytes)){var start=$.start==-1 ?
 $.self.source.length-$.suffix.source.length :
 Math.min($.self.source.length-$.suffix.source.length,$.start)
 var end=$.end==-1 ?
 ($.start==-1 ? $.self.source.length :start+$.suffix.source.length):
 Math.min($.self.source.length-1,$.end)
 var res=true
 for(var i=$.suffix.source.length-1,len=$.suffix.source.length;
 i >=0 && res;--i){res=$.self.source[end-len+i]==$.suffix.source[i]}
 return res}else if(_b_.isinstance($.suffix,_b_.tuple)){for(var i=0;i < $.suffix.length;++i){if(_b_.isinstance($.suffix[i],bytes)){if(bytes.endswith($.self,$.suffix[i],$.start,$.end)){return true}}else{throw _b_.TypeError.$factory("endswith first arg must be "+
 "bytes or a tuple of bytes, not "+
 $B.class_name($.suffix))}}
 return false}else{throw _b_.TypeError.$factory("endswith first arg must be bytes "+
 "or a tuple of bytes, not "+$B.class_name($.suffix))}}
 bytes.expandtabs=function(){var $=$B.args('expandtabs',2,{self:null,tabsize:null},['self','tabsize'],arguments,{tabsize:8},null,null)
 var tab_spaces=[]
 for(let i=0;i < $.tabsize;++i){tab_spaces.push(32)}
 var buffer=$.self.source.slice()
 for(let i=0;i < buffer.length;++i){if(buffer[i]===9){buffer.splice.apply(buffer,[i,1].concat(tab_spaces))}}
 return _b_.bytes.$factory(buffer)}
 bytes.find=function(self,sub){if(arguments.length !=2){var $=$B.args('find',4,{self:null,sub:null,start:null,end:null},['self','sub','start','end'],arguments,{start:0,end:-1},null,null),sub=$.sub,start=$.start,end=$.end}else{var start=0,end=-1}
 if(typeof sub=="number"){if(sub < 0 ||sub > 255){throw _b_.ValueError.$factory("byte must be in range(0, 256)")}
 return self.source.slice(0,end==-1 ? undefined :end).indexOf(sub,start)}else if(! sub.__class__){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name(sub)+"'")}else if(! sub.__class__.$buffer_protocol){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name(sub)+"'")}
 end=end==-1 ? self.source.length :Math.min(self.source.length,end)
 var len=sub.source.length
 for(var i=start;i <=end-len;i++){var chunk=self.source.slice(i,i+len),found=true
 for(var j=0;j < len;j++){if(chunk[j]!=sub.source[j]){found=false
 break}}
 if(found){return i}}
 return-1}
 bytes.fromhex=function(){var $=$B.args('fromhex',2,{cls:null,string:null},['cls','string'],arguments,{},null,null),string=$.string.replace(/\s/g,''),source=[]
 for(var i=0;i < string.length;i+=2){if(i+2 > string.length){throw _b_.ValueError.$factory("non-hexadecimal number found "+
 "in fromhex() arg")}
 source.push(_b_.int.$factory(string.substr(i,2),16))}
 return $.cls.$factory(source)}
 bytes.hex=function(){
 var $=$B.args('hex',1,{self:null},['self'],arguments,{},null,null),self=$.self,res=""
 for(var i=0,len=self.source.length;i < len;i++){var hexa=self.source[i].toString(16)
 if(hexa.length < 2){hexa="0"+hexa}
 res+=hexa}
 return res}
 bytes.index=function(){var $=$B.args('rfind',4,{self:null,sub:null,start:null,end:null},['self','sub','start','end'],arguments,{start:0,end:-1},null,null)
 var index=bytes.find($.self,$.sub,$.start,$.end)
 if(index==-1){throw _b_.ValueError.$factory("subsection not found")}
 return index}
 bytes.isalnum=function(self){var src=self.source,len=src.length,res=len > 0
 for(var i=0;i < len && res;++i){res=(src[i]> 96 && src[i]< 123)||
 (src[i]> 64 && src[i]< 91)||
 (src[i]> 47 && src[i]< 58)}
 return res}
 bytes.isalpha=function(self){var src=self.source,len=src.length,res=len > 0
 for(var i=0;i < len && res;++i){res=(src[i]> 96 && src[i]< 123)||(src[i]> 64 && src[i]< 91)}
 return res}
 bytes.isdigit=function(self){var src=self.source,len=src.length,res=len > 0
 for(let i=0;i < len && res;++i){res=src[i]> 47 && src[i]< 58}
 return res}
 bytes.islower=function(self){var src=self.source,len=src.length,res=false
 for(let i=0;i < len;++i){
 res=res ||(src[i]> 96 && src[i]< 123)
 if(src[i]> 64 && src[i]< 91){return false}}
 return res}
 bytes.isspace=function(self){var src=self.source,len=src.length
 for(let i=0;i < len;++i){switch(src[i]){case 9:
 case 10:
 case 11:
 case 12:
 case 13:
 case 32:
 break
 default:
 return false}}
 return true}
 bytes.isupper=function(self){var src=self.source,len=src.length,res=false
 for(let i=0;i < len;++i){
 res=res ||(src[i]> 64 && src[i]< 91)
 if(src[i]> 96 && src[i]< 123){return false}}
 return res}
 bytes.istitle=function(self){var src=self.source,len=src.length,current_char_is_letter=false,prev_char_was_letter=false,is_uppercase=false,is_lowercase=false
 for(var i=0;i < len;++i){is_lowercase=src[i]> 96 && src[i]< 123
 is_uppercase=src[i]> 64 && src[i]< 91
 current_char_is_letter=is_lowercase ||is_uppercase
 if(current_char_is_letter &&
 (prev_char_was_letter && is_uppercase)||
 (! prev_char_was_letter && is_lowercase)){return false}
 prev_char_was_letter=current_char_is_letter}
 return true}
 bytes.join=function(){var $ns=$B.args('join',2,{self:null,iterable:null},['self','iterable'],arguments,{}),self=$ns['self'],iterable=$ns['iterable']
 var next_func=$B.$getattr(_b_.iter(iterable),'__next__'),res=self.__class__.$factory(),empty=true
 while(true){try{var item=next_func()
 if(empty){empty=false}
 else{res=bytes.__add__(res,self)}
 res=bytes.__add__(res,item)}catch(err){if(_b_.isinstance(err,_b_.StopIteration)){break}
 throw err}}
 return res}
 var _lower=function(char_code){if(char_code >=65 && char_code <=90){return char_code+32}else{return char_code}}
 bytes.lower=function(self){var _res=[],pos=0
 for(var i=0,len=self.source.length;i < len;i++){if(self.source[i]){_res[pos++]=_lower(self.source[i])}}
 return bytes.$factory(_res)}
 bytes.ljust=function(){var $=$B.args('ljust',3,{self:null,width:null,fillbyte:null},['self','width','fillbyte'],arguments,{fillbyte:bytes.$factory([32])},null,null)
 if(!$.fillbyte.__class__){throw _b_.TypeError.$factory("argument 2 must be a byte string of length 1, "+
 "not '"+$B.class_name($.fillbyte)+"'")}else if(!$.fillbyte.__class__.$buffer_protocol){throw _b_.TypeError.$factory("argument 2 must be a byte string of length 1, "+
 "not '"+$B.class_name($.fillbyte)+"'")}
 var padding=[],count=$.width-$.self.source.length
 for(var i=0;i < count;++i){padding.push($.fillbyte.source[0])}
 return bytes.$factory($.self.source.concat(padding))}
 bytes.lstrip=function(self,cars){return _strip(self,cars,'l')}
 bytes.maketrans=function(from,to){var _t=[],to=$B.to_bytes(to)
 for(var i=0;i < 256;i++){_t[i]=i}
 for(var i=0,len=from.source.length;i < len;i++){var _ndx=from.source[i]
 _t[_ndx]=to[i]}
 return bytes.$factory(_t)}
 bytes.partition=function(){var $=$B.args('partition',2,{self:null,sep:null},['self','sep'],arguments,{},null,null)
 if(! $.sep.__class__){throw _b_.TypeError.$factory("a bytes-like object is required, "+
 "not '"+$B.class_name($.sep)+"'")}else if(! $.sep.__class__.$buffer_protocol){throw _b_.TypeError.$factory("a bytes-like object is required, "+
 "not '"+$B.class_name($.sep)+"'")}
 var len=$.sep.source.length,src=$.self.source,i=bytes.find($.self,$.sep)
 return _b_.tuple.$factory([bytes.$factory(src.slice(0,i)),bytes.$factory(src.slice(i,i+len)),bytes.$factory(src.slice(i+len))
 ])}
 bytes.removeprefix=function(){var $=$B.args("removeprefix",2,{self:null,prefix:null},["self","prefix"],arguments,{},null,null)
 if(!_b_.isinstance($.prefix,[bytes,bytearray])){throw _b_.ValueError.$factory("prefix should be bytes, not "+
 `'${$B.class_name($.prefix)}'`)}
 if(bytes.startswith($.self,$.prefix)){return bytes.__getitem__($.self,_b_.slice.$factory($.prefix.source.length,_b_.None))}
 return bytes.__getitem__($.self,_b_.slice.$factory(0,_b_.None))}
 bytes.removesuffix=function(){var $=$B.args("removesuffix",2,{self:null,prefix:null},["self","suffix"],arguments,{},null,null)
 if(!_b_.isinstance($.suffix,[bytes,bytearray])){throw _b_.ValueError.$factory("suffix should be bytes, not "+
 `'${$B.class_name($.suffix)}'`)}
 if(bytes.endswith($.self,$.suffix)){return bytes.__getitem__($.self,_b_.slice.$factory(0,$.suffix.source.length+1))}
 return bytes.__getitem__($.self,_b_.slice.$factory(0,_b_.None))}
 bytes.replace=function(){var $=$B.args('replace',4,{self:null,old:null,new:null,count:null},['self','old','new','count'],arguments,{count:-1},null,null),res=[]
 var self=$.self,src=self.source,len=src.length,old=$.old,$new=$.new
 var count=$.count >=0 ? $.count :src.length
 if(! $.old.__class__){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name($.old)+"'")}else if(! $.old.__class__.$buffer_protocol){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name($.sep)+"'")}
 if(! $.new.__class__){throw _b_.TypeError.$factory("second argument must be a bytes-like "+
 "object, not '"+$B.class_name($.old)+"'")}else if(! $.new.__class__.$buffer_protocol){throw _b_.TypeError.$factory("second argument must be a bytes-like "+
 "object, not '"+$B.class_name($.sep)+"'")}
 for(var i=0;i < len;i++){if(bytes.startswith(self,old,i)&& count){for(var j=0;j < $new.source.length;j++){res.push($new.source[j])}
 i+=(old.source.length-1)
 count--}else{res.push(src[i])}}
 return bytes.$factory(res)}
 bytes.rfind=function(self,subbytes){if(arguments.length==2 && subbytes.__class__===bytes){var sub=subbytes,start=0,end=-1}else{var $=$B.args('rfind',4,{self:null,sub:null,start:null,end:null},['self','sub','start','end'],arguments,{start:0,end:-1},null,null),self=$.self,sub=$.sub,start=$.start,end=$.end}
 if(typeof sub=="number"){if(sub < 0 ||sub > 255){throw _b_.ValueError.$factory("byte must be in range(0, 256)")}
 return $.self.source.slice(start,$.end==-1 ? undefined :$.end).
 lastIndexOf(sub)+start}else if(! sub.__class__){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name($.sub)+"'")}else if(! sub.__class__.$buffer_protocol){throw _b_.TypeError.$factory("first argument must be a bytes-like "+
 "object, not '"+$B.class_name(sub)+"'")}
 end=end==-1 ? self.source.length :Math.min(self.source.length,end)
 var len=sub.source.length
 for(var i=end-len;i >=start;--i){var chunk=self.source.slice(i,i+len),found=true
 for(var j=0;j < len;j++){if(chunk[j]!=sub.source[j]){found=false
 break}}
 if(found){return i}}
 return-1}
 bytes.rindex=function(){var $=$B.args('rfind',4,{self:null,sub:null,start:null,end:null},['self','sub','start','end'],arguments,{start:0,end:-1},null,null)
 var index=bytes.rfind($.self,$.sub,$.start,$.end)
 if(index==-1){throw _b_.ValueError.$factory("subsection not found")}
 return index}
 bytes.rjust=function(){var $=$B.args('rjust',3,{self:null,width:null,fillbyte:null},['self','width','fillbyte'],arguments,{fillbyte:bytes.$factory([32])},null,null)
 if(!$.fillbyte.__class__){throw _b_.TypeError.$factory("argument 2 must be a byte string of length 1, "+
 "not '"+$B.class_name($.fillbyte)+"'")}else if(!$.fillbyte.__class__.$buffer_protocol){throw _b_.TypeError.$factory("argument 2 must be a byte string of length 1, "+
 "not '"+$B.class_name($.fillbyte)+"'")}
 var padding=[],count=$.width-$.self.source.length
 for(var i=0;i < count;++i){padding.push($.fillbyte.source[0])}
 return bytes.$factory(padding.concat($.self.source))}
 bytes.rpartition=function(){var $=$B.args('rpartition',2,{self:null,sep:null},['self','sep'],arguments,{},null,null)
 if(!$.sep.__class__){throw _b_.TypeError.$factory("a bytes-like object is required, "+
 "not '"+$B.class_name($.sep)+"'")}else if(!$.sep.__class__.$buffer_protocol){throw _b_.TypeError.$factory("a bytes-like object is required, "+
 "not '"+$B.class_name($.sep)+"'")}
 var len=$.sep.source.length,src=$.self.source,i=bytes.rfind($.self,$.sep)
 return _b_.tuple.$factory([bytes.$factory(src.slice(0,i)),bytes.$factory(src.slice(i,i+len)),bytes.$factory(src.slice(i+len))
 ])}
 bytes.rstrip=function(self,cars){return _strip(self,cars,'r')}
 bytes.split=function(){var $=$B.args('split',2,{self:null,sep:null},['self','sep'],arguments,{},null,null),res=[],start=0,stop=0
 if(! $.sep.__class__ ){throw _b_.TypeError.$factory("a bytes-like object is required, "+
 "not '"+$B.class_name($.sep)+"'")}else if(! $.sep.__class__.$buffer_protocol){throw _b_.TypeError.$factory("a bytes-like object is required, "+
 "not '"+$B.class_name($.sep)+"'")}
 var seps=$.sep.source,len=seps.length,src=$.self.source,blen=src.length
 while(stop < blen){var match=true
 for(var i=0;i < len && match;i++){if(src[stop+i]!=seps[i]){match=false}}
 if(match){res.push(bytes.$factory(src.slice(start,stop)))
 start=stop+len
 stop=start}else{stop++}}
 if(match ||(stop > start)){res.push(bytes.$factory(src.slice(start,stop)))}
 return res}
 bytes.splitlines=function(self){var $=$B.args('splitlines',2,{self:null,keepends:null},['self','keepends'],arguments,{keepends:false},null,null)
 if(!_b_.isinstance($.keepends,[_b_.bool,_b_.int])){throw _b_.TypeError('integer argument expected, got '+
 $B.get_class($.keepends).__name)}
 var keepends=_b_.int.$factory($.keepends),res=[],source=$.self.source,start=0,pos=0
 if(! source.length){return res}
 while(pos < source.length){if(pos < source.length-1 && source[pos]==0x0d &&
 source[pos+1]==0x0a){res.push(bytes.$factory(source.slice(start,keepends ? pos+2 :pos)))
 start=pos=pos+2}else if(source[pos]==0x0d ||source[pos]==0x0a){res.push(bytes.$factory(source.slice(start,keepends ? pos+1 :pos)))
 start=pos=pos+1}else{pos++}}
 if(start < source.length){res.push(bytes.$factory(source.slice(start)))}
 return res}
 bytes.startswith=function(){var $=$B.args('startswith',3,{self:null,prefix:null,start:null},['self','prefix','start'],arguments,{start:0},null,null),start=$.start
 if(_b_.isinstance($.prefix,bytes)){var res=true
 for(var i=0;i < $.prefix.source.length && res;i++){res=$.self.source[start+i]==$.prefix.source[i]}
 return res}else if(_b_.isinstance($.prefix,_b_.tuple)){var items=[]
 for(var i=0;i < $.prefix.length;i++){if(_b_.isinstance($.prefix[i],bytes)){items=items.concat($.prefix[i].source)}else{throw _b_.TypeError.$factory("startswith first arg must be "+
 "bytes or a tuple of bytes, not "+
 $B.class_name($.prefix))}}
 var prefix=bytes.$factory(items)
 return bytes.startswith($.self,prefix,start)}else{throw _b_.TypeError.$factory("startswith first arg must be bytes "+
 "or a tuple of bytes, not "+$B.class_name($.prefix))}}
 bytes.strip=function(self,cars){var res=bytes.lstrip(self,cars)
 return bytes.rstrip(res,cars)}
 bytes.swapcase=function(self){var src=self.source,len=src.length,buffer=src.slice()
 for(var i=0;i < len;++i){if(buffer[i]> 96 && buffer[i]< 123){buffer[i]-=32}else if(buffer[i]> 64 && buffer[i]< 91){buffer[i]+=32}}
 return bytes.$factory(buffer)}
 bytes.title=function(self){var src=self.source,len=src.length
 buffer=src.slice(),current_char_is_letter=false,prev_char_was_letter=false,is_uppercase=false,is_lowercase=false
 for(var i=0;i < len;++i){is_lowercase=buffer[i]> 96 && buffer[i]< 123
 is_uppercase=buffer[i]> 64 && buffer[i]< 91
 current_char_is_letter=is_lowercase ||is_uppercase
 if(current_char_is_letter){if(prev_char_was_letter && is_uppercase){buffer[i]+=32}else if(! prev_char_was_letter && is_lowercase){buffer[i]-=32}}
 prev_char_was_letter=current_char_is_letter}
 return bytes.$factory(buffer)}
 bytes.translate=function(self,table,_delete){if(_delete===undefined){_delete=[]}else if(_b_.isinstance(_delete,bytes)){_delete=_delete.source}else{throw _b_.TypeError.$factory("Type "+
 $B.get_class(_delete).__name+" doesn't support the buffer API")}
 var res=[],pos=0
 if(_b_.isinstance(table,bytes)&& table.source.length==256){for(var i=0,len=self.source.length;i < len;i++){if(_delete.indexOf(self.source[i])>-1){continue}
 res[pos++]=table.source[self.source[i]]}}
 return bytes.$factory(res)}
 var _upper=function(char_code){if(char_code >=97 && char_code <=122){return char_code-32}else{return char_code}}
 bytes.upper=function(self){var _res=[],pos=0
 for(var i=0,len=self.source.length;i < len;i++){if(self.source[i]){_res[pos++]=_upper(self.source[i])}}
 return bytes.$factory(_res)}
 bytes.zfill=function(self,width){var buffer=self.source.slice(),prefix_offset=(buffer[0]==43 ||buffer[0]==45)? 1 :0
 var count=width-self.source.length
 var padding=[]
 for(var i=0;i < count;++i){padding.push(48)}
 buffer.splice.apply(buffer,[prefix_offset,0].concat(padding))
 return bytes.$factory(buffer)}
 function $UnicodeEncodeError(encoding,code_point,position){throw _b_.UnicodeEncodeError.$factory("'"+encoding+
 "' codec can't encode character "+_b_.hex(code_point)+
 " in position "+position)}
 function $UnicodeDecodeError(encoding,position){throw _b_.UnicodeDecodeError.$factory("'"+encoding+
 "' codec can't decode bytes in position "+position)}
 function _hex(_int){return _int.toString(16)}
 function _int(hex){return parseInt(hex,16)}
 function normalise(encoding){var enc=encoding.toLowerCase()
 if(enc.substr(0,7)=="windows"){enc="cp"+enc.substr(7)}
 if(enc.startsWith("cp")||enc.startsWith("iso")){enc=enc.replace("-","")}
 enc=enc.replace(/-/g,"_")
 return enc}
 function load_decoder(enc){
 if(to_unicode[enc]===undefined){var mod=_b_.__import__("encodings."+enc)
 if(mod[enc].getregentry){to_unicode[enc]=$B.$getattr(mod[enc].getregentry(),"decode")}}}
 function load_encoder(enc){
 if(from_unicode[enc]===undefined){var mod=_b_.__import__("encodings."+enc)
 if(mod[enc].getregentry){from_unicode[enc]=$B.$getattr(mod[enc].getregentry(),"encode")}}}
 var decode=$B.decode=function(obj,encoding,errors){var s="",b=obj.source,enc=normalise(encoding),has_surrogate=false
 switch(enc){case "utf_8":
 case "utf-8":
 case "utf8":
 case "U8":
 case "UTF":
 var pos=0,s="",err_info
 while(pos < b.length){var byte=b[pos]
 err_info=null
 if(!(byte & 0x80)){
 s+=String.fromCodePoint(byte)
 pos++}else if((byte >> 5)==6){
 if(b[pos+1]===undefined){err_info=[byte,pos,"end"]}else if((b[pos+1]& 0xc0)!=0x80){err_info=[byte,pos,"continuation"]}
 if(err_info !==null){if(errors=="ignore"){pos++}else{throw _b_.UnicodeDecodeError.$factory(
 "'utf-8' codec can't decode byte 0x"+
 err_info[0].toString(16)+"  in position "+
 err_info[1]+
 (err_info[2]=="end" ? ": unexpected end of data" :
 ": invalid continuation byte"))}}else{var cp=byte & 0x1f
 cp <<=6
 cp+=b[pos+1]& 0x3f
 s+=String.fromCodePoint(cp)
 pos+=2}}else if((byte >> 4)==14){
 if(b[pos+1]===undefined){err_info=[byte,pos,"end",pos+1]}else if((b[pos+1]& 0xc0)!=0x80){err_info=[byte,pos,"continuation",pos+2]}else if(b[pos+2]===undefined){err_info=[byte,pos+'-'+(pos+1),"end",pos+2]}else if((b[pos+2]& 0xc0)!=0x80){err_info=[byte,pos,"continuation",pos+3]}
 if(err_info !==null){if(errors=="ignore"){pos=err_info[3]}else if(errors=="surrogateescape"){for(var i=pos;i < err_info[3];i++){s+=String.fromCodePoint(0xdc80+b[i]-0x80)}
 pos=err_info[3]}else{throw _b_.UnicodeDecodeError.$factory(
 "'utf-8' codec can't decode byte 0x"+
 err_info[0].toString(16)+"  in position "+
 err_info[1]+
 (err_info[2]=="end" ? ": unexpected end of data" :
 ": invalid continuation byte"))}}else{var cp=byte & 0xf
 cp=cp << 12
 cp+=(b[pos+1]& 0x3f)<< 6
 cp+=b[pos+2]& 0x3f
 s+=String.fromCodePoint(cp)
 pos+=3}}else if((byte >> 3)==30){
 has_surrogate=true
 if(b[pos+1]===undefined){err_info=[byte,pos,"end",pos+1]}else if((b[pos+1]& 0xc0)!=0x80){err_info=[byte,pos,"continuation",pos+2]}else if(b[pos+2]===undefined){err_info=[byte,pos+'-'+(pos+1),"end",pos+2]}else if((b[pos+2]& 0xc0)!=0x80){err_info=[byte,pos,"continuation",pos+3]}else if(b[pos+3]===undefined){err_info=[byte,pos+'-'+(pos+1)+'-'+(pos+2),"end",pos+3]}else if((b[pos+2]& 0xc0)!=0x80){err_info=[byte,pos,"continuation",pos+3]}
 if(err_info !==null){if(errors=="ignore"){pos=err_info[3]}else if(errors=="surrogateescape"){for(var i=pos;i < err_info[3];i++){s+=String.fromCodePoint(0xdc80+b[i]-0x80)}
 pos=err_info[3]}else{throw _b_.UnicodeDecodeError.$factory(
 "'utf-8' codec can't decode byte 0x"+
 err_info[0].toString(16)+"  in position "+
 err_info[1]+
 (err_info[2]=="end" ? ": unexpected end of data" :
 ": invalid continuation byte"))}}else{var cp=byte & 0xf
 cp=cp << 18
 cp+=(b[pos+1]& 0x3f)<< 12
 cp+=(b[pos+2]& 0x3f)<< 6
 cp+=(b[pos+3]& 0x3f)
 s+=String.fromCodePoint(cp)
 pos+=4}}else{if(errors=="ignore"){pos++}else if(errors=="surrogateescape"){s+=String.fromCodePoint(0xdc80+b[pos]-0x80)
 pos++}else{throw _b_.UnicodeDecodeError.$factory(
 "'utf-8' codec can't decode byte 0x"+
 byte.toString(16)+" in position "+pos+
 ": invalid start byte")}}}
 if(has_surrogate){return _b_.str.$surrogate.$factory(s)}
 return s
 case "latin_1":
 case "windows1252":
 case "iso-8859-1":
 case "iso8859-1":
 case "8859":
 case "cp819":
 case "latin":
 case "latin1":
 case "L1":
 b.forEach(function(item){s+=String.fromCharCode(item)})
 break
 case "unicode_escape":
 if(obj.__class__===bytes ||obj.__class__===bytearray){obj=decode(obj,"latin-1","strict")}
 return obj.replace(/\\n/g,"\n").
 replace(/\\a/g,"\u0007").
 replace(/\\b/g,"\b").
 replace(/\\f/g,"\f").
 replace(/\\t/g,"\t").
 replace(/\\'/g,"'").
 replace(/\\"/g,'"')
 case "raw_unicode_escape":
 if(obj.__class__===bytes ||obj.__class__===bytearray){obj=decode(obj,"latin-1","strict")}
 return obj.replace(/\\u([a-fA-F0-9]{4})/g,function(mo){var cp=parseInt(mo.substr(2),16)
 return String.fromCharCode(cp)})
 case "ascii":
 for(var i=0,len=b.length;i < len;i++){var cp=b[i]
 if(cp <=127){s+=String.fromCharCode(cp)}else{if(errors=="ignore"){}else{var msg="'ascii' codec can't decode byte 0x"+
 cp.toString(16)+" in position "+i+
 ": ordinal not in range(128)"
 throw _b_.UnicodeDecodeError.$factory(msg)}}}
 break
 default:
 try{load_decoder(enc)}catch(err){console.log(b,encoding,"error load_decoder",err)
 throw _b_.LookupError.$factory("unknown encoding: "+enc)}
 return to_unicode[enc](obj)[0]}
 return s}
 var encode=$B.encode=function(){var $=$B.args("encode",3,{s:null,encoding:null,errors:null},["s","encoding","errors"],arguments,{encoding:"utf-8",errors:"strict"},null,null),s=$.s,encoding=$.encoding,errors=$.errors
 var t=[],pos=0,enc=normalise(encoding)
 switch(enc){case "utf-8":
 case "utf_8":
 case "utf8":
 var res=[]
 for(var i=0,len=s.length;i < len;i++){var cp=s.charCodeAt(i)
 if(cp < 0x7f){res.push(cp)}else if(cp < 0x7ff){res.push(0xc0+(cp >> 6),0x80+(cp & 0x3f))}else if(cp < 0xffff){res.push(0xe0+(cp >> 12),0x80+((cp & 0xfff)>> 6),0x80+(cp & 0x3f))}else{console.log("4 bytes")}}
 return res
 case "latin":
 case "latin1":
 case "latin-1":
 case "latin_1":
 case "L1":
 case "iso8859_1":
 case "iso_8859_1":
 case "8859":
 case "cp819":
 case "windows1252":
 for(var i=0,len=s.length;i < len;i++){var cp=s.charCodeAt(i)
 if(cp <=255){t[pos++]=cp}
 else if(errors !="ignore"){$UnicodeEncodeError(encoding,i)}}
 break
 case "ascii":
 for(var i=0,len=s.length;i < len;i++){var cp=s.charCodeAt(i)
 if(cp <=127){t[pos++]=cp}
 else if(errors !="ignore"){$UnicodeEncodeError(encoding,i)}}
 break
 case "raw_unicode_escape":
 for(var i=0,len=s.length;i < len;i++){var cp=s.charCodeAt(i)
 if(cp < 256){t[pos++]=cp}else{var us=cp.toString(16)
 if(us.length % 2){us="0"+us}
 us="\\u"+us
 for(var j=0;j < us.length;j++){t[pos++]=us.charCodeAt(j)}}}
 break
 default:
 try{load_encoder(enc)}catch(err){throw _b_.LookupError.$factory("unknown encoding: "+encoding)}
 t=from_unicode[enc](s)[0].source}
 return t}
 bytes.$factory=function(source,encoding,errors){var $=$B.args("bytes",3,{source:null,encoding:null,errors:null},["source","encoding","errors"],arguments,{source:[],encoding:"utf-8",errors:"strict"},null,null)
 return bytes.$new(bytes,$.source,$.encoding,$.errors)}
 bytes.__class__=_b_.type
 bytes.$is_class=true
 for(var attr in bytes){if(bytearray[attr]===undefined && typeof bytes[attr]=="function"){bytearray[attr]=(function(_attr){return function(){return bytes[_attr].apply(null,arguments)}})(attr)}}
 $B.set_func_names(bytes,"builtins")
 bytes.fromhex=_b_.classmethod.$factory(bytes.fromhex)
 $B.set_func_names(bytearray,"builtins")
 bytearray.fromhex=_b_.classmethod.$factory(bytearray.fromhex)
 _b_.bytes=bytes
 _b_.bytearray=bytearray})(__BRYTHON__)
 ;
 ;(function($B){var _b_=$B.builtins,object=_b_.object,$N=_b_.None
 function create_type(obj){return $B.get_class(obj).$factory()}
 function clone(obj){var res=create_type(obj)
 res.$items=obj.$items.slice()
 for(key in obj.$hashes){res.$hashes[key]=obj.$hashes[key]}
 return res}
 var set={__class__:_b_.type,$infos:{__module__:"builtins",__name__:"set"},$is_class:true,$native:true}
 set.__add__=function(self,other){throw _b_.TypeError.$factory(
 "unsupported operand type(s) for +: 'set' and "+typeof other)}
 set.__and__=function(self,other,accept_iter){try{$test(accept_iter,other)}
 catch(err){return _b_.NotImplemented}
 var res=create_type(self)
 for(var i=0,len=self.$items.length;i < len;i++){if(_b_.getattr(other,"__contains__")(self.$items[i])){set.add(res,self.$items[i])}}
 return res}
 set.__class_getitem__=function(cls,item){
 if(! Array.isArray(item)){item=[item]}
 return $B.GenericAlias.$factory(cls,item)}
 set.__contains__=function(self,item){if(self.$simple){if(typeof item=="number" ||item instanceof Number){if(isNaN(item)){
 for(var i=self.$items.length-1;i >=0;i--){if(isNaN(self.$items[i])){return true}}
 return false}else if(item instanceof Number){return self.$numbers.indexOf(item.valueOf())>-1}else{return self.$items.indexOf(item)>-1}}else if(typeof item=="string"){return self.$items.indexOf(item)>-1}}
 if(! _b_.isinstance(item,set)){$B.$getattr(item,"__hash__")}
 var hash=_b_.hash(item)
 if(self.$hashes[hash]){for(var i=0,len=self.$hashes[hash].length;i < len;i++){if($B.rich_comp("__eq__",self.$hashes[hash][i],item)){return true}}}
 return false}
 set.__eq__=function(self,other){
 if(other===undefined){return self===set}
 if(_b_.isinstance(other,[_b_.set,_b_.frozenset])){if(other.$items.length==self.$items.length){for(var i=0,len=self.$items.length;i < len;i++){if(set.__contains__(self,other.$items[i])===false){return false}}
 return true}
 return false}
 return _b_.NotImplemented}
 set.__format__=function(self,format_string){return set.__str__(self)}
 set.__ge__=function(self,other){if(_b_.isinstance(other,[set,frozenset])){return set.__le__(other,self)}
 return _b_.NotImplemented}
 set.__gt__=function(self,other){if(_b_.isinstance(other,[set,frozenset])){return set.__lt__(other,self)}
 return _b_.NotImplemented}
 set.__hash__=_b_.None
 set.__init__=function(self,iterable,second){if(second===undefined){if(Array.isArray(iterable)){for(var i=0,len=iterable.length;i < len;i++){$add(self,iterable[i])}
 return $N}}
 var $=$B.args("__init__",2,{self:null,iterable:null},["self","iterable"],arguments,{iterable:[]},null,null),self=$.self,iterable=$.iterable
 if(_b_.isinstance(iterable,[set,frozenset])){self.$items=iterable.$items.slice()
 self.$hashes={}
 for(var key in iterable.$hashes){self.$hashes[key]=iterable.$hashes[key]}
 return $N}
 var it=$B.$iter(iterable)
 while(1){try{var item=_b_.next(it)
 $add(self,item)}catch(err){if(_b_.isinstance(err,_b_.StopIteration)){break}
 throw err}}
 return $N}
 var set_iterator=$B.make_iterator_class("set iterator")
 set.__iter__=function(self){self.$items.sort()
 return set_iterator.$factory(self.$items)}
 set.__le__=function(self,other){
 if(_b_.isinstance(other,[set,frozenset])){var cfunc=_b_.getattr(other,"__contains__")
 for(var i=0,len=self.$items.length;i < len;i++){if(! cfunc(self.$items[i])){return false}}
 return true}else{return _b_.NotImplemented}}
 set.__len__=function(self){return self.$items.length}
 set.__lt__=function(self,other){if(_b_.isinstance(other,[set,frozenset])){return set.__le__(self,other)&&
 set.__len__(self)< _b_.getattr(other,"__len__")()}else{return _b_.NotImplemented}}
 set.__mro__=[_b_.object]
 set.__new__=function(cls){if(cls===undefined){throw _b_.TypeError.$factory("set.__new__(): not enough arguments")}
 return{
 __class__:cls,$simple:true,$items:[],$numbers:[],
 $hashes:{}}}
 set.__or__=function(self,other,accept_iter){
 var res=clone(self),func=_b_.getattr($B.$iter(other),"__next__")
 while(1){try{set.add(res,func())}
 catch(err){if(_b_.isinstance(err,_b_.StopIteration)){break}
 throw err}}
 res.__class__=self.__class__
 return res}
 set.__rand__=function(self,other){
 return set.__and__(self,other)}
 set.__reduce__=function(self){return _b_.tuple.$factory([self.__class__,_b_.tuple.$factory([self.$items]),$N])}
 set.__reduce_ex__=function(self,protocol){return set.__reduce__(self)}
 set.__rsub__=function(self,other){
 return set.__sub__(self,other)}
 set.__rxor__=function(self,other){
 return set.__xor__(self,other)}
 set.__str__=set.__repr__=function(self){var klass_name=$B.class_name(self)
 if(self.$items.length===0){return klass_name+"()"}
 var head=klass_name+"({",tail="})"
 if(head=="set({"){head="{";tail="}"}
 var res=[]
 if($B.repr.enter(self)){return klass_name+"(...)"}
 self.$items.sort()
 for(var i=0,len=self.$items.length;i < len;i++){var r=_b_.repr(self.$items[i])
 if(r===self ||r===self.$items[i]){res.push("{...}")}
 else{res.push(r)}}
 res=res.join(", ")
 $B.repr.leave(self)
 return head+res+tail}
 set.__sub__=function(self,other,accept_iter){
 try{$test(accept_iter,other,"-")}
 catch(err){return _b_.NotImplemented}
 var res=create_type(self),cfunc=_b_.getattr(other,"__contains__"),items=[]
 for(var i=0,len=self.$items.length;i < len;i++){if(! cfunc(self.$items[i])){items.push(self.$items[i])}}
 set.__init__.call(null,res,items)
 return res}
 set.__xor__=function(self,other,accept_iter){
 try{$test(accept_iter,other,"^")}
 catch(err){return _b_.NotImplemented}
 var res=create_type(self),cfunc=_b_.getattr(other,"__contains__")
 for(var i=0,len=self.$items.length;i < len;i++){if(! cfunc(self.$items[i])){set.add(res,self.$items[i])}}
 for(var i=0,len=other.$items.length;i < len;i++){if(! set.__contains__(self,other.$items[i])){set.add(res,other.$items[i])}}
 return res}
 function $test(accept_iter,other,op){if(accept_iter===undefined &&
 ! _b_.isinstance(other,[set,frozenset])){throw _b_.TypeError.$factory("unsupported operand type(s) for "+op+
 ": 'set' and '"+$B.class_name(other)+"'")}}
 $B.make_rmethods(set)
 function $add(self,item){var $simple=false
 if(typeof item==="string" ||typeof item==="number" ||
 item instanceof Number){$simple=true}
 if($simple){var ix=self.$items.indexOf(item)
 if(ix==-1){if(item instanceof Number &&
 self.$numbers.indexOf(item.valueOf())>-1){}else if(typeof item=="number" &&
 self.$numbers.indexOf(item)>-1){}else{self.$items.push(item)
 var value=item.valueOf()
 if(typeof value=="number"){self.$numbers.push(value)}}}else{
 if(item !==self.$items[ix]){self.$items.push(item)}}}else{
 var hashvalue=_b_.hash(item)
 var items=self.$hashes[hashvalue]
 if(items===undefined){self.$hashes[hashvalue]=[item]
 self.$items.push(item)}else{var items=self.$hashes[hashvalue],cfunc=function(other){return $B.rich_comp("__eq__",item,other)}
 for(var i=0,len=items.length;i < len;i++){if(cfunc(items[i])){
 return $N}}
 self.$hashes[hashvalue].push(item)
 self.$items.push(item)}}
 return $N}
 set.add=function(){var $=$B.args("add",2,{self:null,item:null},["self","item"],arguments,{},null,null),self=$.self,item=$.item
 return $add(self,item)}
 set.clear=function(){var $=$B.args("clear",1,{self:null},["self"],arguments,{},null,null)
 $.self.$items=[]
 $.self.$hashes={}
 return $N}
 set.copy=function(){var $=$B.args("copy",1,{self:null},["self"],arguments,{},null,null)
 if(_b_.isinstance($.self,frozenset)){return $.self}
 var res=set.$factory()
 $.self.$items.forEach(function(item){res.$items.push(item)})
 $.self.$numbers.forEach(function(item){res.$numbers.push(item)})
 for(key in self.$hashes){res.$hashes[key]=self.$hashes[key]}
 return res}
 set.difference_update=function(self){var $=$B.args("difference_update",1,{self:null},["self"],arguments,{},"args",null)
 for(var i=0;i < $.args.length;i++){var s=set.$factory($.args[i]),_next=_b_.getattr($B.$iter(s),"__next__"),item
 while(true){try{item=_next()
 var _type=typeof item
 if(_type=="string" ||_type=="number"){var _index=self.$items.indexOf(item)
 if(_index >-1){self.$items.splice(_index,1)}}else{for(var j=0;j < self.$items.length;j++){if($B.rich_comp("__eq__",self.$items[j],item)){self.$items.splice(j,1)
 var hash=_b_.hash(item)
 if(self.$hashes[hash]){for(var k=0;k < self.$hashes[hash].length;k++){if($B.rich_comp("__eq__",self.$hashes[hash][k],item)){self.$hashes[hash].splice(k,1)
 break}}}}}}}catch(err){if(_b_.isinstance(err,_b_.StopIteration)){break}
 throw err}}}
 return $N}
 set.discard=function(){var $=$B.args("discard",2,{self:null,item:null},["self","item"],arguments,{},null,null)
 try{set.remove($.self,$.item)}
 catch(err){if(!_b_.isinstance(err,[_b_.KeyError,_b_.LookupError])){throw err}}
 return $N}
 set.intersection_update=function(){
 var $=$B.args("intersection_update",1,{self:null},["self"],arguments,{},"args",null),self=$.self
 for(var i=0;i < $.args.length;i++){var remove=[],s=set.$factory($.args[i])
 for(var j=0;j < self.$items.length;j++){var _item=self.$items[j],_type=typeof _item
 if(_type=="string" ||_type=="number"){if(s.$items.indexOf(_item)==-1){remove.push(j)}}else{var found=false,hash=_b_.hash(_item)
 if(s.$hashes[hash]){var hashes=s.$hashes[hash]
 for(var k=0;! found && k < hashes.length;k++){if($B.rich_comp("__eq__",hashes[k],_item)){found=true}}
 if(! found){remove.push(j)
 hashes=self.$hashes[hash]
 for(var k=0;! found && k < hashes.length;k++){if($B.rich_comp("__eq__",hashes[k],_item)){self.$hashes.splice(k,1)}}}}}}
 remove.sort(function(x,y){return x-y}).reverse()
 for(var j=0;j < remove.length;j++){self.$items.splice(remove[j],1)}}
 return $N}
 set.isdisjoint=function(){var $=$B.args("is_disjoint",2,{self:null,other:null},["self","other"],arguments,{},null,null)
 for(var i=0,len=$.self.$items.length;i < len;i++){if(_b_.getattr($.other,"__contains__")($.self.$items[i])){return false}}
 return true}
 set.pop=function(self){if(self.$items.length===0){throw _b_.KeyError.$factory('pop from an empty set')}
 var item=self.$items.pop()
 if(typeof item !="string" && typeof item !="number"){
 var hash=_b_.hash(item),items=self.$hashes[hash]
 for(var k=0;k < items.length;k++){if($B.rich_comp("__eq__",items[k],item)){self.$hashes[hash].splice(k,1)
 break}}}
 return item}
 set.remove=function(self,item){
 var $=$B.args("remove",2,{self:null,item:null},["self","item"],arguments,{},null,null),self=$.self,item=$.item
 if(! _b_.isinstance(item,set)){_b_.hash(item)}
 if(typeof item=="string" ||typeof item=="number"){var _i=self.$items.indexOf(item)
 if(_i==-1){throw _b_.KeyError.$factory(item)}
 self.$items.splice(_i,1)
 if(typeof item=="number"){self.$numbers.splice(self.$numbers.indexOf(item),1)}
 return $N}
 var hash=_b_.hash(item)
 if(self.$hashes[hash]){
 for(var i=0,len=self.$items.length;i < len;i++){if($B.rich_comp("__eq__",self.$items[i],item)){self.$items.splice(i,1)
 if(item instanceof Number){self.$numbers.splice(self.$numbers.indexOf(item.valueOf()),1)}
 break}}
 for(var i=0,len=self.$hashes[hash].length;i < len;i++){if($B.rich_comp("__eq__",self.$hashes[hash][i],item)){self.$hashes[hash].splice(i,1)
 break}}
 return $N}
 throw _b_.KeyError.$factory(item)}
 set.symmetric_difference_update=function(self,s){
 var $=$B.args("symmetric_difference_update",2,{self:null,s:null},["self","s"],arguments,{},null,null),self=$.self,s=$.s
 var _next=_b_.getattr($B.$iter(s),"__next__"),item,remove=[],add=[]
 while(true){try{item=_next()
 var _type=typeof item
 if(_type=="string" ||_type=="number"){var _index=self.$items.indexOf(item)
 if(_index >-1){remove.push(_index)}else{add.push(item)}}else{var found=false
 for(var j=0;! found && j < self.$items.length;j++){if($B.rich_comp("__eq__",self.$items[j],item)){remove.push(j)
 found=true}}
 if(! found){add.push(item)}}}catch(err){if(_b_.isinstance(err,_b_.StopIteration)){break}
 throw err}}
 remove.sort(function(x,y){return x-y}).reverse()
 for(var i=0;i < remove.length;i++){if(remove[i]!=remove[i-1]){self.$items.splice(remove[i],1)}}
 for(var i=0;i < add.length;i++){set.add(self,add[i])}
 return $N}
 set.update=function(self){
 var $=$B.args("update",1,{self:null},["self"],arguments,{},"args",null)
 for(var i=0;i < $.args.length;i++){var other=set.$factory($.args[i])
 for(var j=0,_len=other.$items.length;j < _len;j++){$add(self,other.$items[j])}}
 return $N}
 set.difference=function(){var $=$B.args("difference",1,{self:null},["self"],arguments,{},"args",null)
 if($.args.length==0){return set.copy($.self)}
 var res=clone($.self)
 for(var i=0;i < $.args.length;i++){res=set.__sub__(res,set.$factory($.args[i]),true)}
 return res}
 var fc=set.difference+"" 
 eval("set.intersection = "+
 fc.replace(/difference/g,"intersection").replace("__sub__","__and__"))
 eval("set.symmetric_difference = "+
 fc.replace(/difference/g,"symmetric_difference").replace("__sub__","__xor__"))
 eval("set.union = "+
 fc.replace(/difference/g,"union").replace("__sub__","__or__"))
 set.issubset=function(){var $=$B.args("issubset",2,{self:null,other:null},["self","other"],arguments,{},"args",null),func=_b_.getattr($.other,"__contains__")
 for(var i=0,len=$.self.$items.length;i < len;i++){if(! func($.self.$items[i])){return false}}
 return true}
 set.issuperset=function(){var $=$B.args("issuperset",2,{self:null,other:null},["self","other"],arguments,{},"args",null)
 var func=_b_.getattr($.self,"__contains__"),it=$B.$iter($.other)
 while(true){try{var item=_b_.next(it)
 if(! func(item)){return false}}catch(err){if(_b_.isinstance(err,_b_.StopIteration)){return true}
 throw err}}
 return true}
 function $accept_only_set(f,op){return function(self,other,accept_iter){$test(accept_iter,other,op)
 f(self,other)
 return self}}
 set.__iand__=$accept_only_set(set.intersection_update,"&=")
 set.__isub__=$accept_only_set(set.difference_update,"-=")
 set.__ixor__=$accept_only_set(set.symmetric_difference_update,"^=")
 set.__ior__=$accept_only_set(set.update,"|=")
 set.$factory=function(){
 var res={__class__:set,$simple:true,$items:[],$numbers:[],$hashes:{}}
 var args=[res].concat(Array.prototype.slice.call(arguments))
 set.__init__.apply(null,args)
 return res}
 $B.set_func_names(set,"builtins")
 set.__class_getitem__=_b_.classmethod.$factory(set.__class_getitem__)
 var frozenset={__class__:_b_.type,__mro__:[object],$infos:{__module__:"builtins",__name__:"frozenset"},$is_class:true,$native:true}
 for(var attr in set){switch(attr){case "add":
 case "clear":
 case "discard":
 case "pop":
 case "remove":
 case "update":
 break
 default:
 if(frozenset[attr]==undefined){if(typeof set[attr]=="function"){frozenset[attr]=(function(x){return function(){return set[x].apply(null,arguments)}})(attr)}else{frozenset[attr]=set[attr]}}}}
 frozenset.__hash__=function(self){if(self===undefined){return frozenset.__hashvalue__ ||$B.$py_next_hash--}
 if(self.__hashvalue__ !==undefined){return self.__hashvalue__}
 var _hash=1927868237
 _hash*=self.$items.length
 for(var i=0,len=self.$items.length;i < len;i++){var _h=_b_.hash(self.$items[i])
 _hash ^=((_h ^ 89869747)^(_h << 16))*3644798167}
 _hash=_hash*69069+907133923
 if(_hash==-1){_hash=590923713}
 return self.__hashvalue__=_hash}
 frozenset.__init__=function(){
 return $N}
 frozenset.__new__=function(cls){if(cls===undefined){throw _b_.TypeError.$factory(
 "frozenset.__new__(): not enough arguments")}
 return{
 __class__:cls,$simple:true,$items:[],$numbers:[],$hashes:{}}}
 var singleton_id=Math.floor(Math.random()*Math.pow(2,40))
 function empty_frozenset(){var res=frozenset.__new__(frozenset)
 res.$id=singleton_id
 return res}
 frozenset.$factory=function(){var $=$B.args("frozenset",1,{iterable:null},["iterable"],arguments,{iterable:null},null,null)
 if($.iterable===null){return empty_frozenset()}
 else if($.iterable.__class__==frozenset){return $.iterable}
 var res=set.$factory($.iterable)
 if(res.$items.length==0){return empty_frozenset()}
 res.__class__=frozenset
 return res}
 $B.set_func_names(frozenset,"builtins")
 _b_.set=set
 _b_.frozenset=frozenset})(__BRYTHON__)
 ;
 ;(function($B){var _b_=$B.builtins
 var object=_b_.object
 var _window=self;
 function to_simple(value){switch(typeof value){case 'string':
 case 'number':
 return value
 case 'boolean':
 return value ? "true" :"false"
 case 'object':
 if(value===_b_.None){return 'null'}else if(value instanceof Number){return value.valueOf()}
 default:
 console.log("erreur",value)
 throw _b_.TypeError.$factory("keys must be str, int, "+
 "float, bool or None, not "+$B.class_name(value))}}
 $B.pyobj2structuredclone=function(obj,strict){
 strict=strict===undefined ? true :strict
 if(typeof obj=="boolean" ||typeof obj=="number" ||
 typeof obj=="string"){return obj}else if(obj instanceof Number){return obj.valueOf()}else if(obj===_b_.None){return null }else if(Array.isArray(obj)||obj.__class__===_b_.list ||
 obj.__class__===_b_.tuple){var res=[]
 for(var i=0,len=obj.length;i < len;i++){res.push($B.pyobj2structuredclone(obj[i]))}
 return res}else if(_b_.isinstance(obj,_b_.dict)){if(strict){if(Object.keys(obj.$numeric_dict).length > 0 ||
 Object.keys(obj.$object_dict).length > 0){throw _b_.TypeError.$factory("a dictionary with non-string "+
 "keys does not support structured clone")}}
 var items=$B.dict_to_list(obj),res={}
 for(var i=0,len=items.length;i < len;i++){res[to_simple(items[i][0])]=$B.pyobj2structuredclone(items[i][1])}
 return res}else{return obj}}
 $B.structuredclone2pyobj=function(obj){if(obj===null){return _b_.None}else if(obj===undefined){return $B.Undefined}else if(typeof obj=="boolean" ||typeof obj=="number" ||
 typeof obj=="string"){return obj}else if(obj instanceof Number){return obj.valueOf()}else if(Array.isArray(obj)||obj.__class__===_b_.list ||
 obj.__class__===_b_.tuple){var res=_b_.list.$factory()
 for(var i=0,len=obj.length;i < len;i++){res.push($B.structuredclone2pyobj(obj[i]))}
 return res}else if(typeof obj=="object"){var res=$B.empty_dict()
 for(var key in obj){_b_.dict.$setitem(res,key,$B.structuredclone2pyobj(obj[key]))}
 return res}else{console.log(obj,Array.isArray(obj),obj.__class__,_b_.list,obj.__class__===_b_.list)
 throw _b_.TypeError.$factory(_b_.str.$factory(obj)+
 " does not support the structured clone algorithm")}}
 var JSConstructor={__class__:_b_.type,__mro__:[object],$infos:{__module__:"<javascript>",__name__:'JSConstructor'},$is_class:true}
 JSConstructor.__call__=function(self){
 return function(){var args=[null]
 for(var i=0,len=arguments.length;i < len;i++){args.push(pyobj2jsobj(arguments[i]))}
 var factory=self.func.bind.apply(self.func,args)
 var res=new factory()
 return $B.$JS2Py(res)}}
 JSConstructor.__getattribute__=function(self,attr){
 if(attr=="__call__"){return function(){var args=[null]
 for(var i=0,len=arguments.length;i < len;i++){args.push(pyobj2jsobj(arguments[i]))}
 var factory=self.func.bind.apply(self.func,args)
 var res=new factory()
 return $B.$JS2Py(res)}}
 return JSObject.__getattribute__(self,attr)}
 JSConstructor.$factory=function(obj){return{
 __class__:JSConstructor,js:obj,func:obj.js_func}}
 var jsobj2pyobj=$B.jsobj2pyobj=function(jsobj){switch(jsobj){case true:
 case false:
 return jsobj}
 if(jsobj===undefined){return $B.Undefined}
 else if(jsobj===null){return _b_.None}
 if(Array.isArray(jsobj)){return _b_.list.$factory(jsobj.map(jsobj2pyobj))}
 if(typeof jsobj==='number'){if(jsobj.toString().indexOf('.')==-1){return _b_.int.$factory(jsobj)}
 return _b_.float.$factory(jsobj)}
 if(jsobj.$nat==='kw'){return jsobj}
 if($B.$isNode(jsobj)){return $B.DOMNode.$factory(jsobj)}
 return $B.JSObj.$factory(jsobj)}
 var pyobj2jsobj=$B.pyobj2jsobj=function(pyobj){
 if(pyobj===true ||pyobj===false){return pyobj}
 if(pyobj===_b_.None){return null}
 if(pyobj===$B.Undefined){return undefined}
 var klass=$B.get_class(pyobj)
 if(klass===undefined){
 return pyobj;}
 if(klass===JSConstructor){
 if(pyobj.js_func !==undefined){return pyobj.js_func}
 return pyobj.js}else if(klass===$B.DOMNode ||
 klass.__mro__.indexOf($B.DOMNode)>-1){
 return pyobj}else if([_b_.list,_b_.tuple].indexOf(klass)>-1){
 var res=[]
 pyobj.forEach(function(item){res.push(pyobj2jsobj(item))})
 return res}else if(klass===_b_.dict ||_b_.issubclass(klass,_b_.dict)){
 var jsobj={}
 var items=_b_.list.$factory(_b_.dict.items(pyobj))
 items.forEach(function(item){if(typeof item[1]=='function'){
 item[1].bind(jsobj)}
 jsobj[item[0]]=pyobj2jsobj(item[1])})
 return jsobj}else if(klass===_b_.float){
 return pyobj.valueOf()}else if(klass===$B.Function ||klass===$B.method){
 return function(){try{var args=[]
 for(var i=0;i < arguments.length;i++){if(arguments[i]===undefined){args.push(_b_.None)}
 else{args.push(jsobj2pyobj(arguments[i]))}}
 return pyobj2jsobj(pyobj.apply(this,args))}catch(err){console.log(err)
 console.log($B.$getattr(err,'info'))
 console.log($B.class_name(err)+':',err.args.length > 0 ? err.args[0]:'' )
 throw err}}}else{
 return pyobj}}
 $B.JSConstructor=JSConstructor
 function pyargs2jsargs(pyargs){var args=[]
 for(var i=0,len=pyargs.length;i < len;i++){var arg=pyargs[i]
 if(arg !==undefined && arg !==null &&
 arg.$nat !==undefined){var kw=arg.kw
 if(Array.isArray(kw)){kw=$B.extend(js_attr.name,...kw)}
 if(Object.keys(kw).length > 0){
 throw _b_.TypeError.$factory(
 "A Javascript function can't take "+
 "keyword arguments")}}else{args.push($B.pyobj2jsobj(arg))}}
 return args}
 $B.JSObj=$B.make_class("JSObj",function(jsobj){if(Array.isArray(jsobj)){}else if(typeof jsobj=="function"){jsobj.$is_js_func=true}else if(typeof jsobj=="number" && ! Number.isInteger(jsobj)){return new Number(jsobj)}
 return jsobj}
 )
 $B.JSObj.__sub__=function(self,other){
 if(typeof self=="bigint" && typeof other=="bigint"){return self-other}
 throw _b_.TypeError.$factory("unsupported operand type(s) for - : '"+
 $B.class_name(self)+"' and '"+$B.class_name(other)+"'")}
 var ops={'+':'__add__','*':'__mul__','**':'__pow__','%' :'__mod__'}
 for(var op in ops){eval('$B.JSObj.'+ops[op]+' = '+
 ($B.JSObj.__sub__+'').replace(/-/g,op))}
 $B.JSObj.__eq__=function(self,other){switch(typeof self){case "object":
 if(Object.keys(self).length !==Object.keys(other).length){return false}
 for(var key in self){if(! $B.JSObj.__eq__(self[key],other[key])){return false}}
 default:
 return self===other}}
 $B.JSObj.__ne__=function(self,other){return ! $B.JSObj.__eq__(self,other)}
 $B.JSObj.__getattribute__=function(self,attr){var test=false 
 if(test){console.log("__ga__",self,attr)}
 if(attr=="$$new" && typeof self=="function"){
 if(self.$js_func){return function(){var args=pyargs2jsargs(arguments)
 return $B.JSObj.$factory(new self.$js_func(...args))}}else{return function(){var args=pyargs2jsargs(arguments)
 return $B.JSObj.$factory(new self(...args))}}}
 if(typeof attr=="string"){attr=$B.from_alias(attr)}
 var js_attr=self[attr]
 if(js_attr==undefined && typeof self=="function" && self.$js_func){js_attr=self.$js_func[attr]}
 if(js_attr===undefined){if(typeof self.getNamedItem=='function'){var res=self.getNamedItem(attr)
 if(res !==undefined){return $B.JSObj.$factory(res)}}
 var klass=$B.get_class(self)
 if(klass && klass[attr]){var class_attr=klass[attr]
 if(typeof class_attr=="function"){return function(){var args=[self]
 for(var i=0,len=arguments.length;i < len;i++){args.push(arguments[i])}
 return $B.JSObj.$factory(class_attr.apply(null,args))}}else{return class_attr}}
 if(attr=="bind" && typeof self.addEventListener=="function"){return function(event,callback){return self.addEventListener(event,callback)}}
 throw _b_.AttributeError.$factory(attr)}
 if(typeof js_attr==='function'){var res=function(){var args=pyargs2jsargs(arguments),target=self.$js_func ||self
 try{var result=js_attr.apply(target,args)}catch(err){console.log("error",err)
 console.log("attribute",attr,"of self",self,js_attr,args,arguments)
 throw err}
 if(result===undefined){return $B.Undefined}else if(result===null){return _b_.None}
 return $B.JSObj.$factory(result)}
 res.prototype=js_attr.prototype
 res.$js_func=js_attr
 res.__mro__=[_b_.object]
 res.$infos={__name__:js_attr.name,__qualname__:js_attr.name}
 if($B.frames_stack.length > 0){res.$infos.__module__=$B.last($B.frames_stack)[3].__name__}
 return $B.JSObj.$factory(res)}else{return $B.JSObj.$factory(js_attr)}}
 $B.JSObj.__setattr__=function(self,attr,value){if(typeof attr=="string"){attr=$B.from_alias(attr)}
 self[attr]=$B.pyobj2structuredclone(value)
 return _b_.None}
 $B.JSObj.__getitem__=function(self,key){if(typeof key=="string"){return $B.JSObj.__getattribute__(self,key)}else if(typeof key=="number"){if(self[key]!==undefined){return $B.JSObj.$factory(self[key])}
 if(typeof self.length=='number'){if((typeof key=="number" ||typeof key=="boolean")&&
 typeof self.item=='function'){var rank=_b_.int.$factory(key)
 if(rank < 0){rank+=self.length}
 var res=self.item(rank)
 if(res===null){throw _b_.IndexError.$factory(rank)}
 return $B.JSObj.$factory(res)}}}
 throw _b_.KeyError.$factory(rank)}
 $B.JSObj.__setitem__=$B.JSObj.__setattr__
 var JSObj_iterator=$B.make_iterator_class('JS object iterator')
 $B.JSObj.__iter__=function(self){var items=[]
 if(_window.Symbol && self[Symbol.iterator]!==undefined){
 var items=[]
 if(self.next !==undefined){while(true){var nxt=self.next()
 if(nxt.done){break}
 items.push($B.JSObj.$factory(nxt.value))}}else if(self.length !==undefined && self.item !==undefined){for(var i=0;i < self.length;i++){items.push($B.JSObj.$factory(self.item(i)))}}
 return JSObj_iterator.$factory(items)}else if(self.length !==undefined && self.item !==undefined){
 for(var i=0;i < self.length;i++){items.push($B.JSObj.$factory(self.js.item(i)))}
 return JSObj_iterator.$factory(items)}
 var _dict=$B.JSObj.to_dict(self)
 return _b_.dict.__iter__(_dict)}
 $B.JSObj.__len__=function(self){if(typeof self.length=='number'){return self.length}
 throw _b_.AttributeError.$factory(self+' has no attribute __len__')}
 $B.JSObj.__repr__=$B.JSObj.__str__=function(self){return '<Javascript '+self.constructor.name+' object: '+
 self.toString()+'>'}
 $B.JSObj.bind=function(self,evt,func){
 var js_func=function(ev){return func(jsobj2pyobj(ev))}
 self.addEventListener(evt,js_func)
 return _b_.None}
 $B.JSObj.to_dict=function(self){
 return $B.structuredclone2pyobj(self)}
 $B.set_func_names($B.JSObj,"builtins")
 $B.JSMeta=$B.make_class("JSMeta")
 $B.JSMeta.__call__=function(cls){
 var args=[]
 for(var i=1,len=arguments.length;i < len;i++){args.push(arguments[i])}
 return new cls.__mro__[0].$js_func(...args)}
 $B.JSMeta.__mro__=[_b_.type,_b_.object]
 $B.JSMeta.__getattribute__=function(cls,attr){if(cls[attr]!==undefined){return cls[attr]}else if($B.JSMeta[attr]!==undefined){return $B.JSMeta[attr]}else{
 return _b_.type.__getattribute__(cls,attr)}}
 $B.JSMeta.__init_subclass__=function(){}
 $B.set_func_names($B.JSMeta,"builtins")})(__BRYTHON__)
 ;
 __BRYTHON__.stdlib = {}
 
 ;(function($B){var _b_=$B.builtins,_window=self
 var module=$B.module={__class__ :_b_.type,__mro__:[_b_.object],$infos:{__module__:"builtins",__name__:"module"},$is_class:true}
 module.__init__=function(){}
 module.__new__=function(cls,name,doc,$package){return{
 __class__:cls,__name__:name,__doc__:doc ||_b_.None,__package__:$package ||_b_.None}}
 module.__repr__=module.__str__=function(self){var res="<module "+self.__name__
 if(self.__file__===undefined){res+=" (built-in)"}
 return res+">"}
 module.__setattr__=function(self,attr,value){if(self.__name__=="__builtins__"){
 $B.builtins[attr]=value}else{self[attr]=value}}
 module.$factory=function(name,doc,$package){return{
 __class__:module,__name__:name,__doc__:doc ||_b_.None,__package__:$package ||_b_.None}}
 $B.set_func_names(module,"builtins")
 function parent_package(mod_name){var parts=mod_name.split(".")
 parts.pop()
 return parts.join(".")}
 function $download_module(mod,url,$package){var xhr=new XMLHttpRequest(),fake_qs="?v="+(new Date().getTime()),res=null,mod_name=mod.__name__
 var timer=_window.setTimeout(function(){xhr.abort()},5000)
 if($B.$options.cache){xhr.open("GET",url,false)}else{xhr.open("GET",url+fake_qs,false)}
 xhr.send()
 if($B.$CORS){if(xhr.status==200 ||xhr.status==0){res=xhr.responseText}else{res=_b_.ModuleNotFoundError.$factory("No module named '"+
 mod_name+"'")}}else{if(xhr.readyState==4){if(xhr.status==200){res=xhr.responseText
 mod.$last_modified=
 xhr.getResponseHeader("Last-Modified")}else{
 console.info("Error "+xhr.status+
 " means that Python module "+mod_name+
 " was not found at url "+url)
 res=_b_.ModuleNotFoundError.$factory("No module named '"+
 mod_name+"'")}}}
 _window.clearTimeout(timer)
 if(res==null){throw _b_.ModuleNotFoundError.$factory("No module named '"+
 mod_name+"' (res is null)")}
 if(res.constructor===Error){throw res}
 return res}
 $B.$download_module=$download_module
 function import_js(mod,path){try{var module_contents=$download_module(mod,path,undefined)}catch(err){return null}
 run_js(module_contents,path,mod)
 return true}
 function run_js(module_contents,path,_module){
 try{var $module=new Function(module_contents+";\nreturn $module")()
 if($B.$options.store){_module.$js=module_contents}}catch(err){console.log(err)
 console.log(path,_module)
 throw err}
 try{$module}
 catch(err){console.log("no $module")
 throw _b_.ImportError.$factory("name '$module' not defined in module")}
 $module.__name__=_module.__name__
 for(var attr in $module){if(typeof $module[attr]=="function"){$module[attr].$infos={__module__:_module.__name__,__name__:attr,__qualname__:attr}}}
 if(_module !==undefined){
 for(var attr in $module){_module[attr]=$module[attr]}
 $module=_module
 $module.__class__=module }else{
 $module.__class__=module
 $module.__name__=_module.__name__
 $module.__repr__=$module.__str__=function(){if($B.builtin_module_names.indexOf(_module.name)>-1){return "<module '"+_module.__name__+"' (built-in)>"}
 return "<module '"+_module.__name__+"' from "+path+" >"}
 if(_module.name !="builtins"){
 $module.__file__=path}}
 $B.imported[_module.__name__]=$module
 return true}
 function show_ns(){var kk=Object.keys(_window)
 for(var i=0,len=kk.length;i < len;i++){console.log(kk[i])
 if(kk[i].charAt(0)=="$"){console.log(eval(kk[i]))}}
 console.log("---")}
 function import_py(mod,path,$package){
 var mod_name=mod.__name__,module_contents=$download_module(mod,path,$package)
 mod.$src=module_contents
 $B.imported[mod_name].$is_package=mod.$is_package
 $B.imported[mod_name].$last_modified=mod.$last_modified
 if(path.substr(path.length-12)=="/__init__.py"){$B.imported[mod_name].__package__=mod_name
 $B.imported[mod_name].__path__=path
 $B.imported[mod_name].$is_package=mod.$is_package=true}else if($package){$B.imported[mod_name].__package__=$package}else{var mod_elts=mod_name.split(".")
 mod_elts.pop()
 $B.imported[mod_name].__package__=mod_elts.join(".")}
 $B.imported[mod_name].__file__=path
 return run_py(module_contents,path,mod)}
 function run_py(module_contents,path,module,compiled){
 $B.file_cache[path]=module_contents
 var root,js,mod_name=module.__name__ 
 if(! compiled){var $Node=$B.$Node,$NodeJSCtx=$B.$NodeJSCtx
 $B.$py_module_path[module.__name__]=path
 var src={src:module_contents,has_annotations:false}
 root=$B.py2js(src,module,module.__name__,$B.builtins_scope)
 if(module.__package__ !==undefined){root.binding["__package__"]=true}}
 try{js=compiled ? module_contents :root.to_js()
 if($B.$options.debug==10){console.log("code for module "+module.__name__)
 console.log(js)}
 var src=js
 js="var $module = (function(){\n"+js+"return $locals_"+
 module.__name__.replace(/\./g,"_")+"})(__BRYTHON__)\n"+
 "return $module"
 var module_id="$locals_"+module.__name__.replace(/\./g,'_')
 var $module=(new Function(module_id,js))(module)}catch(err){console.log(err+" for module "+module.__name__)
 console.log("module",module)
 console.log(root)
 if($B.debug > 1){console.log(js)}
 for(var attr in err){console.log(attr,err[attr])}
 console.log(_b_.getattr(err,"info","[no info]"))
 console.log("message: "+err.$message)
 console.log("filename: "+err.fileName)
 console.log("linenum: "+err.lineNumber)
 if($B.debug > 0){console.log("line info "+$B.line_info)}
 throw err}finally{$B.clear_ns(module.__name__)}
 try{
 var mod=eval("$module")
 for(var attr in mod){module[attr]=mod[attr]}
 module.__initializing__=false
 $B.imported[module.__name__]=module
 return{
 content:src,name:mod_name,imports:Object.keys(root.imports).join(",")}}catch(err){console.log(""+err+" "+" for module "+module.__name__)
 for(var attr in err){console.log(attr+" "+err[attr])}
 if($B.debug > 0){console.log("line info "+__BRYTHON__.line_info)}
 throw err}}
 $B.run_py=run_py 
 function new_spec(fields){
 fields.__class__=module
 return fields}
 var finder_VFS={__class__:_b_.type,__mro__:[_b_.object],$infos:{__module__:"builtins",__name__:"VFSFinder"},create_module :function(cls,spec){
 return _b_.None},exec_module :function(cls,modobj){var stored=modobj.__spec__.loader_state.stored,timestamp=modobj.__spec__.loader_state.timestamp
 delete modobj.__spec__["loader_state"]
 var ext=stored[0],module_contents=stored[1],imports=stored[2]
 modobj.$is_package=stored[3]||false
 var path="VFS."+modobj.__name__
 path+=modobj.$is_package ? "/__init__.py" :ext
 modobj.__file__=path
 $B.file_cache[modobj.__file__]=$B.VFS[modobj.__name__][1]
 if(ext=='.js'){run_js(module_contents,modobj.__path__,modobj)}else if($B.precompiled.hasOwnProperty(modobj.__name__)){if($B.debug > 1){console.info("load",modobj.__name__,"from precompiled")}
 var parts=modobj.__name__.split(".")
 for(var i=0;i < parts.length;i++){var parent=parts.slice(0,i+1).join(".")
 if($B.imported.hasOwnProperty(parent)&&
 $B.imported[parent].__initialized__){continue}
 var mod_js=$B.precompiled[parent],is_package=modobj.$is_package
 if(Array.isArray(mod_js)){mod_js=mod_js[0]}
 var mod=$B.imported[parent]=module.$factory(parent,undefined,is_package)
 mod.__initialized__=true
 if(is_package){mod.__path__="<stdlib>"
 mod.__package__=parent}else{var elts=parent.split(".")
 elts.pop()
 mod.__package__=elts.join(".")}
 mod.__file__=path
 try{var parent_id=parent.replace(/\./g,"_")
 mod_js+="return $locals_"+parent_id
 var $module=new Function("$locals_"+parent_id,mod_js)(
 mod)}catch(err){if($B.debug > 1){console.log(err)
 for(var k in err){console.log(k,err[k])}
 console.log(Object.keys($B.imported))
 if($B.debug > 2){console.log(modobj,"mod_js",mod_js)}}
 throw err}
 for(var attr in $module){mod[attr]=$module[attr]}
 $module.__file__=path
 if(i > 0){
 $B.builtins.setattr(
 $B.imported[parts.slice(0,i).join(".")],parts[i],$module)}}
 return $module}else{var mod_name=modobj.__name__
 if($B.debug > 1){console.log("run Python code from VFS",mod_name)}
 var record=run_py(module_contents,modobj.__path__,modobj)
 record.is_package=modobj.$is_package
 record.timestamp=$B.timestamp
 record.source_ts=timestamp
 $B.precompiled[mod_name]=record.is_package ?[record.content]:
 record.content
 var elts=mod_name.split(".")
 if(elts.length > 1){elts.pop()}
 if($B.$options.indexedDB && self.indexedDB &&
 $B.idb_name){
 var idb_cx=indexedDB.open($B.idb_name)
 idb_cx.onsuccess=function(evt){var db=evt.target.result,tx=db.transaction("modules","readwrite"),store=tx.objectStore("modules"),cursor=store.openCursor(),request=store.put(record)
 request.onsuccess=function(){if($B.debug > 1){console.info(modobj.__name__,"stored in db")}}
 request.onerror=function(){console.info("could not store "+modobj.__name__)}}}}},find_module:function(cls,name,path){return{
 __class__:Loader,load_module:function(name,path){var spec=cls.find_spec(cls,name,path)
 var mod=module.$factory(name)
 $B.imported[name]=mod
 mod.__spec__=spec
 cls.exec_module(cls,mod)}}},find_spec :function(cls,fullname,path,prev_module){var stored,is_package,timestamp
 if(!$B.use_VFS){return _b_.None}
 stored=$B.VFS[fullname]
 if(stored===undefined){return _b_.None}
 is_package=stored[3]||false
 timestamp=stored.timestamp
 if(stored){var is_builtin=$B.builtin_module_names.indexOf(fullname)>-1
 return new_spec({name :fullname,loader:cls,
 origin :is_builtin? "built-in" :"brython_stdlib",
 submodule_search_locations:is_package?[]:_b_.None,loader_state:{stored:stored,timestamp:timestamp},
 cached:_b_.None,parent:is_package? fullname :parent_package(fullname),has_location:_b_.False})}}}
 $B.set_func_names(finder_VFS,"<import>")
 for(var method in finder_VFS){if(typeof finder_VFS[method]=="function"){finder_VFS[method]=_b_.classmethod.$factory(
 finder_VFS[method])}}
 finder_VFS.$factory=function(){return{__class__:finder_VFS}}
 var finder_cpython={__class__:_b_.type,__mro__:[_b_.object],$infos:{__module__:"builtins",__name__:"CPythonFinder"},create_module :function(cls,spec){
 return _b_.None},exec_module :function(cls,modobj){console.log("exec PYthon module",modobj)
 var loader_state=modobj.__spec__.loader_state
 var content=loader_state.content
 delete modobj.__spec__["loader_state"]
 modobj.$is_package=loader_state.is_package
 modobj.__file__=loader_state.__file__
 $B.file_cache[modobj.__file__]=content
 var mod_name=modobj.__name__
 if($B.debug > 1){console.log("run Python code from CPython",mod_name)}
 run_py(content,modobj.__path__,modobj)},find_module:function(cls,name,path){return{
 __class__:Loader,load_module:function(name,path){var spec=cls.find_spec(cls,name,path)
 var mod=module.$factory(name)
 $B.imported[name]=mod
 mod.__spec__=spec
 cls.exec_module(cls,mod)}}},find_spec :function(cls,fullname,path,prev_module){console.log("finder cpython",fullname)
 var xhr=new XMLHttpRequest(),url="/cpython_import?module="+fullname,result
 xhr.open("GET",url,false)
 xhr.onreadystatechange=function(){if(this.readyState==4 && this.status==200){var data=JSON.parse(this.responseText)
 result=new_spec({name :fullname,loader:cls,
 origin :"CPython",
 submodule_search_locations:data.is_package?[]:_b_.None,loader_state:{content:data.content},
 cached:_b_.None,parent:data.is_package? fullname :parent_package(fullname),has_location:_b_.False})}}
 xhr.send()
 return result}}
 $B.set_func_names(finder_cpython,"<import>")
 for(var method in finder_cpython){if(typeof finder_cpython[method]=="function"){finder_cpython[method]=_b_.classmethod.$factory(
 finder_cpython[method])}}
 finder_cpython.$factory=function(){return{__class__:finder_cpython}}
 var finder_stdlib_static={$factory :finder_stdlib_static,__class__ :_b_.type,__mro__:[_b_.object],$infos:{__module__:"builtins",__name__:"StdlibStatic"},create_module :function(cls,spec){
 return _b_.None},exec_module :function(cls,module){var metadata=module.__spec__.loader_state
 module.$is_package=metadata.is_package
 if(metadata.ext=="py"){import_py(module,metadata.path,module.__package__)}else{import_js(module,metadata.path)}
 delete module.__spec__["loader_state"]},find_module:function(cls,name,path){var spec=cls.find_spec(cls,name,path)
 if(spec===_b_.None){return _b_.None}
 return{
 __class__:Loader,load_module:function(name,path){var mod=module.$factory(name)
 $B.imported[name]=mod
 mod.__spec__=spec
 mod.__package__=spec.parent
 cls.exec_module(cls,mod)}}},find_spec:function(cls,fullname,path,prev_module){if($B.stdlib && $B.$options.static_stdlib_import){var address=$B.stdlib[fullname]
 if(address===undefined){var elts=fullname.split(".")
 if(elts.length > 1){elts.pop()
 var $package=$B.stdlib[elts.join(".")]
 if($package && $package[1]){address=["py"]}}}
 if(address !==undefined){var ext=address[0],is_pkg=address[1]!==undefined,path=$B.brython_path+
 ((ext=="py")? "Lib/" :"libs/")+
 fullname.replace(/\./g,"/"),metadata={ext:ext,is_package:is_pkg,path:path+(is_pkg? "/__init__.py" :
 ((ext=="py")? ".py" :".js")),address:address}
 var res=new_spec({name :fullname,loader:cls,
 origin :metadata.path,submodule_search_locations:is_pkg?[path]:_b_.None,loader_state:metadata,
 cached:_b_.None,parent:is_pkg ? fullname :parent_package(fullname),has_location:_b_.True})
 return res}}
 return _b_.None}}
 $B.set_func_names(finder_stdlib_static,"<import>")
 for(var method in finder_stdlib_static){if(typeof finder_stdlib_static[method]=="function"){finder_stdlib_static[method]=_b_.classmethod.$factory(
 finder_stdlib_static[method])}}
 finder_stdlib_static.$factory=function(){return{__class__:finder_stdlib_static}}
 var finder_path={__class__:_b_.type,__mro__:[_b_.object],$infos:{__module__:"builtins",__name__:"ImporterPath"},create_module :function(cls,spec){
 return _b_.None},exec_module :function(cls,_module){var _spec=$B.$getattr(_module,"__spec__"),code=_spec.loader_state.code;
 _module.$is_package=_spec.loader_state.is_package,delete _spec.loader_state["code"]
 var src_type=_spec.loader_state.type
 if(src_type=="py" ||src_type=="pyc.js"){run_py(code,_spec.origin,_module,src_type=="pyc.js")}
 else if(_spec.loader_state.type=="js"){run_js(code,_spec.origin,_module)}},find_module:function(cls,name,path){return finder_path.find_spec(cls,name,path)},find_spec :function(cls,fullname,path,prev_module){var current_module=$B.last($B.frames_stack)[2]
 if($B.VFS && $B.VFS[current_module]){
 return _b_.None}
 if($B.is_none(path)){
 path=$B.path}
 for(var i=0,li=path.length;i < li;++i){var path_entry=path[i]
 if(path_entry[path_entry.length-1]!="/"){path_entry+="/"}
 var finder=$B.path_importer_cache[path_entry]
 if(finder===undefined){var finder_notfound=true
 for(var j=0,lj=$B.path_hooks.length;
 j < lj && finder_notfound;++j){var hook=$B.path_hooks[j].$factory
 try{finder=(typeof hook=="function" ? hook :
 $B.$getattr(hook,"__call__"))(path_entry)
 finder_notfound=false}catch(e){if(e.__class__ !==_b_.ImportError){throw e}}}
 if(finder_notfound){$B.path_importer_cache[path_entry]=_b_.None}}
 if($B.is_none(finder)){continue}
 var find_spec=$B.$getattr(finder,"find_spec"),fs_func=typeof find_spec=="function" ?
 find_spec :
 $B.$getattr(find_spec,"__call__")
 var spec=fs_func(fullname,prev_module)
 if(!$B.is_none(spec)){return spec}}
 return _b_.None}}
 $B.set_func_names(finder_path,"<import>")
 for(var method in finder_path){if(typeof finder_path[method]=="function"){finder_path[method]=_b_.classmethod.$factory(
 finder_path[method])}}
 finder_path.$factory=function(){return{__class__:finder_path}}
 var url_hook={__class__:_b_.type,__mro__:[_b_.object],__repr__:function(self){return "<UrlPathFinder"+(self.hint? " for '"+self.hint+"'":
 "(unbound)")+" at "+self.path_entry+'>'},$infos:{__module__:"builtins",__name__:"UrlPathFinder"},find_spec :function(self,fullname,module){var loader_data={},notfound=true,hint=self.hint,base_path=self.path_entry+fullname.match(/[^.]+$/g)[0],modpaths=[]
 var tryall=hint===undefined
 if(tryall ||hint=='py'){
 modpaths=modpaths.concat([[base_path+".py","py",false],[base_path+"/__init__.py","py",true]])}
 for(var j=0;notfound && j < modpaths.length;++j){try{var file_info=modpaths[j],module={__name__:fullname,$is_package:false}
 loader_data.code=$download_module(module,file_info[0],undefined)
 notfound=false
 loader_data.type=file_info[1]
 loader_data.is_package=file_info[2]
 if(hint===undefined){self.hint=file_info[1]
 $B.path_importer_cache[self.path_entry]=self}
 if(loader_data.is_package){
 $B.path_importer_cache[base_path+'/']=
 url_hook.$factory(base_path+'/',self.hint)}
 loader_data.path=file_info[0]}catch(err){}}
 if(!notfound){return new_spec({name :fullname,loader:finder_path,origin :loader_data.path,
 submodule_search_locations:loader_data.is_package?
 [base_path]:_b_.None,loader_state:loader_data,
 cached:_b_.None,parent:loader_data.is_package? fullname :
 parent_package(fullname),has_location:_b_.True})}
 return _b_.None},invalidate_caches :function(self){}}
 url_hook.$factory=function(path_entry,hint){return{
 __class__:url_hook,path_entry:path_entry.endsWith("/")? path_entry :path_entry+"/",hint:hint}}
 $B.set_func_names(url_hook,"<import>")
 $B.path_importer_cache={};
 var _sys_paths=[[$B.script_dir+"/","py"],[$B.brython_path+"Lib/","py"],[$B.brython_path+"Lib/site-packages/","py"],[$B.brython_path+"libs/","js"]]
 for(var i=0;i < _sys_paths.length;++i){var _path=_sys_paths[i],_type=_path[1]
 _path=_path[0]
 $B.path_importer_cache[_path]=url_hook.$factory(_path,_type)}
 function import_error(mod_name){var exc=_b_.ImportError.$factory(mod_name)
 exc.name=mod_name
 throw exc}
 $B.$__import__=function(mod_name,globals,locals,fromlist,level){var $test=false 
 if($test){console.log("__import__",mod_name)}
 var from_stdlib=false
 if(globals.$jsobj && globals.$jsobj.__file__){var file=globals.$jsobj.__file__
 if((file.startsWith($B.brython_path+"Lib/")&&
 ! file.startsWith($B.brython_path+"Lib/site-packages/"))||
 file.startsWith($B.brython_path+"libs/")||
 file.startsWith("VFS.")){from_stdlib=true}}
 var modobj=$B.imported[mod_name],parsed_name=mod_name.split('.'),has_from=fromlist.length > 0
 if(modobj==_b_.None){
 import_error(mod_name)}
 if(modobj===undefined){
 if($B.is_none(fromlist)){fromlist=[]}
 for(var i=0,modsep="",_mod_name="",len=parsed_name.length-1,__path__=_b_.None;i <=len;++i){var _parent_name=_mod_name;
 _mod_name+=modsep+parsed_name[i]
 modsep="."
 var modobj=$B.imported[_mod_name]
 if(modobj==_b_.None){
 import_error(_mod_name)}else if(modobj===undefined){try{$B.import_hooks(_mod_name,__path__,from_stdlib)}catch(err){delete $B.imported[_mod_name]
 throw err}
 if($B.is_none($B.imported[_mod_name])){import_error(_mod_name)}else{
 if(_parent_name){_b_.setattr($B.imported[_parent_name],parsed_name[i],$B.imported[_mod_name])}}}else if($B.imported[_parent_name]&&
 $B.imported[_parent_name][parsed_name[i]]===undefined){
 _b_.setattr($B.imported[_parent_name],parsed_name[i],$B.imported[_mod_name])}
 if(i < len){try{__path__=$B.$getattr($B.imported[_mod_name],"__path__")}catch(e){
 if(i==len-1 &&
 $B.imported[_mod_name][parsed_name[len]]&&
 $B.imported[_mod_name][parsed_name[len]].__class__===
 module){return $B.imported[_mod_name][parsed_name[len]]}
 if(has_from){
 import_error(mod_name)}else{
 var exc=_b_.ModuleNotFoundError.$factory()
 exc.msg="No module named '"+mod_name+"'; '"+
 _mod_name+"' is not a package"
 exc.args=$B.fast_tuple([exc.msg])
 exc.name=mod_name
 exc.path=_b_.None
 throw exc}}}}}else{if($B.imported[parsed_name[0]]&&
 parsed_name.length==2){try{if($B.imported[parsed_name[0]][parsed_name[1]]===undefined){$B.$setattr($B.imported[parsed_name[0]],parsed_name[1],modobj)}}catch(err){console.log("error",parsed_name,modobj)
 throw err}}}
 if(fromlist.length > 0){
 return $B.imported[mod_name]}else{
 return $B.imported[parsed_name[0]]}}
 $B.$import=function(mod_name,fromlist,aliases,locals){fromlist=fromlist===undefined ?[]:fromlist
 aliases=aliases===undefined ?{}:aliases
 locals=locals===undefined ?{}:locals
 var parts=mod_name.split(".")
 if(mod_name[mod_name.length-1]=="."){parts.pop()}
 var norm_parts=[],prefix=true
 for(var i=0,len=parts.length;i < len;i++){var p=parts[i]
 if(prefix && p==""){
 elt=norm_parts.pop()
 if(elt===undefined){throw _b_.ImportError.$factory("Parent module '' not loaded, "+
 "cannot perform relative import")}}else{prefix=false;
 norm_parts.push(p.substr(0,2)=="$$" ? p.substr(2):p)}}
 var mod_name=norm_parts.join(".")
 if($B.$options.debug==10){console.log("$import "+mod_name)
 console.log("use VFS ? "+$B.use_VFS)
 console.log("use static stdlib paths ? "+$B.static_stdlib_import)}
 var current_frame=$B.frames_stack[$B.frames_stack.length-1],_globals=current_frame[3],__import__=_globals["__import__"],globals=$B.obj_dict(_globals)
 if(__import__===undefined){
 __import__=$B.$__import__}
 var importer=typeof __import__=="function" ?
 __import__ :
 $B.$getattr(__import__,"__call__"),modobj=importer(mod_name,globals,undefined,fromlist,0)
 if(! fromlist ||fromlist.length==0){
 var alias=aliases[mod_name]
 if(alias){locals[alias]=$B.imported[mod_name]}else{locals[$B.to_alias(norm_parts[0])]=modobj}}else{var __all__=fromlist,thunk={}
 if(fromlist && fromlist[0]=="*"){__all__=$B.$getattr(modobj,"__all__",thunk);
 if(__all__ !==thunk){
 aliases={}}}
 if(__all__===thunk){
 for(var attr in modobj){if(attr[0]!=="_"){locals[attr]=modobj[attr]}}}else{
 for(var i=0,l=__all__.length;i < l;++i){var name=__all__[i]
 var alias=aliases[name]||name
 try{
 locals[alias]=$B.$getattr(modobj,name)}catch($err1){
 try{var name1=$B.from_alias(name)
 $B.$getattr(__import__,'__call__')(mod_name+'.'+name1,globals,undefined,[],0)
 locals[alias]=$B.$getattr(modobj,name1)}catch($err3){
 if(mod_name==="__future__"){
 var frame=$B.last($B.frames_stack),line_info=frame[3].$line_info,line_elts=line_info.split(','),line_num=parseInt(line_elts[0])
 $B.$SyntaxError(frame[2],"future feature "+name+" is not defined",current_frame[3].src,undefined,line_num)}
 if($err3.$py_error){var errname=$err3.__class__.$infos.__name__
 if($err3.__class__ !==_b_.ImportError &&
 $err3.__class__ !==_b_.ModuleNotFoundError){$B.handle_error($err3)}
 throw _b_.ImportError.$factory(
 "cannot import name '"+name+"'")}
 if($B.debug > 1){console.log($err3)
 console.log($B.last($B.frames_stack))}
 throw _b_.ImportError.$factory(
 "cannot import name '"+name+"'")}}}}
 return locals}}
 $B.import_all=function(locals,module){
 for(var attr in module){if(attr.startsWith("$$")){locals[attr]=module[attr]}else if('_$'.indexOf(attr.charAt(0))==-1){locals[attr]=module[attr]}}}
 $B.$path_hooks=[url_hook]
 $B.$meta_path=[finder_VFS,finder_stdlib_static,finder_path]
 $B.finders={VFS:finder_VFS,stdlib_static:finder_stdlib_static,path:finder_path,CPython:finder_cpython}
 function optimize_import_for_path(path,filetype){if(path.slice(-1)!="/"){path=path+"/" }
 var value=(filetype=='none')? _b_.None :
 url_hook.$factory(path,filetype)
 $B.path_importer_cache[path]=value}
 var Loader={__class__:$B.$type,__mro__:[_b_.object],__name__ :"Loader"}
 var _importlib_module={__class__ :module,__name__ :"_importlib",Loader:Loader,VFSFinder:finder_VFS,StdlibStatic:finder_stdlib_static,ImporterPath:finder_path,UrlPathFinder:url_hook,optimize_import_for_path :optimize_import_for_path}
 _importlib_module.__repr__=_importlib_module.__str__=function(){return "<module '_importlib' (built-in)>"}
 $B.imported["_importlib"]=_importlib_module})(__BRYTHON__)
 ;
 ;(function($B){var bltns=$B.InjectBuiltins()
 eval(bltns)
 var object=_b_.object
 function $err(op,other){var msg="unsupported operand type(s) for "+op+
 ": 'float' and '"+$B.class_name(other)+"'"
 throw _b_.TypeError.$factory(msg)}
 function float_value(obj){
 return obj.$brython_value !==undefined ? obj.$brython_value :obj}
 var float={__class__:_b_.type,__dir__:object.__dir__,$infos:{__module__:"builtins",__name__:"float"},$is_class:true,$native:true,$descriptors:{"numerator":true,"denominator":true,"imag":true,"real":true}}
 float.numerator=function(self){return float_value(self)}
 float.denominator=function(self){return _b_.int.$factory(1)}
 float.imag=function(self){return _b_.int.$factory(0)}
 float.real=function(self){return float_value(self)}
 float.__float__=function(self){return float_value(self)}
 float.as_integer_ratio=function(self){self=float_value(self)
 if(self.valueOf()==Number.POSITIVE_INFINITY ||
 self.valueOf()==Number.NEGATIVE_INFINITY){throw _b_.OverflowError.$factory("Cannot pass infinity to "+
 "float.as_integer_ratio.")}
 if(! Number.isFinite(self.valueOf())){throw _b_.ValueError.$factory("Cannot pass NaN to "+
 "float.as_integer_ratio.")}
 var tmp=_b_.$frexp(self.valueOf()),fp=tmp[0],exponent=tmp[1]
 for(var i=0;i < 300;i++){if(fp==Math.floor(fp)){break}else{fp*=2
 exponent--}}
 numerator=float.$factory(fp)
 py_exponent=abs(exponent)
 denominator=1
 py_exponent=_b_.getattr(_b_.int.$factory(denominator),"__lshift__")(py_exponent)
 if(exponent > 0){numerator=numerator*py_exponent}else{denominator=py_exponent}
 return _b_.tuple.$factory([_b_.int.$factory(numerator),_b_.int.$factory(denominator)])}
 float.__bool__=function(self){self=float_value(self)
 return _b_.bool.$factory(self.valueOf())}
 float.__eq__=function(self,other){self=float_value(self)
 other=float_value(other)
 if(isNaN(self)&& isNaN(other)){return false}
 if(isinstance(other,_b_.int)){return self==other}
 if(isinstance(other,float)){
 return self.valueOf()==other.valueOf()}
 if(isinstance(other,_b_.complex)){if(other.$imag !=0){return false}
 return self==other.$real}
 return _b_.NotImplemented}
 float.__floordiv__=function(self,other){self=float_value(self)
 other=float_value(other)
 if(isinstance(other,[_b_.int,float])){if(other.valueOf()==0){throw ZeroDivisionError.$factory('division by zero')}
 return float.$factory(Math.floor(self/other))}
 if(hasattr(other,"__rfloordiv__")){return getattr(other,"__rfloordiv__")(self)}
 $err("//",other)}
 float.fromhex=function(arg){
 if(! isinstance(arg,_b_.str)){throw _b_.ValueError.$factory("argument must be a string")}
 var value=arg.trim()
 switch(value.toLowerCase()){case "+inf":
 case "inf":
 case "+infinity":
 case "infinity":
 return $FloatClass(Infinity)
 case "-inf":
 case "-infinity":
 return $FloatClass(-Infinity)
 case "+nan":
 case "nan":
 return $FloatClass(Number.NaN)
 case "-nan":
 return $FloatClass(-Number.NaN)
 case "":
 throw _b_.ValueError.$factory("could not convert string to float")}
 var _m=/^(\d*\.?\d*)$/.exec(value)
 if(_m !==null){return $FloatClass(parseFloat(_m[1]))}
 var _m=/^(\+|-)?(0x)?([0-9A-F]+\.?)?(\.[0-9A-F]+)?(p(\+|-)?\d+)?$/i.exec(value)
 if(_m==null){throw _b_.ValueError.$factory("invalid hexadecimal floating-point string")}
 var _sign=_m[1],_int=parseInt(_m[3]||'0',16),_fraction=_m[4]||'.0',_exponent=_m[5]||'p0'
 if(_sign=="-"){_sign=-1}else{_sign=1}
 var _sum=_int
 for(var i=1,len=_fraction.length;i < len;i++){_sum+=parseInt(_fraction.charAt(i),16)/Math.pow(16,i)}
 return new Number(_sign*_sum*Math.pow(2,parseInt(_exponent.substring(1))))}
 float.__getformat__=function(arg){if(arg=="double" ||arg=="float"){return "IEEE, little-endian"}
 throw _b_.ValueError.$factory("__getformat__() argument 1 must be "+
 "'double' or 'float'")}
 function preformat(self,fmt){if(fmt.empty){return _b_.str.$factory(self)}
 if(fmt.type && 'eEfFgGn%'.indexOf(fmt.type)==-1){throw _b_.ValueError.$factory("Unknown format code '"+fmt.type+
 "' for object of type 'float'")}
 if(isNaN(self)){if(fmt.type=="f" ||fmt.type=="g"){return "nan"}
 else{return "NAN"}}
 if(self==Number.POSITIVE_INFINITY){if(fmt.type=="f" ||fmt.type=="g"){return "inf"}
 else{return "INF"}}
 if(fmt.precision===undefined && fmt.type !==undefined){fmt.precision=6}
 if(fmt.type=="%"){self*=100}
 if(fmt.type=="e"){var res=self.toExponential(fmt.precision),exp=parseInt(res.substr(res.search("e")+1))
 if(Math.abs(exp)< 10){res=res.substr(0,res.length-1)+"0"+
 res.charAt(res.length-1)}
 return res}
 if(fmt.precision !==undefined){
 var prec=fmt.precision
 if(prec==0){return Math.round(self)+""}
 var res=self.toFixed(prec),pt_pos=res.indexOf(".")
 if(fmt.type !==undefined &&
 (fmt.type=="%" ||fmt.type.toLowerCase()=="f")){if(pt_pos==-1){res+="."+"0".repeat(fmt.precision)}else{var missing=fmt.precision-res.length+pt_pos+1
 if(missing > 0){res+="0".repeat(missing)}}}else if(fmt.type && fmt.type.toLowerCase()=="g"){var exp_fmt=preformat(self,{type:"e"}).split("e"),exp=parseInt(exp_fmt[1])
 if(-4 <=exp && exp < fmt.precision){res=preformat(self,{type:"f",precision:fmt.precision-1-exp})}else{res=preformat(self,{type:"e",precision:fmt.precision-1})}
 var parts=res.split("e")
 if(fmt.alternate){if(parts[0].search(/\./)==-1){parts[0]+='.'}}else{if(parts[1]){var signif=parts[0]
 while(signif.endsWith("0")){signif=signif.substr(0,signif.length-1)}
 if(signif.endsWith(".")){signif=signif.substr(0,signif.length-1)}
 parts[0]=signif}}
 res=parts.join("e")
 if(fmt.type=="G"){res=res.toUpperCase()}
 return res}else if(fmt.type===undefined){fmt.type="g"
 res=preformat(self,fmt)
 fmt.type=undefined}else{var res1=self.toExponential(fmt.precision-1),exp=parseInt(res1.substr(res1.search("e")+1))
 if(exp <-4 ||exp >=fmt.precision-1){var elts=res1.split("e")
 while(elts[0].endsWith("0")){elts[0]=elts[0].substr(0,elts[0].length-1)}
 res=elts.join("e")}}}else{var res=_b_.str.$factory(self)}
 if(fmt.type===undefined ||"gGn".indexOf(fmt.type)!=-1){
 if(res.search("e")==-1){while(res.charAt(res.length-1)=="0"){res=res.substr(0,res.length-1)}}
 if(res.charAt(res.length-1)=="."){if(fmt.type===undefined){res+="0"}
 else{res=res.substr(0,res.length-1)}}}
 if(fmt.sign !==undefined){if((fmt.sign==" " ||fmt.sign=="+" )&& self > 0){res=fmt.sign+res}}
 if(fmt.type=="%"){res+="%"}
 return res}
 float.__format__=function(self,format_spec){self=float_value(self)
 var fmt=new $B.parse_format_spec(format_spec)
 fmt.align=fmt.align ||">"
 var raw=preformat(self,fmt).split('.'),_int=raw[0]
 if(fmt.comma){var len=_int.length,nb=Math.ceil(_int.length/3),chunks=[]
 for(var i=0;i < nb;i++){chunks.push(_int.substring(len-3*i-3,len-3*i))}
 chunks.reverse()
 raw[0]=chunks.join(",")}
 return $B.format_width(raw.join("."),fmt)}
 float.__hash__=function(self){if(self===undefined){return float.__hashvalue__ ||$B.$py_next_hash--}
 var _v=self.valueOf()
 if(_v===Infinity){return 314159}
 if(_v===-Infinity){return-271828}
 if(isNaN(_v)){return 0}
 if(_v==Math.round(_v)){return Math.round(_v)}
 var r=_b_.$frexp(_v)
 r[0]*=Math.pow(2,31)
 var hipart=_b_.int.$factory(r[0])
 r[0]=(r[0]-hipart)*Math.pow(2,31)
 var x=hipart+_b_.int.$factory(r[0])+(r[1]<< 15)
 return x & 0xFFFFFFFF}
 _b_.$isninf=function(x){var x1=x
 if(isinstance(x,float)){x1=x.valueOf()}
 return x1==-Infinity ||x1==Number.NEGATIVE_INFINITY}
 _b_.$isinf=function(x){var x1=x
 if(isinstance(x,float)){x1=x.valueOf()}
 return x1==Infinity ||x1==-Infinity ||
 x1==Number.POSITIVE_INFINITY ||x1==Number.NEGATIVE_INFINITY}
 _b_.$fabs=function(x){return x > 0 ? float.$factory(x):float.$factory(-x)}
 _b_.$frexp=function(x){var x1=x
 if(isinstance(x,float)){x1=x.valueOf()}
 if(isNaN(x1)||_b_.$isinf(x1)){return[x1,-1]}
 if(x1==0){return[0,0]}
 var sign=1,ex=0,man=x1
 if(man < 0.){sign=-sign
 man=-man}
 while(man < 0.5){man*=2.0
 ex--}
 while(man >=1.0){man*=0.5
 ex++}
 man*=sign
 return[man,ex]}
 _b_.$ldexp=function(x,i){if(_b_.$isninf(x)){return float.$factory('-inf')}
 if(_b_.$isinf(x)){return float.$factory('inf')}
 var y=x
 if(isinstance(x,float)){y=x.valueOf()}
 if(y==0){return y}
 var j=i
 if(isinstance(i,float)){j=i.valueOf()}
 return y*Math.pow(2,j)}
 float.hex=function(self){
 self=float_value(self)
 var DBL_MANT_DIG=53,
 TOHEX_NBITS=DBL_MANT_DIG+3-(DBL_MANT_DIG+2)% 4
 switch(self.valueOf()){case Infinity:
 case-Infinity:
 case Number.NaN:
 case-Number.NaN:
 return self
 case-0:
 return "-0x0.0p0"
 case 0:
 return "0x0.0p0"}
 var _a=_b_.$frexp(_b_.$fabs(self.valueOf())),_m=_a[0],_e=_a[1],_shift=1-Math.max(-1021-_e,0)
 _m=_b_.$ldexp(_m,_shift)
 _e-=_shift
 var _int2hex="0123456789ABCDEF".split(""),_s=_int2hex[Math.floor(_m)]
 _s+='.'
 _m-=Math.floor(_m)
 for(var i=0;i <(TOHEX_NBITS-1)/4;i++){_m*=16.0
 _s+=_int2hex[Math.floor(_m)]
 _m-=Math.floor(_m)}
 var _esign="+"
 if(_e < 0){_esign="-"
 _e=-_e}
 if(self.value < 0){return "-0x"+_s+"p"+_esign+_e}
 return "0x"+_s+"p"+_esign+_e}
 float.__init__=function(self,value){return _b_.None}
 float.__int__=function(self){return parseInt(self)}
 float.is_integer=function(self){return _b_.int.$factory(self)==self}
 float.__mod__=function(self,other){
 self=float_value(self)
 other=float_value(other)
 if(other==0){throw ZeroDivisionError.$factory("float modulo")}
 if(isinstance(other,_b_.int)){return new Number((self % other+other)% other)}
 if(isinstance(other,float)){
 var q=Math.floor(self/other),r=self-other*q
 return new Number(r)}
 if(isinstance(other,_b_.bool)){var bool_value=0
 if(other.valueOf()){bool_value=1}
 return new Number((self % bool_value+bool_value)% bool_value)}
 if(hasattr(other,"__rmod__")){return getattr(other,"__rmod__")(self)}
 $err("%",other)}
 float.__mro__=[object]
 float.__mul__=function(self,other){self=float_value(self)
 other=float_value(other)
 if(isinstance(other,_b_.int)){if(other.__class__==$B.long_int){return new Number(self*parseFloat(other.value))}
 return new Number(self*other)}
 if(isinstance(other,float)){return new Number(self*float_value(other))}
 if(isinstance(other,_b_.bool)){var bool_value=0
 if(other.valueOf()){bool_value=1}
 return new Number(self*bool_value)}
 if(isinstance(other,_b_.complex)){return $B.make_complex(float.$factory(self*other.$real),float.$factory(self*other.$imag))}
 if(hasattr(other,"__rmul__")){return getattr(other,"__rmul__")(self)}
 $err("*",other)}
 float.__ne__=function(self,other){var res=float.__eq__(self,other)
 return res===_b_.NotImplemented ? res :! res}
 float.__neg__=function(self,other){return float.$factory(-float_value(self))}
 float.__new__=function(cls,value){if(cls===undefined){throw _b_.TypeError.$factory("float.__new__(): not enough arguments")}else if(! _b_.isinstance(cls,_b_.type)){throw _b_.TypeError.$factory("float.__new__(X): X is not a type object")}
 if(cls===float){return float.$factory(value)}
 return{
 __class__:cls,__dict__:$B.empty_dict(),$brython_value:value ||0}}
 float.__pos__=function(self){return float_value(self)}
 float.__pow__=function(self,other){self=float_value(self)
 other=float_value(other)
 var other_int=isinstance(other,_b_.int)