diff options
Diffstat (limited to 'src/lua')
85 files changed, 21392 insertions, 0 deletions
diff --git a/src/lua/.cvsignore b/src/lua/.cvsignore new file mode 100644 index 00000000..0b086004 --- /dev/null +++ b/src/lua/.cvsignore @@ -0,0 +1,2 @@ +tolua +host diff --git a/src/lua/.gitignore b/src/lua/.gitignore new file mode 100644 index 00000000..26548e17 --- /dev/null +++ b/src/lua/.gitignore @@ -0,0 +1,2 @@ +/liblua.a +/tolua diff --git a/src/lua/CMakeLists.txt b/src/lua/CMakeLists.txt new file mode 100644 index 00000000..df2b30e7 --- /dev/null +++ b/src/lua/CMakeLists.txt @@ -0,0 +1,11 @@ +ADD_LIBRARY (lua STATIC + lapi.c lcode.c ldebug.c ldo.c lfunc.c lgc.c + llex.c lmem.c lobject.c lparser.c lstate.c lstring.c + ltable.c ltests.c ltm.c lundump.c lvm.c lzio.c + lauxlib.c lbaselib.c ldblib.c liolib.c lstrlib.c + tolua_lb.c tolua_rg.c tolua_tt.c tolua_tm.c tolua_gp.c + tolua_eh.c tolua_bd.c) + +ADD_EXECUTABLE(tolua tolua.c tolualua.c lua) + +TARGET_LINK_LIBRARIES(tolua lua) diff --git a/src/lua/array.lua b/src/lua/array.lua new file mode 100644 index 00000000..7929f8cd --- /dev/null +++ b/src/lua/array.lua @@ -0,0 +1,203 @@ +-- tolua: array class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1999 +-- $Id: array.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Array class +-- Represents a extern array variable or a public member of a class. +-- Stores all fields present in a declaration. +classArray = { + _base = classDeclaration, +} + +settag(classArray,tolua_tag) + +-- Print method +function classArray:print (ident,close) + print(ident.."Array{") + print(ident.." mod = '"..self.mod.."',") + print(ident.." type = '"..self.type.."',") + print(ident.." ptr = '"..self.ptr.."',") + print(ident.." name = '"..self.name.."',") + print(ident.." def = '"..self.def.."',") + print(ident.." dim = '"..self.dim.."',") + print(ident.." ret = '"..self.ret.."',") + print(ident.."}"..close) +end + +-- get variable value +function classArray:getvalue (class,static) + if class and static then + return class..'::'..self.name..'[toluaI_index]' + elseif class then + return 'self->'..self.name..'[toluaI_index]' + else + return self.name..'[toluaI_index]' + end +end + +-- Write binding functions +function classArray:supcode () + local class = self:inclass() + + -- get function ------------------------------------------------ + if class then + output("/* get function:",self.name," of class ",class," */") + else + output("/* get function:",self.name," */") + end + self.cgetname = self:cfuncname("toluaI_get") + output("static int",self.cgetname,"(lua_State* tolua_S)") + output("{") + + -- declare index + output(' int toluaI_index;') + + -- declare self, if the case + local _,_,static = strfind(self.mod,'^%s*(static)') + if class and static==nil then + output(' ',class,'*','self;') + output(' lua_pushstring(tolua_S,".self");') + output(' lua_rawget(tolua_S,1);') + output(' self = ') + output('(',class,'*) ') + output('lua_touserdata(tolua_S,-1);') + elseif static then + _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)') + end + + -- check index + output(' if (!tolua_istype(tolua_S,2,LUA_TNUMBER,0))') + output(' tolua_error(tolua_S,"invalid type in array indexing.");') + output(' toluaI_index = (int)tolua_getnumber(tolua_S,2,0)-1;') + output(' if (toluaI_index<0 || toluaI_index>='..self.dim..')') + output(' tolua_error(tolua_S,"array indexing out of range.");') + + -- return value + local t,ct = isbasic(self.type) + if t then + output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static)..');') + else + if self.ptr == '&' or self.ptr == '' then + output(' tolua_pushusertype(tolua_S,(void*)&'..self:getvalue(class,static)..',',self.tag,');') + else + output(' tolua_pushusertype(tolua_S,(void*)'..self:getvalue(class,static)..',',self.tag,');') + end + end + output(' return 1;') + output('}') + output('\n') + + -- set function ------------------------------------------------ + if not strfind(self.mod,'const') then + if class then + output("/* set function:",self.name," of class ",class," */") + else + output("/* set function:",self.name," */") + end + self.csetname = self:cfuncname("toluaI_set") + output("static int",self.csetname,"(lua_State* tolua_S)") + output("{") + + -- declare index + output(' int toluaI_index;') + + -- declare self, if the case + local _,_,static = strfind(self.mod,'^%s*(static)') + if class and static==nil then + output(' ',class,'*','self;') + output(' lua_pushstring(tolua_S,".self");') + output(' lua_rawget(tolua_S,1);') + output(' self = ') + output('(',class,'*) ') + output('lua_touserdata(tolua_S,-1);') + elseif static then + _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)') + end + + -- check index + output(' if (!tolua_istype(tolua_S,2,LUA_TNUMBER,0))') + output(' tolua_error(tolua_S,"invalid type in array indexing.");') + output(' toluaI_index = (int)tolua_getnumber(tolua_S,2,0)-1;') + output(' if (toluaI_index<0 || toluaI_index>='..self.dim..')') + output(' tolua_error(tolua_S,"array indexing out of range.");') + + -- assign value + local ptr = '' + if self.ptr~='' then ptr = '*' end + output(' ') + if class and static then + output(class..'::'..self.name..'[toluaI_index]') + elseif class then + output('self->'..self.name..'[toluaI_index]') + else + output(self.name..'[toluaI_index]') + end + local t = isbasic(self.type) + output(' = ') + if not t and ptr=='' then output('*') end + output('((',self.mod,self.type) + if not t then + output('*') + end + output(') ') + local def = 0 + if self.def ~= '' then def = self.def end + if t then + output('tolua_get'..t,'(tolua_S,3,',def,'));') + else + output('tolua_getusertype(tolua_S,3,',def,'));') + end + output(' return 0;') + output('}') + output('\n') + end + +end + +function classArray:register () + local parent = self:inclass() or self:inmodule() + if parent then + if self.csetname then + output(' tolua_tablearray(tolua_S,"'..parent..'","'..self.lname..'",'..self.cgetname..','..self.csetname..');') + else + output(' tolua_tablearray(tolua_S,"'..parent..'","'..self.lname..'",'..self.cgetname..',NULL);') + end + else + if self.csetname then + output(' tolua_globalarray(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');') + else + output(' tolua_globalarray(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);') + end + end +end + +function classArray:unregister () + if self:inclass()==nil and self:inmodule()==nil then + output(' lua_pushnil(tolua_S); lua_setglobal(tolua_S,"'..self.lname..'");') + end +end + + +-- Internal constructor +function _Array (t) + t._base = classArray + settag(t,tolua_tag) + append(t) + return t +end + +-- Constructor +-- Expects a string representing the variable declaration. +function Array (s) + return _Array (Declaration(s,'var')) +end + + diff --git a/src/lua/basic.lua b/src/lua/basic.lua new file mode 100644 index 00000000..2bac463f --- /dev/null +++ b/src/lua/basic.lua @@ -0,0 +1,190 @@ +-- tolua: basic utility functions +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: basic.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Basic C types and their corresponding Lua types +-- All occurrences of "char*" will be replaced by "_cstring", +-- and all occurrences of "void*" will be replaced by "_userdata" +_basic = { + ['void'] = '', + ['char'] = 'number', + ['int'] = 'number', + ['short'] = 'number', + ['long'] = 'number', + ['_cstring'] = 'string', + ['_userdata'] = 'userdata', + ['char*'] = 'string', + ['void*'] = 'userdata', + ['bool'] = 'bool', + ['LUA_VALUE'] = 'value', + ['byte'] = 'number', + ['s16b'] = 'number', + ['u16b'] = 'number', + ['s32b'] = 'number', + ['u32b'] = 'number', +} + +_basic_tag = { + ['void'] = '', + ['char'] = 'LUA_TNUMBER', + ['int'] = 'LUA_TNUMBER', + ['short'] = 'LUA_TNUMBER', + ['long'] = 'LUA_TNUMBER', + ['_cstring'] = 'LUA_TSTRING', + ['_userdata'] = 'LUA_TUSERDATA', + ['char*'] = 'LUA_TSTRING', + ['void*'] = 'LUA_TUSERDATA', + ['bool'] = 'tolua_tag(tolua_S,"bool")', + ['byte'] = 'LUA_TNUMBER', + ['s16b'] = 'LUA_TNUMBER', + ['u16b'] = 'LUA_TNUMBER', + ['s32b'] = 'LUA_TNUMBER', + ['u32b'] = 'LUA_TNUMBER', +} + +_basic_ctype = { + number = "long", + string = "const char*", + userdata = "void*", + bool = "int", +} + +-- List of user defined types +-- Each type corresponds to a variable name that stores its tag value. +_usertype = {} + +-- Tag method to provide inheritance +function tolua_index (t,f) + if f == '_base' then -- to avoid loop + return tolua_old_index(t,f) + else + return t._base[f] + end +end + +tolua_tag = newtag() +tolua_old_index = settagmethod(tolua_tag,"index",tolua_index) + +-- Error handler +function tolua_error (s) + local out = _OUTPUT + _OUTPUT = _STDERR + if strsub(s,1,1) == '#' then + write("\n** tolua: "..strsub(s,2)..".\n\n") + else + write("\n** tolua internal error: "..s..".\n\n") + return + end + + if _curr_code then + local _,_,s = strfind(_curr_code,"^%s*(.-\n)") -- extract first line + if s==nil then s = _curr_code end + s = gsub(s,"_userdata","void*") -- return with 'void*' + s = gsub(s,"_cstring","char*") -- return with 'char*' + write("Code being processed:\n"..s.."\n") + end + _OUTPUT = out +end + + +_ERRORMESSAGE = tolua_error + +-- register an user defined type +function regtype (t) + if not istype(t) then + _usertype[t] = t + end + return t +end + +-- return tag name +function tagvar(type,const) + if type == '' or type == 'void' then + return type,0 + else + local m,t = findtypedef(type) + if isbasic(t) then + return t, _basic_tag[t] + end + if strfind(m,'const') then const = 'const' end + regtype(t) + if const and const ~= '' then + t = 'const '..t + end + return t,'tolua_tag(tolua_S,"'..t..'")' + end +end + +-- check if basic type +function isbasic (type) + local m,t = findtypedef(type) + local b = _basic[t] + if b then + return b,_basic_ctype[b] + end + return nil +end + +-- check if type +function istype (t) + return _basic[t] or _usertype[t] or istypedef(t) +end + + +-- split string using a token +function split (s,t) + local l = {n=0} + local f = function (s) + %l.n = %l.n + 1 + %l[%l.n] = s + end + local p = "%s*(.-)%s*"..t.."%s*" + s = gsub(s,"^%s+","") + s = gsub(s,"%s+$","") + s = gsub(s,p,f) + l.n = l.n + 1 + l[l.n] = gsub(s,"(%s%s*)$","") + return l +end + + +-- concatenate strings of a table +function concat (t,f,l) + local s = '' + local i=f + while i<=l do + s = s..t[i] + i = i+1 + if i <= l then s = s..' ' end + end + return s +end + +-- output line +function output (...) + local i=1 + while i<=arg.n do + if _cont and not strfind(_cont,'[%(,"]') and + strfind(arg[i],"^[%a_~]") then + write(' ') + end + write(arg[i]) + if arg[i] ~= '' then + _cont = strsub(arg[i],-1,-1) + end + i = i+1 + end + if strfind(arg[arg.n],"[%/%)%;%{%}]$") then + _cont=nil write('\n') + end +end + + diff --git a/src/lua/class.lua b/src/lua/class.lua new file mode 100644 index 00000000..01385178 --- /dev/null +++ b/src/lua/class.lua @@ -0,0 +1,85 @@ +-- tolua: class class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: class.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Class class +-- Represents a class definition. +-- Stores the following fields: +-- name = class name +-- base = class base, if any (only single inheritance is supported) +-- {i} = list of members +classClass = { + _base = classContainer, + type = 'class', + name = '', + base = '', +} +settag(classClass,tolua_tag) + + +-- register class +function classClass:register () + output(' tolua_cclass(tolua_S,"'..self.name..'","'..self.base..'");') + local i=1 + while self[i] do + self[i]:register() + i = i+1 + end +end + +-- unregister class +function classClass:unregister () + output(' lua_pushnil(tolua_S); lua_setglobal(tolua_S,"'..self.name..'");') +end + +-- output tags +function classClass:decltag () + self.itype,self.tag = tagvar(self.name); + self.citype,self.ctag = tagvar(self.name,'const'); + local i=1 + while self[i] do + self[i]:decltag() + i = i+1 + end +end + + +-- Print method +function classClass:print (ident,close) + print(ident.."Class{") + print(ident.." name = '"..self.name.."',") + print(ident.." base = '"..self.base.."';") + local i=1 + while self[i] do + self[i]:print(ident.." ",",") + i = i+1 + end + print(ident.."}"..close) +end + +-- Internal constructor +function _Class (t) + t._base = classClass + settag(t,tolua_tag) + append(t) + return t +end + +-- Constructor +-- Expects the name, the base and the body of the class. +function Class (n,p,b) + local c = _Class(_Container{name=n, base=p}) + push(c) + c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces + pop() +end + + diff --git a/src/lua/clean.lua b/src/lua/clean.lua new file mode 100644 index 00000000..ba08d534 --- /dev/null +++ b/src/lua/clean.lua @@ -0,0 +1,74 @@ +-- mark up comments and strings +STR1 = "\001" +STR2 = "\002" +STR3 = "\003" +STR4 = "\004" +REM = "\005" +ANY = "([\001-\005])" +ESC1 = "\006" +ESC2 = "\007" + +MASK = { -- the substitution order is important + {ESC1, "\\'"}, + {ESC2, '\\"'}, + {STR1, "'"}, + {STR2, '"'}, + {STR3, "%[%["}, + {STR4, "%]%]"}, + {REM , "%-%-"}, +} + +function mask (s) + for i = 1,getn(MASK) do + s = gsub(s,MASK[i][2],MASK[i][1]) + end + return s +end + +function unmask (s) + for i = 1,getn(MASK) do + s = gsub(s,MASK[i][1],MASK[i][2]) + end + return s +end + +function clean (s) + -- check for compilation error + local code = "return function () " .. s .. " end" + if not dostring(code) then + return nil + end + + local S = "" -- saved string + + s = mask(s) + + -- remove blanks and comments + while 1 do + local b,e,d = strfind(s,ANY) + if b then + S = S..strsub(s,1,b-1) + s = strsub(s,b+1) + if d==STR1 or d==STR2 then + e = strfind(s,d) + S = S ..d..strsub(s,1,e) + s = strsub(s,e+1) + elseif d==STR3 then + e = strfind(s,STR4) + S = S..d..strsub(s,1,e) + s = strsub(s,e+1) + elseif d==REM then + s = gsub(s,"[^\n]*(\n?)","%1",1) + end + else + S = S..s + break + end + end + -- eliminate unecessary spaces + S = gsub(S,"[ \t]+"," ") + S = gsub(S,"[ \t]*\n[ \t]*","\n") + S = unmask(S) + return S +end + diff --git a/src/lua/code.lua b/src/lua/code.lua new file mode 100644 index 00000000..08f38ad2 --- /dev/null +++ b/src/lua/code.lua @@ -0,0 +1,73 @@ +-- tolua: code class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1999 +-- $Id: code.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Code class +-- Represents Lua code to be compiled and included +-- in the initialization function. +-- The following fields are stored: +-- text = text code +classCode = { + text = '', + _base = classFeature, +} +settag(classCode,tolua_tag) + +-- register code +function classCode:register () + -- clean Lua code + local s = clean(self.text) + if not s then + error("parser error in embedded code") + end + + -- convert to C + output('\n { /* begin embedded lua code */\n') + output(' static unsigned char B[] = {\n ') + local t={n=0} + local b = gsub(s,'(.)',function (c) + local e = '' + %t.n=%t.n+1 if %t.n==15 then %t.n=0 e='\n ' end + return format('%3u,%s',strbyte(c),e) + end + ) + output(b..strbyte(" ")) + output('\n };\n') + output(' lua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code");') + output(' } /* end of embedded lua code */\n\n') +end + + +-- Print method +function classCode:print (ident,close) + print(ident.."Code{") + print(ident.." text = [["..self.text.."]],") + print(ident.."}"..close) +end + + +-- Internal constructor +function _Code (t) + t._base = classCode + settag(t,tolua_tag) + append(t) + return t +end + +-- Constructor +-- Expects a string representing the code text +function Code (l) + return _Code { + text = l + } +end + + diff --git a/src/lua/container.lua b/src/lua/container.lua new file mode 100644 index 00000000..cbbf11c1 --- /dev/null +++ b/src/lua/container.lua @@ -0,0 +1,311 @@ +-- tolua: container abstract class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: container.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Container class +-- Represents a container of features to be bound +-- to lua. +classContainer = +{ + curr = nil, + _base = classFeature, +} +settag(classContainer,tolua_tag) + +-- output tags +function classContainer:decltag () + push(self) + local i=1 + while self[i] do + self[i]:decltag() + i = i+1 + end + pop() +end + + +-- write support code +function classContainer:supcode () + push(self) + local i=1 + while self[i] do + self[i]:supcode() + i = i+1 + end + pop() +end + + +-- Internal container constructor +function _Container (self) + self._base = classContainer + settag(self,tolua_tag) + self.n = 0 + self.typedefs = {n=0} + self.lnames = {} + return self +end + +-- push container +function push (t) + classContainer.curr = t +end + +-- pop container +function pop () + classContainer.curr = classContainer.curr.parent +end + +-- append to current container +function append (t) + return classContainer.curr:append(t) +end + +-- append typedef to current container +function appendtypedef (t) + return classContainer.curr:appendtypedef(t) +end + +-- substitute typedef +function findtypedef (type) + return classContainer.curr:findtypedef(type) +end + +-- check if is typedef +function istypedef (type) + return classContainer.curr:istypedef(type) +end + +-- append feature to container +function classContainer:append (t) + self.n = self.n + 1 + self[self.n] = t + t.parent = self +end + +-- append typedef +function classContainer:appendtypedef (t) + self.typedefs.n = self.typedefs.n + 1 + self.typedefs[self.typedefs.n] = t +end + +-- determine lua function name overload +function classContainer:overload (lname) + if not self.lnames[lname] then + self.lnames[lname] = 0 + else + self.lnames[lname] = self.lnames[lname] + 1 + end + return format("%02d",self.lnames[lname]) +end + +function classContainer:findtypedef (type) + local env = self + while env do + if env.typedefs then + local i=1 + while env.typedefs[i] do + if env.typedefs[i].utype == type then + local mod1,type1 = env.typedefs[i].mod,env.typedefs[i].type + local mod2,type2 = findtypedef(type1) + return mod2..' '..mod1,type2 + end + i = i+1 + end + end + env = env.parent + end + return '',type +end + +function classContainer:istypedef (type) + local env = self + while env do + if env.typedefs then + local i=1 + while env.typedefs[i] do + if env.typedefs[i].utype == type then + return 1 + end + i = i+1 + end + end + env = env.parent + end + return nil +end + +-- parse chunk +function classContainer:doparse (s) + + -- try module + do + local b,e,name,body = strfind(s,"^%s*module%s%s*([_%w][_%w]*)%s*(%b{})%s*") + if b then + _curr_code = strsub(s,b,e) + Module(name,body) + return strsub(s,e+1) + end + end + + -- try define + do + local b,e,name = strfind(s,"^%s*#define%s%s*([^%s]*)[^\n]*\n%s*") + if b then + _curr_code = strsub(s,b,e) + Define(name) + return strsub(s,e+1) + end + end + + -- try enumerates + do + local b,e,body = strfind(s,"^%s*enum[^{]*(%b{})%s*;?%s*") + if b then + _curr_code = strsub(s,b,e) + Enumerate(body) + return strsub(s,e+1) + end + end + + do + local b,e,body,name = strfind(s,"^%s*typedef%s%s*enum[^{]*(%b{})%s*([%w_][^%s]*)%s*;%s*") + if b then + _curr_code = strsub(s,b,e) + Enumerate(body) + Typedef("int "..name) + return strsub(s,e+1) + end + end + + -- try operator + do + local b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&]*operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)%s*;%s*") + if b then + _curr_code = strsub(s,b,e) + Operator(decl,kind,arg,const) + return strsub(s,e+1) + end + end + + -- try function + do + local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&]*[_%w])%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*") + if not b then + -- try a single letter function name + b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?)%s*;%s*") + end + if b then + _curr_code = strsub(s,b,e) + Function(decl,arg,const) + return strsub(s,e+1) + end + end + + -- try inline function + do + local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&]*[_%w])%s*(%b())%s*(c?o?n?s?t?)%s*%b{}%s*") + if not b then + -- try a single letter function name + b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?)%s*%b{}%s*") + end + if b then + _curr_code = strsub(s,b,e) + Function(decl,arg,const) + return strsub(s,e+1) + end + end + + -- try class + do + local b,e,name,base,body = strfind(s,"^%s*class%s*([_%w][_%w]*)%s*(.-)%s*(%b{})%s*;%s*") + if not b then + b,e,name,base,body = strfind(s,"^%s*struct%s*([_%w][_%w]*)%s*(.-)%s*(%b{})%s*;%s*") + if not b then + base = '' + b,e,body,name = strfind(s,"^%s*typedef%s%s*struct%s%s*[_%w]*%s*(%b{})%s*([_%w][_%w]*)%s*;%s*") + end + end + if b then + if base ~= '' then + local b,e + b,e,base = strfind(base,".-([_%w][_%w]*)$") + end + _curr_code = strsub(s,b,e) + Class(name,base,body) + return strsub(s,e+1) + end + end + + -- try typedef + do + local b,e,types = strfind(s,"^%s*typedef%s%s*(.-)%s*;%s*") + if b then + _curr_code = strsub(s,b,e) + Typedef(types) + return strsub(s,e+1) + end + end + + -- try variable + do + local b,e,decl = strfind(s,"^%s*([_%w][_@%s%w%d%*&]*[_%w%d])%s*;%s*") + if b then + _curr_code = strsub(s,b,e) + Variable(decl) + return strsub(s,e+1) + end + end + + -- try array + do + local b,e,decl = strfind(s,"^%s*([_%w][][_@%s%w%d%*&%-%>]*[]_%w%d])%s*;%s*") + if b then + _curr_code = strsub(s,b,e) + Array(decl) + return strsub(s,e+1) + end + end + + -- try code + do + local b,e,code = strfind(s,"^%s*(%b\1\2)") + if b then + Code(strsub(code,2,-2)) + return strsub(s,e+1) + end + end + + -- try verbatim + do + local b,e,line = strfind(s,"^%s*%$(.-\n)") + if b then + Verbatim(line) + return strsub(s,e+1) + end + end + + -- no matching + if gsub(s,"%s%s*","") ~= "" then + _curr_code = s + error("#parse error") + else + return "" + end +end + +function classContainer:parse (s) + while s ~= '' do + s = self:doparse(s) + end +end + + diff --git a/src/lua/declaration.lua b/src/lua/declaration.lua new file mode 100644 index 00000000..e4d5c688 --- /dev/null +++ b/src/lua/declaration.lua @@ -0,0 +1,399 @@ +-- tolua: declaration class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: declaration.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Declaration class +-- Represents variable, function, or argument declaration. +-- Stores the following fields: +-- mod = type modifiers +-- type = type +-- ptr = "*" or "&", if representing a pointer or a reference +-- name = name +-- dim = dimension, if a vector +-- def = default value, if any (only for arguments) +-- ret = "*" or "&", if value is to be returned (only for arguments) +classDeclaration = { + _base = classFeature, + mod = '', + type = '', + ptr = '', + name = '', + dim = '', + ret = '', + def = '' +} +settag(classDeclaration,tolua_tag) + +-- Create an unique variable name +function create_varname () + if not _varnumber then _varnumber = 0 end + _varnumber = _varnumber + 1 + return "tolua_var_".._varnumber +end + +-- Check declaration name +-- It also identifies default values +function classDeclaration:checkname () + + if strsub(self.name,1,1) == '[' and not istype(self.type) then + self.name = self.type..self.name + local m = split(self.mod,'%s%s*') + self.type = m[m.n] + self.mod = concat(m,1,m.n-1) + end + + local t = split(self.name,'=') + if t.n==2 then + self.name = t[1] + self.def = t[t.n] + end + + local b,e,d = strfind(self.name,"%[(.-)%]") + if b then + self.name = strsub(self.name,1,b-1) + self.dim = d + end + + + if self.type ~= '' and self.type ~= 'void' and self.name == '' then + self.name = create_varname() + elseif self.kind=='var' then + if self.type=='' and self.name~='' then + self.type = self.type..self.name + self.name = create_varname() + elseif istype(self.name) then + if self.type=='' then self.type = self.name + else self.type = self.type..' '..self.name end + self.name = create_varname() + end + end + +end + +-- Check declaration type +-- Substitutes typedef's. +function classDeclaration:checktype () + + -- check if there is a pointer to basic type + if isbasic(self.type) and self.ptr~='' then + self.ret = self.ptr + self.ptr = nil + end + + -- check if there is array to be returned + if self.dim~='' and self.ret~='' then + error('#invalid parameter: cannot return an array of values') + end + + -- register type + if self.type~='' then + regtype(self.type) + end + + -- restore 'void*' and 'string*' + if self.type == '_userdata' then self.type = 'void*' + elseif self.type == '_cstring' then self.type = 'char*' + end + +-- +-- -- if returning value, automatically set default value +-- if self.ret ~= '' and self.def == '' then +-- self.def = '0' +-- end +-- + +end + +-- Print method +function classDeclaration:print (ident,close) + print(ident.."Declaration{") + print(ident.." mod = '"..self.mod.."',") + print(ident.." type = '"..self.type.."',") + print(ident.." ptr = '"..self.ptr.."',") + print(ident.." name = '"..self.name.."',") + print(ident.." dim = '"..self.dim.."',") + print(ident.." def = '"..self.def.."',") + print(ident.." ret = '"..self.ret.."',") + print(ident.."}"..close) +end + +-- declare tag +function classDeclaration:decltag () + self.itype, self.tag = tagvar(self.type,strfind(self.mod,'const')) +end + + +-- output type checking +function classDeclaration:outchecktype (narg) + local tag, def + if self.dim ~= '' then + tag = 'LUA_TTABLE' + def = 0 + else + tag = self.tag + def = self.def~='' or 0 + end + return 'tolua_istype(tolua_S,'..narg..','..tag..','..def..')' +end + +-- Declare variable +function classDeclaration:declare (narg) + local ptr = '' + if self.ptr~='' then ptr = '*' end + output(" ",self.mod,self.type,ptr) + if self.dim ~= '' and tonumber(self.dim)==nil then + output('*') + end + output(self.name) + if self.dim ~= '' then + if tonumber(self.dim)~=nil then + output('[',self.dim,'];') + else + output(' = (',self.mod,self.type,ptr,'*)', + 'malloc(',self.dim,'*sizeof(',self.type,ptr,'));') + end + else + local t = isbasic(self.type) + output(' = ') + if not t and ptr=='' then output('*') end + output('((',self.mod,self.type) + if not t then + output('*') + end + output(') ') + local def = 0 + if self.def ~= '' then def = self.def end + if t then + output('tolua_get'..t,'(tolua_S,',narg,',',def,'));') + else + output('tolua_getusertype(tolua_S,',narg,',',def,'));') + end + end +end + +-- Get parameter value +function classDeclaration:getarray (narg) + if self.dim ~= '' then + output(' {') + local def = self.def~='' or 0 + output(' if (!tolua_arrayistype(tolua_S,',narg,',',self.tag,',',self.dim,',',def,'))') + output(' goto tolua_lerror;') + output(' else\n') + output(' {') + output(' int i;') + output(' for(i=0; i<'..self.dim..';i++)') + local t = isbasic(self.type) + local ptr = '' + if self.ptr~='' then ptr = '*' end + output(' ',self.name..'[i] = ') + if not t and ptr=='' then output('*') end + output('((',self.mod,self.type) + if not t then + output('*') + end + output(') ') + local def = 0 + if self.def ~= '' then def = self.def end + if t then + output('tolua_getfield'..t..'(tolua_S,',narg,',i+1,',def,'));') + else + output('tolua_getfieldusertype(tolua_S,',narg,',i+1,',def,'));') + end + output(' }') + output(' }') + end +end + +-- Get parameter value +function classDeclaration:setarray (narg) + if self.dim ~= '' then + output(' {') + output(' int i;') + output(' for(i=0; i<'..self.dim..';i++)') + local t,ct = isbasic(self.type) + if t then + output(' tolua_pushfield'..t..'(tolua_S,',narg,',i+1,(',ct,')',self.name,'[i]);') + else + if self.ptr == '' then + output(' {') + output('#ifdef __cplusplus\n') + output(' void* toluaI_clone = new',self.type,'(',self.name,'[i]);') + output('#else\n') + output(' void* toluaI_clone = tolua_copy(tolua_S,(void*)&',self.name,'[i],sizeof(',self.type,'));') + output('#endif\n') + output(' tolua_pushfieldusertype(tolua_S,',narg,',i+1,tolua_doclone(tolua_S,toluaI_clone,',self.tag,'),',self.tag,');') + output(' }') + + --output(' tolua_pushfieldclone(tolua_S,',narg,',i+1,(void*)&',self.name,'[i],sizeof(',self.type,'),',self.tag,');') + else + output(' tolua_pushfieldusertype(tolua_S,',narg,',i+1,(void*)',self.name,'[i],',self.tag,');') + end + end + output(' }') + end +end + +-- Free dynamically allocated array +function classDeclaration:freearray () + if self.dim ~= '' and tonumber(self.dim)==nil then + output(' free(',self.name,');') + end +end + +-- Pass parameter +function classDeclaration:passpar () + if self.ptr=='&' then + output('*'..self.name) + elseif self.ret=='*' then + output('&'..self.name) + else + output(self.name) + end +end + +-- Return parameter value +function classDeclaration:retvalue () + if self.ret ~= '' then + local t,ct = isbasic(self.type) + if t then + output(' tolua_push'..t..'(tolua_S,(',ct,')'..self.name..');') + else + output(' tolua_pushusertype(tolua_S,(void*)'..self.name..',',self.tag,');') + end + return 1 + end + return 0 +end + +-- Internal constructor +function _Declaration (t) + if t.name and t.name~='' then + local n = split(t.name,'@') + t.name = n[1] + t.lname = gsub(n[2] or n[1],"%[.-%]","") + end + t._base = classDeclaration + settag(t,tolua_tag) + t:checkname() + t:checktype() + return t +end + +-- Constructor +-- Expects the string declaration. +-- The kind of declaration can be "var" or "func". +function Declaration (s,kind) + -- eliminate spaces if default value is provided + s = gsub(s,"%s*=%s*","=") + + if kind == "var" then + -- check the form: void + if s == '' or s == 'void' then + return _Declaration{type = 'void', kind = kind} + end + end + + -- check the form: mod type*& name + local t = split(s,'%*%s*&') + if t.n == 2 then + if kind == 'func' then + error("#invalid function return type: "..s) + end + local m = split(t[1],'%s%s*') + return _Declaration{ + name = t[2], + ptr = '*', + ret = '&', + type = m[m.n], + mod = concat(m,1,m.n-1), + kind = kind + } + end + + -- check the form: mod type** name + t = split(s,'%*%s*%*') + if t.n == 2 then + if kind == 'func' then + error("#invalid function return type: "..s) + end + local m = split(t[1],'%s%s*') + return _Declaration{ + name = t[2], + ptr = '*', + ret = '*', + type = m[m.n], + mod = concat(m,1,m.n-1), + kind = kind + } + end + + -- check the form: mod type& name + t = split(s,'&') + if t.n == 2 then + local m = split(t[1],'%s%s*') + return _Declaration{ + name = t[2], + ptr = '&', + type = m[m.n], + mod = concat(m,1,m.n-1) , + kind = kind + } + end + + -- check the form: mod type* name + local s1 = gsub(s,"(%b\[\])",function (n) return gsub(n,'%*','\1') end) + t = split(s1,'%*') + if t.n == 2 then + t[2] = gsub(t[2],'\1','%*') -- restore * in dimension expression + local m = split(t[1],'%s%s*') + return _Declaration{ + name = t[2], + ptr = '*', + type = m[m.n], + mod = concat(m,1,m.n-1) , + kind = kind + } + end + + if kind == 'var' then + -- check the form: mod type name + t = split(s,'%s%s*') + local v + if istype(t[t.n]) then v = '' else v = t[t.n]; t.n = t.n-1 end + return _Declaration{ + name = v, + type = t[t.n], + mod = concat(t,1,t.n-1), + kind = kind + } + + else -- kind == "func" + + -- check the form: mod type name + t = split(s,'%s%s*') + local v = t[t.n] -- last word is the function name + local tp,md + if t.n>1 then + tp = t[t.n-1] + md = concat(t,1,t.n-2) + end + return _Declaration{ + name = v, + type = tp, + mod = md, + kind = kind + } + end + +end + + + diff --git a/src/lua/define.lua b/src/lua/define.lua new file mode 100644 index 00000000..db64db50 --- /dev/null +++ b/src/lua/define.lua @@ -0,0 +1,72 @@ +-- tolua: define class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: define.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Define class +-- Represents a numeric const definition +-- The following filds are stored: +-- name = constant name +classDefine = { + name = '', + _base = classFeature, +} +settag(classDefine,tolua_tag) + +-- register define +function classDefine:register () + local p = self:inmodule() + if p then + output(' tolua_constant(tolua_S,"'..p..'","'..self.lname..'",'..self.name..');') + else + output(' tolua_constant(tolua_S,NULL,"'..self.lname..'",'..self.name..');') + end +end + +-- unregister define +function classDefine:unregister () + if not self:inmodule() then + output(' lua_pushnil(tolua_S); lua_setglobal(tolua_S,"'..self.lname..'");') + end +end + +-- Print method +function classDefine:print (ident,close) + print(ident.."Define{") + print(ident.." name = '"..self.name.."',") + print(ident.." lname = '"..self.lname.."',") + print(ident.."}"..close) +end + + +-- Internal constructor +function _Define (t) + t._base = classDefine + settag(t,tolua_tag) + + if t.name == '' then + error("#invalid define") + end + + append(t) + return t +end + +-- Constructor +-- Expects a string representing the constant name +function Define (n) + local t = split(n,'@') + return _Define { + name = t[1], + lname = t[2] or t[1] + } +end + + diff --git a/src/lua/doit.lua b/src/lua/doit.lua new file mode 100644 index 00000000..aa184d62 --- /dev/null +++ b/src/lua/doit.lua @@ -0,0 +1,73 @@ +-- Generate binding code +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: doit.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- open input file, if any +if flags.f then + local st, msg = readfrom(flags.f) + if not st then + error('#'..msg) + end +end + +-- define package name, if not provided +if not flags.n then + if flags.f then + flags.n = gsub(flags.f,"%..*","") + else + error("#no package name nor input file provided") + end +end + +local p = Package(flags.n) + +if flags.f then + readfrom() +end + +if flags.p then + return -- only parse +end + +if flags.o then + local st,msg = writeto(flags.o) + if not st then + error('#'..msg) + end +end + +if flags.P then + p:print() +else + p:decltag() + p:preamble() + p:supcode() + p:register() + p:unregister() +end + +if flags.o then + writeto() +end + +-- write header file +if not flags.P then + if flags.H then + local st,msg = writeto(flags.H) + if not st then + error('#'..msg) + end + p:header() + writeto() + end +end + diff --git a/src/lua/enumerate.lua b/src/lua/enumerate.lua new file mode 100644 index 00000000..6b2b7466 --- /dev/null +++ b/src/lua/enumerate.lua @@ -0,0 +1,93 @@ +-- tolua: enumerate class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: enumerate.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Enumerate class +-- Represents enumeration +-- The following fields are stored: +-- {i} = list of constant names +classEnumerate = { + _base = classFeature, +} +settag(classEnumerate,tolua_tag) + +-- register enumeration +function classEnumerate:register () + local p = self:inclass() or self:inmodule() + local i=1 + while self[i] do + if p then + if self:inclass() then + output(' tolua_constant(tolua_S,"'..p..'","'..self.lnames[i]..'",'..p..'::'..self[i]..');') + else + output(' tolua_constant(tolua_S,"'..p..'","'..self.lnames[i]..'",'..self[i]..');') + end + else + output(' tolua_constant(tolua_S,NULL,"'..self.lnames[i]..'",'..self[i]..');') + end + i = i+1 + end +end +-- register enumeration +function classEnumerate:unregister () + if self:inclass()==nil and self:inmodule()==nil then + local i=1 + while self[i] do + output(' lua_pushnil(tolua_S); lua_setglobal(tolua_S,"'..self.lnames[i]..'");') + i = i+1 + end + end +end + +-- Print method +function classEnumerate:print (ident,close) + print(ident.."Enumerate{") + local i=1 + while self[i] do + print(ident.." '"..self[i].."'("..self.lnames[i].."),") + i = i+1 + end + print(ident.."}"..close) +end + +-- Internal constructor +function _Enumerate (t) + t._base = classEnumerate + settag(t,tolua_tag) + append(t) + return t +end + +-- Constructor +-- Expects a string representing the enumerate body +function Enumerate (b) + local t = split(strsub(b,2,-2),',') -- eliminate braces + local i = 1 + local e = {n=0} + while t[i] do + local tt = split(t[i],'=') -- discard initial value + e.n = e.n + 1 + e[e.n] = tt[1] + i = i+1 + end + -- set lua names + i = 1 + e.lnames = {} + while e[i] do + local t = split(e[i],'@') + e[i] = t[1] + e.lnames[i] = t[2] or t[1] + i = i+1 + end + return _Enumerate(e) +end + + diff --git a/src/lua/feature.lua b/src/lua/feature.lua new file mode 100644 index 00000000..4a4379e1 --- /dev/null +++ b/src/lua/feature.lua @@ -0,0 +1,72 @@ +-- tolua: abstract feature class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: feature.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Feature class +-- Represents the base class of all mapped feature. +classFeature = { +} + +-- write support code +function classFeature:supcode () +end + +-- output tag +function classFeature:decltag () +end + +-- register feature +function classFeature:register () +end + +-- unregister feature +function classFeature:unregister () +end + +-- translate verbatim +function classFeature:preamble () +end + +-- check if feature is inside a class definition +-- it returns the feature class name or nil. +function classFeature:inclass () + if self.parent and self.parent.type == 'class' then + return self.parent.name + else + return nil + end +end + +-- check if feature is inside a module +-- it returns the feature module name or nil. +function classFeature:inmodule () + if self.parent and self.parent.type == 'module' then + return self.parent.name + else + return nil + end +end + +-- return C binding function name based on name +-- the client specifies a prefix +-- return C binding function name +-- the client specifies a prefix +function classFeature:cfuncname (n) + if self.parent then + n = self.parent:cfuncname(n) + end + if self.lname then + return n..'_'..self.lname + else + return n..'_'..self.name + end +end + diff --git a/src/lua/function.lua b/src/lua/function.lua new file mode 100644 index 00000000..b87e3488 --- /dev/null +++ b/src/lua/function.lua @@ -0,0 +1,317 @@ +-- tolua: function class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: function.lua,v 1.2 2001/11/26 23:00:23 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + + +-- Function class +-- Represents a function or a class method. +-- The following fields are stored: +-- mod = type modifiers +-- type = type +-- ptr = "*" or "&", if representing a pointer or a reference +-- name = name +-- args = list of argument declarations +-- const = if it is a method receiving a const "this". +classFunction = { + mod = '', + type = '', + ptr = '', + name = '', + args = {n=0}, + const = '', + _base = classFeature, +} +settag(classFunction,tolua_tag) + +-- declare tags +function classFunction:decltag () + self.itype,self.tag = tagvar(self.type,strfind(self.mod,'const')) + local i=1 + while self.args[i] do + self.args[i]:decltag() + i = i+1 + end +end + + +-- Write binding function +-- Outputs C/C++ binding function. +function classFunction:supcode () + local nret = 0 -- number of returned values + local class = self:inclass() + local _,_,static = strfind(self.mod,'^%s*(static)') + + if class then + output("/* method:",self.name," of class ",class," */") + else + output("/* function:",self.name," */") + end + output("static int",self.cname,"(lua_State* tolua_S)") + output("{") + + -- check types + output(' if (\n') + -- check self + local narg + if class then narg=2 else narg=1 end + if class and self.name~='new' and static==nil then + if self.const == 'const' then + output(' !tolua_istype(tolua_S,1,',self.parent.ctag,',0) ||\n') + else + output(' !tolua_istype(tolua_S,1,',self.parent.tag,',0) ||\n') + end + end + -- check args + if self.args[1].type ~= 'void' then + local i=1 + while self.args[i] do + if isbasic(self.args[i].type) ~= 'value' then + output(' !'..self.args[i]:outchecktype(narg)..' ||\n') + end + narg = narg+1 + i = i+1 + end + end + -- check end of list + output(' !tolua_isnoobj(tolua_S,'..narg..')\n )\n goto tolua_lerror;') + + output(' else\n {') + + -- declare self, if the case + local narg + if class then narg=2 else narg=1 end + if class and self.name~='new' and static==nil then + output(' ',self.const,class,'*','self = ') + output('(',self.const,class,'*) ') + output('tolua_getusertype(tolua_S,1,0);') + elseif static then + _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)') + end + -- declare parameters + if self.args[1].type ~= 'void' then + local i=1 + while self.args[i] do + self.args[i]:declare(narg) + narg = narg+1 + i = i+1 + end + end + + -- check self + if class and self.name~='new' and static==nil then + output(' if (!self) tolua_error(tolua_S,"invalid \'self\' in function \''..self.name..'\'");'); + end + + -- get array element values + if class then narg=2 else narg=1 end + if self.args[1].type ~= 'void' then + local i=1 + while self.args[i] do + self.args[i]:getarray(narg) + narg = narg+1 + i = i+1 + end + end + + -- call function + if class and self.name=='delete' then + output(' delete self;') + elseif class and self.name == 'operator&[]' then + output(' self->operator[](',self.args[1].name,') = ',self.args[2].name,';') + else + output(' {') + if self.type ~= '' and self.type ~= 'void' then + output(' ',self.mod,self.type,self.ptr,'toluaI_ret = ') + output('(',self.mod,self.type,self.ptr,') ') + else + output(' ') + end + if class and self.name=='new' then + output('new',class,'(') + elseif class and static then + output(class..'::'..self.name,'(') + elseif class then + output('self->'..self.name,'(') + else + output(self.name,'(') + end + + -- write parameters + local i=1 + while self.args[i] do + self.args[i]:passpar() + i = i+1 + if self.args[i] then + output(',') + end + end + + output(');') + + -- return values + if self.type ~= '' and self.type ~= 'void' then + nret = nret + 1 + local t,ct = isbasic(self.type) + if t then + output(' tolua_push'..t..'(tolua_S,(',ct,')toluaI_ret);') + else + if self.ptr == '' then + output(' {') + output('#ifdef __cplusplus\n') + output(' void* toluaI_clone = new',self.type,'(toluaI_ret);') + output('#else\n') + output(' void* toluaI_clone = tolua_copy(tolua_S,(void*)&toluaI_ret,sizeof(',self.type,'));') + output('#endif\n') + output(' tolua_pushusertype(tolua_S,tolua_doclone(tolua_S,toluaI_clone,',self.tag,'),',self.tag,');') + output(' }') + --output(' tolua_pushclone((void*)&toluaI_ret,sizeof(',self.type,'),',self.tag,');') + elseif self.ptr == '&' then + output(' tolua_pushusertype(tolua_S,(void*)&toluaI_ret,',self.tag,');') + else + output(' tolua_pushusertype(tolua_S,(void*)toluaI_ret,',self.tag,');') + end + end + end + local i=1 + while self.args[i] do + nret = nret + self.args[i]:retvalue() + i = i+1 + end + output(' }') + + -- set array element values + if class then narg=2 else narg=1 end + if self.args[1].type ~= 'void' then + local i=1 + while self.args[i] do + self.args[i]:setarray(narg) + narg = narg+1 + i = i+1 + end + end + + -- free dynamically allocated array + if self.args[1].type ~= 'void' then + local i=1 + while self.args[i] do + self.args[i]:freearray() + i = i+1 + end + end + end + + output(' }') + output(' return '..nret..';') + + -- call overloaded function or generate error + output('tolua_lerror:\n') + local overload = strsub(self.cname,-2,-1) - 1 + if overload >= 0 then + output(' return '..strsub(self.cname,1,-3)..format("%02d",overload)..'(tolua_S);') + else + output(' tolua_error(tolua_S,"#ferror in function \''..self.lname..'\'.");') + output(' return 0;') + end + + output('}') + output('\n') +end + +-- register function +function classFunction:register () + local parent = self:inclass() or self:inmodule() + if parent then + output(' tolua_function(tolua_S,"'..parent..'","'..self.lname..'",'..self.cname..');') + else + output(' tolua_function(tolua_S,NULL,"'..self.lname..'",'..self.cname..');') + end +end + +-- unregister function +function classFunction:unregister () + if self:inclass()==nil and self:inmodule()==nil then + output(' lua_pushnil(tolua_S); lua_setglobal(tolua_S,"'..self.lname..'");') + end +end + + +-- Print method +function classFunction:print (ident,close) + print(ident.."Function{") + print(ident.." mod = '"..self.mod.."',") + print(ident.." type = '"..self.type.."',") + print(ident.." ptr = '"..self.ptr.."',") + print(ident.." name = '"..self.name.."',") + print(ident.." const = '"..self.const.."',") + print(ident.." cname = '"..self.cname.."',") + print(ident.." lname = '"..self.lname.."',") + print(ident.." args = {") + local i=1 + while self.args[i] do + self.args[i]:print(ident.." ",",") + i = i+1 + end + print(ident.." }") + print(ident.."}"..close) +end + +-- determine lua function name overload +function classFunction:overload () + return self.parent:overload(self.lname) +end + + + +-- Internal constructor +function _Function (t) + t._base = classFunction + settag(t,tolua_tag) + + if t.const ~= 'const' and t.const ~= '' then + error("#invalid 'const' specification") + end + + append(t) + if t:inclass() then + if t.name == t.parent.name then + t.name = 'new' + t.lname = 'new' + t.type = t.parent.name + t.ptr = '*' + elseif t.name == '~'..t.parent.name then + t.name = 'delete' + t.lname = 'delete' + end + end + t.cname = t:cfuncname("toluaI")..t:overload(t) + return t +end + +-- Constructor +-- Expects three strings: one representing the function declaration, +-- another representing the argument list, and the third representing +-- the "const" or empty string. +function Function (d,a,c) + local t = split(strsub(a,2,-2),',') -- eliminate braces + local i=1 + local l = {n=0} + while t[i] do + l.n = l.n+1 + l[l.n] = Declaration(t[i],'var') + i = i+1 + end + local f = Declaration(d,'func') + f.args = l + f.const = c + return _Function(f) +end + + diff --git a/src/lua/lapi.c b/src/lua/lapi.c new file mode 100644 index 00000000..b597e00a --- /dev/null +++ b/src/lua/lapi.c @@ -0,0 +1,499 @@ +/* +** $Id: lapi.c,v 1.3 2001/11/26 23:00:23 darkgod Exp $ +** Lua API +** See Copyright Notice in lua.h +*/ + + +#include <string.h> + +#include "lua.h" + +#include "lapi.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + +const char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n" + "$Authors: " LUA_AUTHORS " $"; + + + +#define Index(L,i) ((i) >= 0 ? (L->Cbase+((i)-1)) : (L->top+(i))) + +#define api_incr_top(L) incr_top + + + + +TObject *luaA_index (lua_State *L, int index) { + return Index(L, index); +} + + +static TObject *luaA_indexAcceptable (lua_State *L, int index) { + if (index == 0) { + return NULL; + } else if (index > 0) { + TObject *o = L->Cbase+(index-1); + if (o >= L->top) return NULL; + else return o; + } else { + TObject *o = L->top+index; + if(o < L->Cbase) return NULL; + else return o; + } +} + + +void luaA_pushobject (lua_State *L, const TObject *o) { + *L->top = *o; + incr_top; +} + +LUA_API int lua_stackspace (lua_State *L) { + return (L->stack_last - L->top); +} + + + +/* +** basic stack manipulation +*/ + + +LUA_API int lua_gettop (lua_State *L) { + return (L->top - L->Cbase); +} + + +LUA_API void lua_settop (lua_State *L, int index) { + if (index >= 0) + luaD_adjusttop(L, L->Cbase, index); + else + L->top = L->top+index+1; /* index is negative */ +} + + +LUA_API void lua_remove (lua_State *L, int index) { + StkId p = luaA_index(L, index); + while (++p < L->top) *(p-1) = *p; + L->top--; +} + + +LUA_API void lua_insert (lua_State *L, int index) { + StkId p = luaA_index(L, index); + StkId q; + for (q = L->top; q>p; q--) + *q = *(q-1); + *p = *L->top; +} + + +LUA_API void lua_pushvalue (lua_State *L, int index) { + *L->top = *luaA_index(L, index); + api_incr_top(L); +} + + + +/* +** access functions (stack -> C) +*/ + + +LUA_API int lua_type (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL) ? LUA_TNONE : ttype(o); +} + +LUA_API const char *lua_typename (lua_State *L, int t) { + UNUSED(L); + return (t == LUA_TNONE) ? "no value" : luaO_typenames[t]; +} + + +LUA_API int lua_iscfunction (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL) ? 0 : iscfunction(o); +} + +LUA_API int lua_isnumber (lua_State *L, int index) { + TObject *o = luaA_indexAcceptable(L, index); + return (o == NULL) ? 0 : (tonumber(o) == 0); +} + +LUA_API int lua_isstring (lua_State *L, int index) { + int t = lua_type(L, index); + return (t == LUA_TSTRING || t == LUA_TNUMBER); +} + + +LUA_API int lua_tag (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL) ? LUA_NOTAG : luaT_tag(o); +} + +LUA_API int lua_equal (lua_State *L, int index1, int index2) { + StkId o1 = luaA_indexAcceptable(L, index1); + StkId o2 = luaA_indexAcceptable(L, index2); + if (o1 == NULL || o2 == NULL) return 0; /* index out-of-range */ + else return luaO_equalObj(o1, o2); +} + +LUA_API int lua_lessthan (lua_State *L, int index1, int index2) { + StkId o1 = luaA_indexAcceptable(L, index1); + StkId o2 = luaA_indexAcceptable(L, index2); + if (o1 == NULL || o2 == NULL) return 0; /* index out-of-range */ + else return luaV_lessthan(L, o1, o2, L->top); +} + + + +LUA_API long lua_tonumber (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL || tonumber(o)) ? 0 : nvalue(o); +} + +LUA_API const char *lua_tostring (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL || tostring(L, o)) ? NULL : svalue(o); +} + +LUA_API size_t lua_strlen (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL || tostring(L, o)) ? 0 : tsvalue(o)->len; +} + +LUA_API lua_CFunction lua_tocfunction (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL || !iscfunction(o)) ? NULL : clvalue(o)->f.c; +} + +LUA_API void *lua_touserdata (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + return (o == NULL || ttype(o) != LUA_TUSERDATA) ? NULL : + tsvalue(o)->u.d.value; +} + +LUA_API const void *lua_topointer (lua_State *L, int index) { + StkId o = luaA_indexAcceptable(L, index); + if (o == NULL) return NULL; + switch (ttype(o)) { + case LUA_TTABLE: + return hvalue(o); + case LUA_TFUNCTION: + return clvalue(o); + default: return NULL; + } +} + + + +/* +** push functions (C -> stack) +*/ + + +LUA_API void lua_pushnil (lua_State *L) { + ttype(L->top) = LUA_TNIL; + api_incr_top(L); +} + + +LUA_API void lua_pushnumber (lua_State *L, long n) { + nvalue(L->top) = n; + ttype(L->top) = LUA_TNUMBER; + api_incr_top(L); +} + + +LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) { + tsvalue(L->top) = luaS_newlstr(L, s, len); + ttype(L->top) = LUA_TSTRING; + api_incr_top(L); +} + + +LUA_API void lua_pushstring (lua_State *L, const char *s) { + if (s == NULL) + lua_pushnil(L); + else + lua_pushlstring(L, s, strlen(s)); +} + + +LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { + luaV_Cclosure(L, fn, n); +} + + +LUA_API void lua_pushusertag (lua_State *L, void *u, int tag) { + /* ORDER LUA_T */ + if (!(tag == LUA_ANYTAG || tag == LUA_TUSERDATA || validtag(tag))) + luaO_verror(L, "invalid tag for a userdata (%d)", tag); + tsvalue(L->top) = luaS_createudata(L, u, tag); + ttype(L->top) = LUA_TUSERDATA; + api_incr_top(L); +} + + + +/* +** get functions (Lua -> stack) +*/ + + +LUA_API void lua_getglobal (lua_State *L, const char *name) { + StkId top = L->top; + *top = *luaV_getglobal(L, luaS_new(L, name)); + L->top = top; + api_incr_top(L); +} + + +LUA_API void lua_gettable (lua_State *L, int index) { + StkId t = Index(L, index); + StkId top = L->top; + *(top-1) = *luaV_gettable(L, t); + L->top = top; /* tag method may change top */ +} + + +LUA_API void lua_rawget (lua_State *L, int index) { + StkId t = Index(L, index); + LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected"); + *(L->top - 1) = *luaH_get(L, hvalue(t), L->top - 1); +} + + +LUA_API void lua_rawgeti (lua_State *L, int index, int n) { + StkId o = Index(L, index); + LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected"); + *L->top = *luaH_getnum(hvalue(o), n); + api_incr_top(L); +} + + +LUA_API void lua_getglobals (lua_State *L) { + hvalue(L->top) = L->gt; + ttype(L->top) = LUA_TTABLE; + api_incr_top(L); +} + + +LUA_API int lua_getref (lua_State *L, int ref) { + if (ref == LUA_REFNIL) + ttype(L->top) = LUA_TNIL; + else if (0 <= ref && ref < L->refSize && + (L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD)) + *L->top = L->refArray[ref].o; + else + return 0; + api_incr_top(L); + return 1; +} + + +LUA_API void lua_newtable (lua_State *L) { + hvalue(L->top) = luaH_new(L, 0); + ttype(L->top) = LUA_TTABLE; + api_incr_top(L); +} + + + +/* +** set functions (stack -> Lua) +*/ + + +LUA_API void lua_setglobal (lua_State *L, const char *name) { + StkId top = L->top; + luaV_setglobal(L, luaS_new(L, name)); + L->top = top-1; /* remove element from the top */ +} + + +LUA_API void lua_settable (lua_State *L, int index) { + StkId t = Index(L, index); + StkId top = L->top; + luaV_settable(L, t, top-2); + L->top = top-2; /* pop index and value */ +} + + +LUA_API void lua_rawset (lua_State *L, int index) { + StkId t = Index(L, index); + LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected"); + *luaH_set(L, hvalue(t), L->top-2) = *(L->top-1); + L->top -= 2; +} + + +LUA_API void lua_rawseti (lua_State *L, int index, int n) { + StkId o = Index(L, index); + LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected"); + *luaH_setint(L, hvalue(o), n) = *(L->top-1); + L->top--; +} + + +LUA_API void lua_setglobals (lua_State *L) { + StkId newtable = --L->top; + LUA_ASSERT(ttype(newtable) == LUA_TTABLE, "table expected"); + L->gt = hvalue(newtable); +} + + +LUA_API int lua_ref (lua_State *L, int lock) { + int ref; + if (ttype(L->top-1) == LUA_TNIL) + ref = LUA_REFNIL; + else { + if (L->refFree != NONEXT) { /* is there a free place? */ + ref = L->refFree; + L->refFree = L->refArray[ref].st; + } + else { /* no more free places */ + luaM_growvector(L, L->refArray, L->refSize, 1, struct Ref, + "reference table overflow", MAX_INT); + L->nblocks += sizeof(struct Ref); + ref = L->refSize++; + } + L->refArray[ref].o = *(L->top-1); + L->refArray[ref].st = lock ? LOCK : HOLD; + } + L->top--; + return ref; +} + + +/* +** "do" functions (run Lua code) +** (most of them are in ldo.c) +*/ + +LUA_API void lua_rawcall (lua_State *L, int nargs, int nresults) { + luaD_call(L, L->top-(nargs+1), nresults); +} + + +/* +** Garbage-collection functions +*/ + +/* GC values are expressed in Kbytes: #bytes/2^10 */ +#define GCscale(x) ((int)((x)>>10)) +#define GCunscale(x) ((unsigned long)(x)<<10) + +LUA_API int lua_getgcthreshold (lua_State *L) { + return GCscale(L->GCthreshold); +} + +LUA_API int lua_getgccount (lua_State *L) { + return GCscale(L->nblocks); +} + +LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) { + if (newthreshold > GCscale(ULONG_MAX)) + L->GCthreshold = ULONG_MAX; + else + L->GCthreshold = GCunscale(newthreshold); + luaC_checkGC(L); +} + + +/* +** miscellaneous functions +*/ + +LUA_API void lua_settag (lua_State *L, int tag) { + luaT_realtag(L, tag); + switch (ttype(L->top-1)) { + case LUA_TTABLE: + hvalue(L->top-1)->htag = tag; + break; + case LUA_TUSERDATA: + tsvalue(L->top-1)->u.d.tag = tag; + break; + default: + luaO_verror(L, "cannot change the tag of a %.20s", + luaO_typename(L->top-1)); + } +} + + +LUA_API void lua_unref (lua_State *L, int ref) { + if (ref >= 0) { + LUA_ASSERT(ref < L->refSize && L->refArray[ref].st < 0, "invalid ref"); + L->refArray[ref].st = L->refFree; + L->refFree = ref; + } +} + + +LUA_API int lua_next (lua_State *L, int index) { + StkId t = luaA_index(L, index); + Node *n; + LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected"); + n = luaH_next(L, hvalue(t), luaA_index(L, -1)); + if (n) { + *(L->top-1) = *key(n); + *L->top = *val(n); + api_incr_top(L); + return 1; + } + else { /* no more elements */ + L->top -= 1; /* remove key */ + return 0; + } +} + + +LUA_API int lua_getn (lua_State *L, int index) { + Hash *h = hvalue(luaA_index(L, index)); + const TObject *value = luaH_getstr(h, luaS_new(L, "n")); /* value = h.n */ + if (ttype(value) == LUA_TNUMBER) + return (int)nvalue(value); + else { + Number max = 0; + int i = h->size; + Node *n = h->node; + while (i--) { + if (ttype(key(n)) == LUA_TNUMBER && + ttype(val(n)) != LUA_TNIL && + nvalue(key(n)) > max) + max = nvalue(key(n)); + n++; + } + return (int)max; + } +} + + +LUA_API void lua_concat (lua_State *L, int n) { + StkId top = L->top; + luaV_strconc(L, n, top); + L->top = top-(n-1); + luaC_checkGC(L); +} + + +LUA_API void *lua_newuserdata (lua_State *L, size_t size) { + TString *ts = luaS_newudata(L, size, NULL); + tsvalue(L->top) = ts; + ttype(L->top) = LUA_TUSERDATA; + api_incr_top(L); + return ts->u.d.value; +} + diff --git a/src/lua/lapi.h b/src/lua/lapi.h new file mode 100644 index 00000000..d6e1c44f --- /dev/null +++ b/src/lua/lapi.h @@ -0,0 +1,17 @@ +/* +** $Id: lapi.h,v 1.3 2001/11/26 23:00:23 darkgod Exp $ +** Auxiliary functions from Lua API +** See Copyright Notice in lua.h +*/ + +#ifndef lapi_h +#define lapi_h + + +#include "lobject.h" + + +TObject *luaA_index (lua_State *L, int index); +void luaA_pushobject (lua_State *L, const TObject *o); + +#endif diff --git a/src/lua/lauxlib.c b/src/lua/lauxlib.c new file mode 100644 index 00000000..810bca20 --- /dev/null +++ b/src/lua/lauxlib.c @@ -0,0 +1,216 @@ +/* +** $Id: lauxlib.c,v 1.3 2001/11/26 23:00:23 darkgod Exp $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#include <stdarg.h> +#include <stdio.h> +#include <string.h> + +/* This file uses only the official API of Lua. +** Any function declared here could be written as an application function. +** With care, these functions can be used by other libraries. +*/ + +#include "lua.h" + +#include "lauxlib.h" +#include "luadebug.h" + + + +LUALIB_API int luaL_findstring (const char *name, const char *const list[]) { + int i; + for (i=0; list[i]; i++) + if (strcmp(list[i], name) == 0) + return i; + return -1; /* name not found */ +} + +LUALIB_API void luaL_argerror (lua_State *L, int narg, const char *extramsg) { + lua_Debug ar; + lua_getstack(L, 0, &ar); + lua_getinfo(L, "n", &ar); + if (ar.name == NULL) + ar.name = "?"; + luaL_verror(L, "bad argument #%d to `%.50s' (%.100s)", + narg, ar.name, extramsg); +} + + +static void type_error (lua_State *L, int narg, int t) { + char buff[50]; + sprintf(buff, "%.8s expected, got %.8s", lua_typename(L, t), + lua_typename(L, lua_type(L, narg))); + luaL_argerror(L, narg, buff); +} + + +LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) { + if (space > lua_stackspace(L)) + luaL_verror(L, "stack overflow (%.30s)", mes); +} + + +LUALIB_API void luaL_checktype(lua_State *L, int narg, int t) { + if (lua_type(L, narg) != t) + type_error(L, narg, t); +} + + +LUALIB_API void luaL_checkany (lua_State *L, int narg) { + if (lua_type(L, narg) == LUA_TNONE) + luaL_argerror(L, narg, "value expected"); +} + + +LUALIB_API const char *luaL_check_lstr (lua_State *L, int narg, size_t *len) { + const char *s = lua_tostring(L, narg); + if (!s) type_error(L, narg, LUA_TSTRING); + if (len) *len = lua_strlen(L, narg); + return s; +} + + +LUALIB_API const char *luaL_opt_lstr (lua_State *L, int narg, const char *def, size_t *len) { + if (lua_isnull(L, narg)) { + if (len) + *len = (def ? strlen(def) : 0); + return def; + } + else return luaL_check_lstr(L, narg, len); +} + + +LUALIB_API long luaL_check_number (lua_State *L, int narg) { + long d = lua_tonumber(L, narg); + if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */ + type_error(L, narg, LUA_TNUMBER); + return d; +} + + +LUALIB_API long luaL_opt_number (lua_State *L, int narg, long def) { + if (lua_isnull(L, narg)) return def; + else return luaL_check_number(L, narg); +} + + +LUALIB_API void luaL_openlib (lua_State *L, const struct luaL_reg *l, int n) { + int i; + for (i=0; i<n; i++) + lua_register(L, l[i].name, l[i].func); +} + + +LUALIB_API void luaL_verror (lua_State *L, const char *fmt, ...) { + char buff[500]; + va_list argp; + va_start(argp, fmt); + vsprintf(buff, fmt, argp); + va_end(argp); + lua_error(L, buff); +} + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + + +#define buffempty(B) ((B)->p == (B)->buffer) +#define bufflen(B) ((B)->p - (B)->buffer) +#define bufffree(B) ((size_t)(LUAL_BUFFERSIZE - bufflen(B))) + +#define LIMIT (LUA_MINSTACK/2) + + +static int emptybuffer (luaL_Buffer *B) { + size_t l = bufflen(B); + if (l == 0) return 0; /* put nothing on stack */ + else { + lua_pushlstring(B->L, B->buffer, l); + B->p = B->buffer; + B->level++; + return 1; + } +} + + +static void adjuststack (luaL_Buffer *B) { + if (B->level > 1) { + lua_State *L = B->L; + int toget = 1; /* number of levels to concat */ + size_t toplen = lua_strlen(L, -1); + do { + size_t l = lua_strlen(L, -(toget+1)); + if (B->level - toget + 1 >= LIMIT || toplen > l) { + toplen += l; + toget++; + } + else break; + } while (toget < B->level); + if (toget >= 2) { + lua_concat(L, toget); + B->level = B->level - toget + 1; + } + } +} + + +LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) { + if (emptybuffer(B)) + adjuststack(B); + return B->buffer; +} + + +LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { + while (l--) + luaL_putchar(B, *s++); +} + + +LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { + luaL_addlstring(B, s, strlen(s)); +} + + +LUALIB_API void luaL_pushresult (luaL_Buffer *B) { + emptybuffer(B); + if (B->level == 0) + lua_pushlstring(B->L, NULL, 0); + else if (B->level > 1) + lua_concat(B->L, B->level); + B->level = 1; +} + + +LUALIB_API void luaL_addvalue (luaL_Buffer *B) { + lua_State *L = B->L; + size_t vl = lua_strlen(L, -1); + if (vl <= bufffree(B)) { /* fit into buffer? */ + memcpy(B->p, lua_tostring(L, -1), vl); /* put it there */ + B->p += vl; + lua_pop(L, 1); /* remove from stack */ + } + else { + if (emptybuffer(B)) + lua_insert(L, -2); /* put buffer before new value */ + B->level++; /* add new value into B stack */ + adjuststack(B); + } +} + + +LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { + B->L = L; + B->p = B->buffer; + B->level = 0; +} + +/* }====================================================== */ diff --git a/src/lua/lauxlib.h b/src/lua/lauxlib.h new file mode 100644 index 00000000..a8d35aff --- /dev/null +++ b/src/lua/lauxlib.h @@ -0,0 +1,100 @@ +/* +** $Id: lauxlib.h,v 1.2 2001/11/26 23:00:23 darkgod Exp $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lauxlib_h +#define lauxlib_h + + +#include <stddef.h> +#include <stdio.h> + +#include "lua.h" + + +#ifndef LUALIB_API +#define LUALIB_API extern +#endif + + +struct luaL_reg { + const char *name; + lua_CFunction func; +}; + + +LUALIB_API void luaL_openlib (lua_State *L, const struct luaL_reg *l, int n); +LUALIB_API void luaL_argerror (lua_State *L, int numarg, const char *extramsg); +LUALIB_API const char *luaL_check_lstr (lua_State *L, int numArg, size_t *len); +LUALIB_API const char *luaL_opt_lstr (lua_State *L, int numArg, const char *def, size_t *len); +LUALIB_API long luaL_check_number (lua_State *L, int numArg); +LUALIB_API long luaL_opt_number (lua_State *L, int numArg, long def); + +LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg); +LUALIB_API void luaL_checktype (lua_State *L, int narg, int t); +LUALIB_API void luaL_checkany (lua_State *L, int narg); + +LUALIB_API void luaL_verror (lua_State *L, const char *fmt, ...); +LUALIB_API int luaL_findstring (const char *name, const char *const list[]); + + + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + +#define luaL_arg_check(L, cond,numarg,extramsg) if (!(cond)) \ + luaL_argerror(L, numarg,extramsg) +#define luaL_check_string(L,n) (luaL_check_lstr(L, (n), NULL)) +#define luaL_opt_string(L,n,d) (luaL_opt_lstr(L, (n), (d), NULL)) +#define luaL_check_int(L,n) ((int)luaL_check_number(L, n)) +#define luaL_check_long(L,n) ((long)luaL_check_number(L, n)) +#define luaL_opt_int(L,n,d) ((int)luaL_opt_number(L, n,d)) +#define luaL_opt_long(L,n,d) ((long)luaL_opt_number(L, n,d)) +#define luaL_openl(L,a) luaL_openlib(L, a, (sizeof(a)/sizeof(a[0]))) + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + + +#ifndef LUAL_BUFFERSIZE +#define LUAL_BUFFERSIZE BUFSIZ +#endif + + +typedef struct luaL_Buffer { + char *p; /* current position in buffer */ + int level; + lua_State *L; + char buffer[LUAL_BUFFERSIZE]; +} luaL_Buffer; + +#define luaL_putchar(B,c) \ + ((void)((B)->p < &(B)->buffer[LUAL_BUFFERSIZE] || luaL_prepbuffer(B)), \ + (*(B)->p++ = (char)(c))) + +#define luaL_addsize(B,n) ((B)->p += (n)) + +LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B); +LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B); +LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l); +LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s); +LUALIB_API void luaL_addvalue (luaL_Buffer *B); +LUALIB_API void luaL_pushresult (luaL_Buffer *B); + + +/* }====================================================== */ + + +#endif + + diff --git a/src/lua/lbaselib.c b/src/lua/lbaselib.c new file mode 100644 index 00000000..71c643aa --- /dev/null +++ b/src/lua/lbaselib.c @@ -0,0 +1,651 @@ +/* +** $Id: lbaselib.c,v 1.2 2001/11/26 23:00:23 darkgod Exp $ +** Basic library +** See Copyright Notice in lua.h +*/ + + + +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "lua.h" + +#include "lauxlib.h" +#include "luadebug.h" +#include "lualib.h" + + + +/* +** If your system does not support `stderr', redefine this function, or +** redefine _ERRORMESSAGE so that it won't need _ALERT. +*/ +static int luaB__ALERT (lua_State *L) { + fputs(luaL_check_string(L, 1), stderr); + return 0; +} + + +/* +** Basic implementation of _ERRORMESSAGE. +** The library `liolib' redefines _ERRORMESSAGE for better error information. +*/ +static int luaB__ERRORMESSAGE (lua_State *L) { + luaL_checktype(L, 1, LUA_TSTRING); + lua_getglobal(L, LUA_ALERT); + if (lua_isfunction(L, -1)) { /* avoid error loop if _ALERT is not defined */ + lua_Debug ar; + lua_pushstring(L, "error: "); + lua_pushvalue(L, 1); + if (lua_getstack(L, 1, &ar)) { + lua_getinfo(L, "Sl", &ar); + if (ar.source && ar.currentline > 0) { + char buff[100]; + sprintf(buff, "\n <%.70s: line %d>", ar.short_src, ar.currentline); + lua_pushstring(L, buff); + lua_concat(L, 2); + } + } + lua_pushstring(L, "\n"); + lua_concat(L, 3); + lua_rawcall(L, 1, 0); + } + return 0; +} + + +/* +** If your system does not support `stdout', you can just remove this function. +** If you need, you can define your own `print' function, following this +** model but changing `fputs' to put the strings at a proper place +** (a console window or a log file, for instance). +*/ +static int luaB_print (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int i; + lua_getglobal(L, "tostring"); + for (i=1; i<=n; i++) { + const char *s; + lua_pushvalue(L, -1); /* function to be called */ + lua_pushvalue(L, i); /* value to print */ + lua_rawcall(L, 1, 1); + s = lua_tostring(L, -1); /* get result */ + if (s == NULL) + lua_error(L, "`tostring' must return a string to `print'"); + if (i>1) fputs("\t", stdout); + fputs(s, stdout); + lua_pop(L, 1); /* pop result */ + } + fputs("\n", stdout); + return 0; +} + + +static int luaB_tonumber (lua_State *L) { + int base = luaL_opt_int(L, 2, 10); + if (base == 10) { /* standard conversion */ + luaL_checkany(L, 1); + if (lua_isnumber(L, 1)) { + lua_pushnumber(L, lua_tonumber(L, 1)); + return 1; + } + } + else { + const char *s1 = luaL_check_string(L, 1); + char *s2; + unsigned long n; + luaL_arg_check(L, 2 <= base && base <= 36, 2, "base out of range"); + n = strtoul(s1, &s2, base); + if (s1 != s2) { /* at least one valid digit? */ + while (isspace((unsigned char)*s2)) s2++; /* skip trailing spaces */ + if (*s2 == '\0') { /* no invalid trailing characters? */ + lua_pushnumber(L, n); + return 1; + } + } + } + lua_pushnil(L); /* else not a number */ + return 1; +} + + +static int luaB_error (lua_State *L) { + lua_error(L, luaL_opt_string(L, 1, NULL)); + return 0; /* to avoid warnings */ +} + +static int luaB_setglobal (lua_State *L) { + luaL_checkany(L, 2); + lua_setglobal(L, luaL_check_string(L, 1)); + return 0; +} + +static int luaB_getglobal (lua_State *L) { + lua_getglobal(L, luaL_check_string(L, 1)); + return 1; +} + +static int luaB_tag (lua_State *L) { + luaL_checkany(L, 1); + lua_pushnumber(L, lua_tag(L, 1)); + return 1; +} + +static int luaB_settag (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + lua_pushvalue(L, 1); /* push table */ + lua_settag(L, luaL_check_int(L, 2)); + return 1; /* return table */ +} + +static int luaB_newtag (lua_State *L) { + lua_pushnumber(L, lua_newtag(L)); + return 1; +} + +static int luaB_copytagmethods (lua_State *L) { + lua_pushnumber(L, lua_copytagmethods(L, luaL_check_int(L, 1), + luaL_check_int(L, 2))); + return 1; +} + +static int luaB_globals (lua_State *L) { + lua_getglobals(L); /* value to be returned */ + if (!lua_isnull(L, 1)) { + luaL_checktype(L, 1, LUA_TTABLE); + lua_pushvalue(L, 1); /* new table of globals */ + lua_setglobals(L); + } + return 1; +} + +static int luaB_rawget (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checkany(L, 2); + lua_rawget(L, -2); + return 1; +} + +static int luaB_rawset (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checkany(L, 2); + luaL_checkany(L, 3); + lua_rawset(L, -3); + return 1; +} + +static int luaB_settagmethod (lua_State *L) { + int tag = luaL_check_int(L, 1); + const char *event = luaL_check_string(L, 2); + luaL_arg_check(L, lua_isfunction(L, 3) || lua_isnil(L, 3), 3, + "function or nil expected"); + if (strcmp(event, "gc") == 0) + lua_error(L, "deprecated use: cannot set the `gc' tag method from Lua"); + lua_gettagmethod(L, tag, event); + lua_pushvalue(L, 3); + lua_settagmethod(L, tag, event); + return 1; +} + + +static int luaB_gettagmethod (lua_State *L) { + int tag = luaL_check_int(L, 1); + const char *event = luaL_check_string(L, 2); + if (strcmp(event, "gc") == 0) + lua_error(L, "deprecated use: cannot get the `gc' tag method from Lua"); + lua_gettagmethod(L, tag, event); + return 1; +} + + +static int luaB_gcinfo (lua_State *L) { + lua_pushnumber(L, lua_getgccount(L)); + lua_pushnumber(L, lua_getgcthreshold(L)); + return 2; +} + + +static int luaB_collectgarbage (lua_State *L) { + lua_setgcthreshold(L, luaL_opt_int(L, 1, 0)); + return 0; +} + + +static int luaB_type (lua_State *L) { + luaL_checkany(L, 1); + lua_pushstring(L, lua_typename(L, lua_type(L, 1))); + return 1; +} + + +static int luaB_next (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + lua_settop(L, 2); /* create a 2nd argument if there isn't one */ + if (lua_next(L, 1)) + return 2; + else { + lua_pushnil(L); + return 1; + } +} + + +static int passresults (lua_State *L, int status, int oldtop) { + static const char *const errornames[] = + {"ok", "run-time error", "file error", "syntax error", + "memory error", "error in error handling"}; + if (status == 0) { + int nresults = lua_gettop(L) - oldtop; + if (nresults > 0) + return nresults; /* results are already on the stack */ + else { + lua_pushuserdata(L, NULL); /* at least one result to signal no errors */ + return 1; + } + } + else { /* error */ + lua_pushnil(L); + lua_pushstring(L, errornames[status]); /* error code */ + return 2; + } +} + +static int luaB_dostring (lua_State *L) { + int oldtop = lua_gettop(L); + size_t l; + const char *s = luaL_check_lstr(L, 1, &l); + if (*s == '\27') /* binary files start with ESC... */ + lua_error(L, "`dostring' cannot run pre-compiled code"); + return passresults(L, lua_dobuffer(L, s, l, luaL_opt_string(L, 2, s)), oldtop); +} + + +static int luaB_dofile (lua_State *L) { + int oldtop = lua_gettop(L); + const char *fname = luaL_opt_string(L, 1, NULL); + return passresults(L, lua_dofile(L, fname), oldtop); +} + + +static int luaB_call (lua_State *L) { + int oldtop; + const char *options = luaL_opt_string(L, 3, ""); + int err = 0; /* index of old error method */ + int i, status; + int n; + luaL_checktype(L, 2, LUA_TTABLE); + n = lua_getn(L, 2); + if (!lua_isnull(L, 4)) { /* set new error method */ + lua_getglobal(L, LUA_ERRORMESSAGE); + err = lua_gettop(L); /* get index */ + lua_pushvalue(L, 4); + lua_setglobal(L, LUA_ERRORMESSAGE); + } + oldtop = lua_gettop(L); /* top before function-call preparation */ + /* push function */ + lua_pushvalue(L, 1); + luaL_checkstack(L, n, "too many arguments"); + for (i=0; i<n; i++) /* push arg[1...n] */ + lua_rawgeti(L, 2, i+1); + status = lua_call(L, n, LUA_MULTRET); + if (err != 0) { /* restore old error method */ + lua_pushvalue(L, err); + lua_setglobal(L, LUA_ERRORMESSAGE); + } + if (status != 0) { /* error in call? */ + if (strchr(options, 'x')) + lua_pushnil(L); /* return nil to signal the error */ + else + lua_error(L, NULL); /* propagate error without additional messages */ + return 1; + } + if (strchr(options, 'p')) /* pack results? */ + lua_error(L, "deprecated option `p' in `call'"); + return lua_gettop(L) - oldtop; /* results are already on the stack */ +} + + +static int luaB_tostring (lua_State *L) { + char buff[64]; + switch (lua_type(L, 1)) { + case LUA_TNUMBER: + lua_pushstring(L, lua_tostring(L, 1)); + return 1; + case LUA_TSTRING: + lua_pushvalue(L, 1); + return 1; + case LUA_TTABLE: + sprintf(buff, "table: %p", lua_topointer(L, 1)); + break; + case LUA_TFUNCTION: + sprintf(buff, "function: %p", lua_topointer(L, 1)); + break; + case LUA_TUSERDATA: + sprintf(buff, "userdata(%d): %p", lua_tag(L, 1), lua_touserdata(L, 1)); + break; + case LUA_TNIL: + lua_pushstring(L, "nil"); + return 1; + default: + luaL_argerror(L, 1, "value expected"); + } + lua_pushstring(L, buff); + return 1; +} + + +static int luaB_foreachi (lua_State *L) { + int n, i; + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checktype(L, 2, LUA_TFUNCTION); + n = lua_getn(L, 1); + for (i=1; i<=n; i++) { + lua_pushvalue(L, 2); /* function */ + lua_pushnumber(L, i); /* 1st argument */ + lua_rawgeti(L, 1, i); /* 2nd argument */ + lua_rawcall(L, 2, 1); + if (!lua_isnil(L, -1)) + return 1; + lua_pop(L, 1); /* remove nil result */ + } + return 0; +} + + +static int luaB_foreach (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_pushnil(L); /* first index */ + for (;;) { + if (lua_next(L, 1) == 0) + return 0; + lua_pushvalue(L, 2); /* function */ + lua_pushvalue(L, -3); /* key */ + lua_pushvalue(L, -3); /* value */ + lua_rawcall(L, 2, 1); + if (!lua_isnil(L, -1)) + return 1; + lua_pop(L, 2); /* remove value and result */ + } +} + + +static int luaB_assert (lua_State *L) { + luaL_checkany(L, 1); + if (lua_isnil(L, 1)) + luaL_verror(L, "assertion failed! %.90s", luaL_opt_string(L, 2, "")); + return 0; +} + + +static int luaB_getn (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + lua_pushnumber(L, lua_getn(L, 1)); + return 1; +} + + +static int luaB_tinsert (lua_State *L) { + int v = lua_gettop(L); /* last argument: to be inserted */ + int n, pos; + luaL_checktype(L, 1, LUA_TTABLE); + n = lua_getn(L, 1); + if (v == 2) /* called with only 2 arguments */ + pos = n+1; + else + pos = luaL_check_int(L, 2); /* 2nd argument is the position */ + lua_pushstring(L, "n"); + lua_pushnumber(L, n+1); + lua_rawset(L, 1); /* t.n = n+1 */ + for (; n>=pos; n--) { + lua_rawgeti(L, 1, n); + lua_rawseti(L, 1, n+1); /* t[n+1] = t[n] */ + } + lua_pushvalue(L, v); + lua_rawseti(L, 1, pos); /* t[pos] = v */ + return 0; +} + + +static int luaB_tremove (lua_State *L) { + int pos, n; + luaL_checktype(L, 1, LUA_TTABLE); + n = lua_getn(L, 1); + pos = luaL_opt_int(L, 2, n); + if (n <= 0) return 0; /* table is "empty" */ + lua_rawgeti(L, 1, pos); /* result = t[pos] */ + for ( ;pos<n; pos++) { + lua_rawgeti(L, 1, pos+1); + lua_rawseti(L, 1, pos); /* a[pos] = a[pos+1] */ + } + lua_pushstring(L, "n"); + lua_pushnumber(L, n-1); + lua_rawset(L, 1); /* t.n = n-1 */ + lua_pushnil(L); + lua_rawseti(L, 1, n); /* t[n] = nil */ + return 1; +} + + + + +/* +** {====================================================== +** Quicksort +** (based on `Algorithms in MODULA-3', Robert Sedgewick; +** Addison-Wesley, 1993.) +*/ + + +static void set2 (lua_State *L, int i, int j) { + lua_rawseti(L, 1, i); + lua_rawseti(L, 1, j); +} + +static int sort_comp (lua_State *L, int a, int b) { + /* WARNING: the caller (auxsort) must ensure stack space */ + if (!lua_isnil(L, 2)) { /* function? */ + int res; + lua_pushvalue(L, 2); + lua_pushvalue(L, a-1); /* -1 to compensate function */ + lua_pushvalue(L, b-2); /* -2 to compensate function and `a' */ + lua_rawcall(L, 2, 1); + res = !lua_isnil(L, -1); + lua_pop(L, 1); + return res; + } + else /* a < b? */ + return lua_lessthan(L, a, b); +} + +static void auxsort (lua_State *L, int l, int u) { + while (l < u) { /* for tail recursion */ + int i, j; + /* sort elements a[l], a[(l+u)/2] and a[u] */ + lua_rawgeti(L, 1, l); + lua_rawgeti(L, 1, u); + if (sort_comp(L, -1, -2)) /* a[u] < a[l]? */ + set2(L, l, u); /* swap a[l] - a[u] */ + else + lua_pop(L, 2); + if (u-l == 1) break; /* only 2 elements */ + i = (l+u)/2; + lua_rawgeti(L, 1, i); + lua_rawgeti(L, 1, l); + if (sort_comp(L, -2, -1)) /* a[i]<a[l]? */ + set2(L, i, l); + else { + lua_pop(L, 1); /* remove a[l] */ + lua_rawgeti(L, 1, u); + if (sort_comp(L, -1, -2)) /* a[u]<a[i]? */ + set2(L, i, u); + else + lua_pop(L, 2); + } + if (u-l == 2) break; /* only 3 elements */ + lua_rawgeti(L, 1, i); /* Pivot */ + lua_pushvalue(L, -1); + lua_rawgeti(L, 1, u-1); + set2(L, i, u-1); + /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */ + i = l; j = u-1; + for (;;) { /* invariant: a[l..i] <= P <= a[j..u] */ + /* repeat ++i until a[i] >= P */ + while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) { + if (i>u) lua_error(L, "invalid order function for sorting"); + lua_pop(L, 1); /* remove a[i] */ + } + /* repeat --j until a[j] <= P */ + while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) { + if (j<l) lua_error(L, "invalid order function for sorting"); + lua_pop(L, 1); /* remove a[j] */ + } + if (j<i) { + lua_pop(L, 3); /* pop pivot, a[i], a[j] */ + break; + } + set2(L, i, j); + } + lua_rawgeti(L, 1, u-1); + lua_rawgeti(L, 1, i); + set2(L, u-1, i); /* swap pivot (a[u-1]) with a[i] */ + /* a[l..i-1] <= a[i] == P <= a[i+1..u] */ + /* adjust so that smaller "half" is in [j..i] and larger one in [l..u] */ + if (i-l < u-i) { + j=l; i=i-1; l=i+2; + } + else { + j=i+1; i=u; u=j-2; + } + auxsort(L, j, i); /* call recursively the smaller one */ + } /* repeat the routine for the larger one */ +} + +static int luaB_sort (lua_State *L) { + int n; + luaL_checktype(L, 1, LUA_TTABLE); + n = lua_getn(L, 1); + if (!lua_isnull(L, 2)) /* is there a 2nd argument? */ + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_settop(L, 2); /* make sure there is two arguments */ + auxsort(L, 1, n); + return 0; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** Deprecated functions to manipulate global environment. +** ======================================================= +*/ + + +#define num_deprecated 4 + +static const struct luaL_reg deprecated_names [num_deprecated] = { + {"foreachvar", luaB_foreach}, + {"nextvar", luaB_next}, + {"rawgetglobal", luaB_rawget}, + {"rawsetglobal", luaB_rawset} +}; + + +#ifdef LUA_DEPRECATEDFUNCS + +/* +** call corresponding function inserting `globals' as first argument +*/ +static int deprecated_func (lua_State *L) { + lua_insert(L, 1); /* upvalue is the function to be called */ + lua_getglobals(L); + lua_insert(L, 2); /* table of globals is 1o argument */ + lua_rawcall(L, lua_gettop(L)-1, LUA_MULTRET); + return lua_gettop(L); /* return all results */ +} + + +static void deprecated_funcs (lua_State *L) { + int i; + for (i=0; i<num_deprecated; i++) { + lua_pushcfunction(L, deprecated_names[i].func); + lua_pushcclosure(L, deprecated_func, 1); + lua_setglobal(L, deprecated_names[i].name); + } +} + + +#else + +/* +** gives an explicit error in any attempt to call a deprecated function +*/ +static int deprecated_func (lua_State *L) { + luaL_verror(L, "function `%.20s' is deprecated", lua_tostring(L, -1)); + return 0; /* to avoid warnings */ +} + + +static void deprecated_funcs (lua_State *L) { + int i; + for (i=0; i<num_deprecated; i++) { + lua_pushstring(L, deprecated_names[i].name); + lua_pushcclosure(L, deprecated_func, 1); + lua_setglobal(L, deprecated_names[i].name); + } +} + +#endif + +/* }====================================================== */ + +static const struct luaL_reg base_funcs[] = { + {LUA_ALERT, luaB__ALERT}, + {LUA_ERRORMESSAGE, luaB__ERRORMESSAGE}, + {"call", luaB_call}, + {"collectgarbage", luaB_collectgarbage}, + {"copytagmethods", luaB_copytagmethods}, + {"dofile", luaB_dofile}, + {"dostring", luaB_dostring}, + {"error", luaB_error}, + {"foreach", luaB_foreach}, + {"foreachi", luaB_foreachi}, + {"gcinfo", luaB_gcinfo}, + {"getglobal", luaB_getglobal}, + {"gettagmethod", luaB_gettagmethod}, + {"globals", luaB_globals}, + {"newtag", luaB_newtag}, + {"next", luaB_next}, + {"print", luaB_print}, + {"rawget", luaB_rawget}, + {"rawset", luaB_rawset}, + {"rawgettable", luaB_rawget}, /* for compatibility */ + {"rawsettable", luaB_rawset}, /* for compatibility */ + {"setglobal", luaB_setglobal}, + {"settag", luaB_settag}, + {"settagmethod", luaB_settagmethod}, + {"tag", luaB_tag}, + {"tonumber", luaB_tonumber}, + {"tostring", luaB_tostring}, + {"type", luaB_type}, + {"assert", luaB_assert}, + {"getn", luaB_getn}, + {"sort", luaB_sort}, + {"tinsert", luaB_tinsert}, + {"tremove", luaB_tremove} +}; + + + +LUALIB_API void lua_baselibopen (lua_State *L) { + luaL_openl(L, base_funcs); + lua_pushstring(L, LUA_VERSION); + lua_setglobal(L, "_VERSION"); + deprecated_funcs(L); +} + diff --git a/src/lua/lcode.c b/src/lua/lcode.c new file mode 100644 index 00000000..89de4a55 --- /dev/null +++ b/src/lua/lcode.c @@ -0,0 +1,701 @@ +/* +** $Id: lcode.c,v 1.4 2004/06/04 13:42:10 neil Exp $ +** Code generator for Lua +** See Copyright Notice in lua.h +*/ + + +#include "stdlib.h" + +#include "lua.h" + +#include "lcode.h" +#include "ldo.h" +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" + + +void luaK_error (LexState *ls, const char *msg) { + luaX_error(ls, msg, ls->t.token); +} + + +/* +** Returns the the previous instruction, for optimizations. +** If there is a jump target between this and the current instruction, +** returns a dummy instruction to avoid wrong optimizations. +*/ +static Instruction previous_instruction (FuncState *fs) { + if (fs->pc > fs->lasttarget) /* no jumps to current position? */ + return fs->f->code[fs->pc-1]; /* returns previous instruction */ + else + return CREATE_0(OP_END); /* no optimizations after an `END' */ +} + + +int luaK_jump (FuncState *fs) { + int j = luaK_code1(fs, OP_JMP, NO_JUMP); + if (j == fs->lasttarget) { /* possible jumps to this jump? */ + luaK_concat(fs, &j, fs->jlt); /* keep them on hold */ + fs->jlt = NO_JUMP; + } + return j; +} + + +static void luaK_fixjump (FuncState *fs, int pc, int dest) { + Instruction *jmp = &fs->f->code[pc]; + if (dest == NO_JUMP) + SETARG_S(*jmp, NO_JUMP); /* point to itself to represent end of list */ + else { /* jump is relative to position following jump instruction */ + int offset = dest-(pc+1); + if (abs(offset) > MAXARG_S) + luaK_error(fs->ls, "control structure too long"); + SETARG_S(*jmp, offset); + } +} + + +static int luaK_getjump (FuncState *fs, int pc) { + int offset = GETARG_S(fs->f->code[pc]); + if (offset == NO_JUMP) /* point to itself represents end of list */ + return NO_JUMP; /* end of list */ + else + return (pc+1)+offset; /* turn offset into absolute position */ +} + + +/* +** returns current `pc' and marks it as a jump target (to avoid wrong +** optimizations with consecutive instructions not in the same basic block). +** discharge list of jumps to last target. +*/ +int luaK_getlabel (FuncState *fs) { + if (fs->pc != fs->lasttarget) { + int lasttarget = fs->lasttarget; + fs->lasttarget = fs->pc; + luaK_patchlist(fs, fs->jlt, lasttarget); /* discharge old list `jlt' */ + fs->jlt = NO_JUMP; /* nobody jumps to this new label (yet) */ + } + return fs->pc; +} + + +void luaK_deltastack (FuncState *fs, int delta) { + fs->stacklevel += delta; + if (fs->stacklevel > fs->f->maxstacksize) { + if (fs->stacklevel > MAXSTACK) + luaK_error(fs->ls, "function or expression too complex"); + fs->f->maxstacksize = fs->stacklevel; + } +} + + +void luaK_kstr (LexState *ls, int c) { + luaK_code1(ls->fs, OP_PUSHSTRING, c); +} + + +static int number_constant (FuncState *fs, Number r) { + /* check whether `r' has appeared within the last LOOKBACKNUMS entries */ + Proto *f = fs->f; + int c = f->nknum; + int lim = c < LOOKBACKNUMS ? 0 : c-LOOKBACKNUMS; + while (--c >= lim) + if (f->knum[c] == r) return c; + /* not found; create a new entry */ + luaM_growvector(fs->L, f->knum, f->nknum, 1, Number, + "constant table overflow", MAXARG_U); + c = f->nknum++; + f->knum[c] = r; + return c; +} + + +void luaK_number (FuncState *fs, Number f) { + if (f <= (Number)MAXARG_S && (Number)(int)f == f) + luaK_code1(fs, OP_PUSHINT, (int)f); /* f has a short integer value */ + else + luaK_code1(fs, OP_PUSHNUM, number_constant(fs, f)); +} + + +void luaK_adjuststack (FuncState *fs, int n) { + if (n > 0) + luaK_code1(fs, OP_POP, n); + else + luaK_code1(fs, OP_PUSHNIL, -n); +} + + +int luaK_lastisopen (FuncState *fs) { + /* check whether last instruction is an open function call */ + Instruction i = previous_instruction(fs); + if (GET_OPCODE(i) == OP_CALL && GETARG_B(i) == MULT_RET) + return 1; + else return 0; +} + + +void luaK_setcallreturns (FuncState *fs, int nresults) { + if (luaK_lastisopen(fs)) { /* expression is an open function call? */ + SETARG_B(fs->f->code[fs->pc-1], nresults); /* set number of results */ + luaK_deltastack(fs, nresults); /* push results */ + } +} + + +static int discharge (FuncState *fs, expdesc *var) { + switch (var->k) { + case VLOCAL: + luaK_code1(fs, OP_GETLOCAL, var->u.index); + break; + case VGLOBAL: + luaK_code1(fs, OP_GETGLOBAL, var->u.index); + break; + case VINDEXED: + luaK_code0(fs, OP_GETTABLE); + break; + case VEXP: + return 0; /* nothing to do */ + } + var->k = VEXP; + var->u.l.t = var->u.l.f = NO_JUMP; + return 1; +} + + +static void discharge1 (FuncState *fs, expdesc *var) { + discharge(fs, var); + /* if it has jumps then it is already discharged */ + if (var->u.l.t == NO_JUMP && var->u.l.f == NO_JUMP) + luaK_setcallreturns(fs, 1); /* call must return 1 value */ +} + + +void luaK_storevar (LexState *ls, const expdesc *var) { + FuncState *fs = ls->fs; + switch (var->k) { + case VLOCAL: + luaK_code1(fs, OP_SETLOCAL, var->u.index); + break; + case VGLOBAL: + luaK_code1(fs, OP_SETGLOBAL, var->u.index); + break; + case VINDEXED: /* table is at top-3; pop 3 elements after operation */ + luaK_code2(fs, OP_SETTABLE, 3, 3); + break; + default: + LUA_INTERNALERROR("invalid var kind to store"); + } +} + + +static OpCode invertjump (OpCode op) { + switch (op) { + case OP_JMPNE: return OP_JMPEQ; + case OP_JMPEQ: return OP_JMPNE; + case OP_JMPLT: return OP_JMPGE; + case OP_JMPLE: return OP_JMPGT; + case OP_JMPGT: return OP_JMPLE; + case OP_JMPGE: return OP_JMPLT; + case OP_JMPT: case OP_JMPONT: return OP_JMPF; + case OP_JMPF: case OP_JMPONF: return OP_JMPT; + default: + LUA_INTERNALERROR("invalid jump instruction"); + return OP_END; /* to avoid warnings */ + } +} + + +static void luaK_patchlistaux (FuncState *fs, int list, int target, + OpCode special, int special_target) { + Instruction *code = fs->f->code; + while (list != NO_JUMP) { + int next = luaK_getjump(fs, list); + Instruction *i = &code[list]; + OpCode op = GET_OPCODE(*i); + if (op == special) /* this `op' already has a value */ + luaK_fixjump(fs, list, special_target); + else { + luaK_fixjump(fs, list, target); /* do the patch */ + if (op == OP_JMPONT) /* remove eventual values */ + SET_OPCODE(*i, OP_JMPT); + else if (op == OP_JMPONF) + SET_OPCODE(*i, OP_JMPF); + } + list = next; + } +} + + +void luaK_patchlist (FuncState *fs, int list, int target) { + if (target == fs->lasttarget) /* same target that list `jlt'? */ + luaK_concat(fs, &fs->jlt, list); /* delay fixing */ + else + luaK_patchlistaux(fs, list, target, OP_END, 0); +} + + +static int need_value (FuncState *fs, int list, OpCode hasvalue) { + /* check whether list has a jump without a value */ + for (; list != NO_JUMP; list = luaK_getjump(fs, list)) + if (GET_OPCODE(fs->f->code[list]) != hasvalue) return 1; + return 0; /* not found */ +} + + +void luaK_concat (FuncState *fs, int *l1, int l2) { + if (*l1 == NO_JUMP) + *l1 = l2; + else { + int list = *l1; + for (;;) { /* traverse `l1' */ + int next = luaK_getjump(fs, list); + if (next == NO_JUMP) { /* end of list? */ + luaK_fixjump(fs, list, l2); + return; + } + list = next; + } + } +} + + +static void luaK_testgo (FuncState *fs, expdesc *v, int invert, OpCode jump) { + int prevpos; /* position of last instruction */ + Instruction *previous; + int *golist, *exitlist; + if (!invert) { + golist = &v->u.l.f; /* go if false */ + exitlist = &v->u.l.t; /* exit if true */ + } + else { + golist = &v->u.l.t; /* go if true */ + exitlist = &v->u.l.f; /* exit if false */ + } + discharge1(fs, v); + prevpos = fs->pc-1; + previous = &fs->f->code[prevpos]; + LUA_ASSERT(*previous==previous_instruction(fs), "no jump allowed here"); + if (!ISJUMP(GET_OPCODE(*previous))) + prevpos = luaK_code1(fs, jump, NO_JUMP); + else { /* last instruction is already a jump */ + if (invert) + SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous))); + } + luaK_concat(fs, exitlist, prevpos); /* insert last jump in `exitlist' */ + luaK_patchlist(fs, *golist, luaK_getlabel(fs)); + *golist = NO_JUMP; +} + + +void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue) { + luaK_testgo(fs, v, 1, keepvalue ? OP_JMPONF : OP_JMPF); +} + + +static void luaK_goiffalse (FuncState *fs, expdesc *v, int keepvalue) { + luaK_testgo(fs, v, 0, keepvalue ? OP_JMPONT : OP_JMPT); +} + + +static int code_label (FuncState *fs, OpCode op, int arg) { + luaK_getlabel(fs); /* those instructions may be jump targets */ + return luaK_code1(fs, op, arg); +} + + +void luaK_tostack (LexState *ls, expdesc *v, int onlyone) { + FuncState *fs = ls->fs; + if (!discharge(fs, v)) { /* `v' is an expression? */ + OpCode previous = GET_OPCODE(fs->f->code[fs->pc-1]); + if (!ISJUMP(previous) && v->u.l.f == NO_JUMP && v->u.l.t == NO_JUMP) { + /* expression has no jumps */ + if (onlyone) + luaK_setcallreturns(fs, 1); /* call must return 1 value */ + } + else { /* expression has jumps */ + int final; /* position after whole expression */ + int j = NO_JUMP; /* eventual jump over values */ + int p_nil = NO_JUMP; /* position of an eventual PUSHNIL */ + int p_1 = NO_JUMP; /* position of an eventual PUSHINT */ + if (ISJUMP(previous) || need_value(fs, v->u.l.f, OP_JMPONF) + || need_value(fs, v->u.l.t, OP_JMPONT)) { + /* expression needs values */ + if (ISJUMP(previous)) + luaK_concat(fs, &v->u.l.t, fs->pc-1); /* put `previous' in t. list */ + else { + j = code_label(fs, OP_JMP, NO_JUMP); /* to jump over both pushes */ + /* correct stack for compiler and symbolic execution */ + luaK_adjuststack(fs, 1); + } + p_nil = code_label(fs, OP_PUSHNILJMP, 0); + p_1 = code_label(fs, OP_PUSHINT, 1); + luaK_patchlist(fs, j, luaK_getlabel(fs)); + } + final = luaK_getlabel(fs); + luaK_patchlistaux(fs, v->u.l.f, p_nil, OP_JMPONF, final); + luaK_patchlistaux(fs, v->u.l.t, p_1, OP_JMPONT, final); + v->u.l.f = v->u.l.t = NO_JUMP; + } + } +} + + +void luaK_prefix (LexState *ls, UnOpr op, expdesc *v) { + FuncState *fs = ls->fs; + if (op == OPR_MINUS) { + luaK_tostack(ls, v, 1); + luaK_code0(fs, OP_MINUS); + } + else { /* op == NOT */ + Instruction *previous; + discharge1(fs, v); + previous = &fs->f->code[fs->pc-1]; + if (ISJUMP(GET_OPCODE(*previous))) + SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous))); + else + luaK_code0(fs, OP_NOT); + /* interchange true and false lists */ + { int temp = v->u.l.f; v->u.l.f = v->u.l.t; v->u.l.t = temp; } + } +} + + +void luaK_infix (LexState *ls, BinOpr op, expdesc *v) { + FuncState *fs = ls->fs; + switch (op) { + case OPR_AND: + luaK_goiftrue(fs, v, 1); + break; + case OPR_OR: + luaK_goiffalse(fs, v, 1); + break; + default: + luaK_tostack(ls, v, 1); /* all other binary operators need a value */ + } +} + + + +static const struct { + OpCode opcode; /* opcode for each binary operator */ + int arg; /* default argument for the opcode */ +} codes[] = { /* ORDER OPR */ + {OP_ADD, 0}, {OP_SUB, 0}, {OP_MULT, 0}, {OP_DIV, 0}, + {OP_POW, 0}, {OP_CONCAT, 2}, + {OP_JMPNE, NO_JUMP}, {OP_JMPEQ, NO_JUMP}, + {OP_JMPLT, NO_JUMP}, {OP_JMPLE, NO_JUMP}, + {OP_JMPGT, NO_JUMP}, {OP_JMPGE, NO_JUMP} +}; + + +void luaK_posfix (LexState *ls, BinOpr op, expdesc *v1, expdesc *v2) { + FuncState *fs = ls->fs; + switch (op) { + case OPR_AND: { + LUA_ASSERT(v1->u.l.t == NO_JUMP, "list must be closed"); + discharge1(fs, v2); + v1->u.l.t = v2->u.l.t; + luaK_concat(fs, &v1->u.l.f, v2->u.l.f); + break; + } + case OPR_OR: { + LUA_ASSERT(v1->u.l.f == NO_JUMP, "list must be closed"); + discharge1(fs, v2); + v1->u.l.f = v2->u.l.f; + luaK_concat(fs, &v1->u.l.t, v2->u.l.t); + break; + } + default: { + luaK_tostack(ls, v2, 1); /* `v2' must be a value */ + luaK_code1(fs, codes[op].opcode, codes[op].arg); + } + } +} + + +static void codelineinfo (FuncState *fs) { + Proto *f = fs->f; + LexState *ls = fs->ls; + if (ls->lastline > fs->lastline) { + luaM_growvector(fs->L, f->lineinfo, f->nlineinfo, 2, int, + "line info overflow", MAX_INT); + if (ls->lastline > fs->lastline+1) + f->lineinfo[f->nlineinfo++] = -(ls->lastline - (fs->lastline+1)); + f->lineinfo[f->nlineinfo++] = fs->pc; + fs->lastline = ls->lastline; + } +} + + +int luaK_code0 (FuncState *fs, OpCode o) { + return luaK_code2(fs, o, 0, 0); +} + + +int luaK_code1 (FuncState *fs, OpCode o, int arg1) { + return luaK_code2(fs, o, arg1, 0); +} + + +int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) { + Instruction i = previous_instruction(fs); + int delta = luaK_opproperties[o].push - luaK_opproperties[o].pop; + int optm = 0; /* 1 when there is an optimization */ + switch (o) { + case OP_CLOSURE: { + delta = -arg2+1; + break; + } + case OP_SETTABLE: { + delta = -arg2; + break; + } + case OP_SETLIST: { + if (arg2 == 0) return NO_JUMP; /* nothing to do */ + delta = -arg2; + break; + } + case OP_SETMAP: { + if (arg1 == 0) return NO_JUMP; /* nothing to do */ + delta = -2*arg1; + break; + } + case OP_RETURN: { + if (GET_OPCODE(i) == OP_CALL && GETARG_B(i) == MULT_RET) { + SET_OPCODE(i, OP_TAILCALL); + SETARG_B(i, arg1); + optm = 1; + } + break; + } + case OP_PUSHNIL: { + if (arg1 == 0) return NO_JUMP; /* nothing to do */ + delta = arg1; + switch(GET_OPCODE(i)) { + case OP_PUSHNIL: SETARG_U(i, GETARG_U(i)+arg1); optm = 1; break; + default: break; + } + break; + } + case OP_POP: { + if (arg1 == 0) return NO_JUMP; /* nothing to do */ + delta = -arg1; + switch(GET_OPCODE(i)) { + case OP_SETTABLE: SETARG_B(i, GETARG_B(i)+arg1); optm = 1; break; + default: break; + } + break; + } + case OP_GETTABLE: { + switch(GET_OPCODE(i)) { + case OP_PUSHSTRING: /* `t.x' */ + SET_OPCODE(i, OP_GETDOTTED); + optm = 1; + break; + case OP_GETLOCAL: /* `t[i]' */ + SET_OPCODE(i, OP_GETINDEXED); + optm = 1; + break; + default: break; + } + break; + } + case OP_ADD: { + switch(GET_OPCODE(i)) { + case OP_PUSHINT: SET_OPCODE(i, OP_ADDI); optm = 1; break; /* `a+k' */ + default: break; + } + break; + } + case OP_SUB: { + switch(GET_OPCODE(i)) { + case OP_PUSHINT: /* `a-k' */ + i = CREATE_S(OP_ADDI, -GETARG_S(i)); + optm = 1; + break; + default: break; + } + break; + } + case OP_CONCAT: { + delta = -arg1+1; + switch(GET_OPCODE(i)) { + case OP_CONCAT: /* `a..b..c' */ + SETARG_U(i, GETARG_U(i)+1); + optm = 1; + break; + default: break; + } + break; + } + case OP_MINUS: { + switch(GET_OPCODE(i)) { + case OP_PUSHINT: /* `-k' */ + SETARG_S(i, -GETARG_S(i)); + optm = 1; + break; + case OP_PUSHNUM: /* `-k' */ + SET_OPCODE(i, OP_PUSHNEGNUM); + optm = 1; + break; + default: break; + } + break; + } + case OP_JMPNE: { + if (i == CREATE_U(OP_PUSHNIL, 1)) { /* `a~=nil' */ + i = CREATE_S(OP_JMPT, NO_JUMP); + optm = 1; + } + break; + } + case OP_JMPEQ: { + if (i == CREATE_U(OP_PUSHNIL, 1)) { /* `a==nil' */ + i = CREATE_0(OP_NOT); + delta = -1; /* just undo effect of previous PUSHNIL */ + optm = 1; + } + break; + } + case OP_JMPT: + case OP_JMPONT: { + switch (GET_OPCODE(i)) { + case OP_NOT: { + i = CREATE_S(OP_JMPF, NO_JUMP); + optm = 1; + break; + } + case OP_PUSHINT: { + if (o == OP_JMPT) { /* JMPONT must keep original integer value */ + i = CREATE_S(OP_JMP, NO_JUMP); + optm = 1; + } + break; + } + case OP_PUSHNIL: { + if (GETARG_U(i) == 1) { + fs->pc--; /* erase previous instruction */ + luaK_deltastack(fs, -1); /* correct stack */ + return NO_JUMP; + } + break; + } + default: break; + } + break; + } + case OP_JMPF: + case OP_JMPONF: { + switch (GET_OPCODE(i)) { + case OP_NOT: { + i = CREATE_S(OP_JMPT, NO_JUMP); + optm = 1; + break; + } + case OP_PUSHINT: { /* `while 1 do ...' */ + fs->pc--; /* erase previous instruction */ + luaK_deltastack(fs, -1); /* correct stack */ + return NO_JUMP; + } + case OP_PUSHNIL: { /* `repeat ... until nil' */ + if (GETARG_U(i) == 1) { + i = CREATE_S(OP_JMP, NO_JUMP); + optm = 1; + } + break; + } + default: break; + } + break; + } + case OP_GETDOTTED: + case OP_GETINDEXED: + case OP_TAILCALL: + case OP_ADDI: { + LUA_INTERNALERROR("instruction used only for optimizations"); + break; + } + default: { + LUA_ASSERT(delta != VD, "invalid delta"); + break; + } + } + luaK_deltastack(fs, delta); + if (optm) { /* optimize: put instruction in place of last one */ + fs->f->code[fs->pc-1] = i; /* change previous instruction */ + return fs->pc-1; /* do not generate new instruction */ + } + /* else build new instruction */ + switch ((enum Mode)luaK_opproperties[o].mode) { + case iO: i = CREATE_0(o); break; + case iU: i = CREATE_U(o, arg1); break; + case iS: i = CREATE_S(o, arg1); break; + case iAB: i = CREATE_AB(o, arg1, arg2); break; + } + codelineinfo(fs); + /* put new instruction in code array */ + luaM_growvector(fs->L, fs->f->code, fs->pc, 1, Instruction, + "code size overflow", MAX_INT); + fs->f->code[fs->pc] = i; + return fs->pc++; +} + + +const struct OpProperties luaK_opproperties[NUM_OPCODES] = { + {iO, 0, 0}, /* OP_END */ + {iU, 0, 0}, /* OP_RETURN */ + {iAB, 0, 0}, /* OP_CALL */ + {iAB, 0, 0}, /* OP_TAILCALL */ + {iU, VD, 0}, /* OP_PUSHNIL */ + {iU, VD, 0}, /* OP_POP */ + {iS, 1, 0}, /* OP_PUSHINT */ + {iU, 1, 0}, /* OP_PUSHSTRING */ + {iU, 1, 0}, /* OP_PUSHNUM */ + {iU, 1, 0}, /* OP_PUSHNEGNUM */ + {iU, 1, 0}, /* OP_PUSHUPVALUE */ + {iU, 1, 0}, /* OP_GETLOCAL */ + {iU, 1, 0}, /* OP_GETGLOBAL */ + {iO, 1, 2}, /* OP_GETTABLE */ + {iU, 1, 1}, /* OP_GETDOTTED */ + {iU, 1, 1}, /* OP_GETINDEXED */ + {iU, 2, 1}, /* OP_PUSHSELF */ + {iU, 1, 0}, /* OP_CREATETABLE */ + {iU, 0, 1}, /* OP_SETLOCAL */ + {iU, 0, 1}, /* OP_SETGLOBAL */ + {iAB, VD, 0}, /* OP_SETTABLE */ + {iAB, VD, 0}, /* OP_SETLIST */ + {iU, VD, 0}, /* OP_SETMAP */ + {iO, 1, 2}, /* OP_ADD */ + {iS, 1, 1}, /* OP_ADDI */ + {iO, 1, 2}, /* OP_SUB */ + {iO, 1, 2}, /* OP_MULT */ + {iO, 1, 2}, /* OP_DIV */ + {iO, 1, 2}, /* OP_POW */ + {iU, VD, 0}, /* OP_CONCAT */ + {iO, 1, 1}, /* OP_MINUS */ + {iO, 1, 1}, /* OP_NOT */ + {iS, 0, 2}, /* OP_JMPNE */ + {iS, 0, 2}, /* OP_JMPEQ */ + {iS, 0, 2}, /* OP_JMPLT */ + {iS, 0, 2}, /* OP_JMPLE */ + {iS, 0, 2}, /* OP_JMPGT */ + {iS, 0, 2}, /* OP_JMPGE */ + {iS, 0, 1}, /* OP_JMPT */ + {iS, 0, 1}, /* OP_JMPF */ + {iS, 0, 1}, /* OP_JMPONT */ + {iS, 0, 1}, /* OP_JMPONF */ + {iS, 0, 0}, /* OP_JMP */ + {iO, 0, 0}, /* OP_PUSHNILJMP */ + {iS, 0, 0}, /* OP_FORPREP */ + {iS, 0, 3}, /* OP_FORLOOP */ + {iS, 2, 0}, /* OP_LFORPREP */ + {iS, 0, 3}, /* OP_LFORLOOP */ + {iAB, VD, 0} /* OP_CLOSURE */ +}; + diff --git a/src/lua/lcode.h b/src/lua/lcode.h new file mode 100644 index 00000000..c413c897 --- /dev/null +++ b/src/lua/lcode.h @@ -0,0 +1,70 @@ +/* +** $Id: lcode.h,v 1.2 2001/11/26 23:00:23 darkgod Exp $ +** Code generator for Lua +** See Copyright Notice in lua.h +*/ + +#ifndef lcode_h +#define lcode_h + +#include "llex.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" + + +/* +** Marks the end of a patch list. It is an invalid value both as an absolute +** address, and as a list link (would link an element to itself). +*/ +#define NO_JUMP (-1) + + +/* +** grep "ORDER OPR" if you change these enums +*/ +typedef enum BinOpr { + OPR_ADD, OPR_SUB, OPR_MULT, OPR_DIV, OPR_POW, + OPR_CONCAT, + OPR_NE, OPR_EQ, OPR_LT, OPR_LE, OPR_GT, OPR_GE, + OPR_AND, OPR_OR, + OPR_NOBINOPR +} BinOpr; + +typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_NOUNOPR } UnOpr; + + +enum Mode {iO, iU, iS, iAB}; /* instruction format */ + +#define VD 100 /* flag for variable delta */ + +extern const struct OpProperties { + char mode; + unsigned char push; + unsigned char pop; +} luaK_opproperties[NUM_OPCODES]; + + +void luaK_error (LexState *ls, const char *msg); +int luaK_code0 (FuncState *fs, OpCode o); +int luaK_code1 (FuncState *fs, OpCode o, int arg1); +int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2); +int luaK_jump (FuncState *fs); +void luaK_patchlist (FuncState *fs, int list, int target); +void luaK_concat (FuncState *fs, int *l1, int l2); +void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue); +int luaK_getlabel (FuncState *fs); +void luaK_deltastack (FuncState *fs, int delta); +void luaK_kstr (LexState *ls, int c); +void luaK_number (FuncState *fs, Number f); +void luaK_adjuststack (FuncState *fs, int n); +int luaK_lastisopen (FuncState *fs); +void luaK_setcallreturns (FuncState *fs, int nresults); +void luaK_tostack (LexState *ls, expdesc *v, int onlyone); +void luaK_storevar (LexState *ls, const expdesc *var); +void luaK_prefix (LexState *ls, UnOpr op, expdesc *v); +void luaK_infix (LexState *ls, BinOpr op, expdesc *v); +void luaK_posfix (LexState *ls, BinOpr op, expdesc *v1, expdesc *v2); + + +#endif diff --git a/src/lua/ldblib.c b/src/lua/ldblib.c new file mode 100644 index 00000000..481f1d6f --- /dev/null +++ b/src/lua/ldblib.c @@ -0,0 +1,188 @@ +/* +** $Id: ldblib.c,v 1.2 2001/11/26 23:00:23 darkgod Exp $ +** Interface from Lua to its debug API +** See Copyright Notice in lua.h +*/ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "lua.h" + +#include "lauxlib.h" +#include "luadebug.h" +#include "lualib.h" + + + +static void settabss (lua_State *L, const char *i, const char *v) { + lua_pushstring(L, i); + lua_pushstring(L, v); + lua_settable(L, -3); +} + + +static void settabsi (lua_State *L, const char *i, int v) { + lua_pushstring(L, i); + lua_pushnumber(L, v); + lua_settable(L, -3); +} + + +static int getinfo (lua_State *L) { + lua_Debug ar; + const char *options = luaL_opt_string(L, 2, "flnSu"); + char buff[20]; + if (lua_isnumber(L, 1)) { + if (!lua_getstack(L, (int)lua_tonumber(L, 1), &ar)) { + lua_pushnil(L); /* level out of range */ + return 1; + } + } + else if (lua_isfunction(L, 1)) { + lua_pushvalue(L, 1); + sprintf(buff, ">%.10s", options); + options = buff; + } + else + luaL_argerror(L, 1, "function or level expected"); + if (!lua_getinfo(L, options, &ar)) + luaL_argerror(L, 2, "invalid option"); + lua_newtable(L); + for (; *options; options++) { + switch (*options) { + case 'S': + settabss(L, "source", ar.source); + if (ar.source) + settabss(L, "short_src", ar.short_src); + settabsi(L, "linedefined", ar.linedefined); + settabss(L, "what", ar.what); + break; + case 'l': + settabsi(L, "currentline", ar.currentline); + break; + case 'u': + settabsi(L, "nups", ar.nups); + break; + case 'n': + settabss(L, "name", ar.name); + settabss(L, "namewhat", ar.namewhat); + break; + case 'f': + lua_pushstring(L, "func"); + lua_pushvalue(L, -3); + lua_settable(L, -3); + break; + } + } + return 1; /* return table */ +} + + +static int getlocal (lua_State *L) { + lua_Debug ar; + const char *name; + if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */ + luaL_argerror(L, 1, "level out of range"); + name = lua_getlocal(L, &ar, luaL_check_int(L, 2)); + if (name) { + lua_pushstring(L, name); + lua_pushvalue(L, -2); + return 2; + } + else { + lua_pushnil(L); + return 1; + } +} + + +static int setlocal (lua_State *L) { + lua_Debug ar; + if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */ + luaL_argerror(L, 1, "level out of range"); + luaL_checkany(L, 3); + lua_pushstring(L, lua_setlocal(L, &ar, luaL_check_int(L, 2))); + return 1; +} + + + +/* dummy variables (to define unique addresses) */ +static char key1, key2; +#define KEY_CALLHOOK (&key1) +#define KEY_LINEHOOK (&key2) + + +static void hookf (lua_State *L, void *key) { + lua_getregistry(L); + lua_pushuserdata(L, key); + lua_gettable(L, -2); + if (lua_isfunction(L, -1)) { + lua_pushvalue(L, 1); + lua_rawcall(L, 1, 0); + } + else + lua_pop(L, 1); /* pop result from gettable */ + lua_pop(L, 1); /* pop table */ +} + + +static void callf (lua_State *L, lua_Debug *ar) { + lua_pushstring(L, ar->event); + hookf(L, KEY_CALLHOOK); +} + + +static void linef (lua_State *L, lua_Debug *ar) { + lua_pushnumber(L, ar->currentline); + hookf(L, KEY_LINEHOOK); +} + + +static void sethook (lua_State *L, void *key, lua_Hook hook, + lua_Hook (*sethookf)(lua_State * L, lua_Hook h)) { + lua_settop(L, 1); + if (lua_isnil(L, 1)) + (*sethookf)(L, NULL); + else if (lua_isfunction(L, 1)) + (*sethookf)(L, hook); + else + luaL_argerror(L, 1, "function expected"); + lua_getregistry(L); + lua_pushuserdata(L, key); + lua_pushvalue(L, -1); /* dup key */ + lua_gettable(L, -3); /* get old value */ + lua_pushvalue(L, -2); /* key (again) */ + lua_pushvalue(L, 1); + lua_settable(L, -5); /* set new value */ +} + + +static int setcallhook (lua_State *L) { + sethook(L, KEY_CALLHOOK, callf, lua_setcallhook); + return 1; +} + + +static int setlinehook (lua_State *L) { + sethook(L, KEY_LINEHOOK, linef, lua_setlinehook); + return 1; +} + + +static const struct luaL_reg dblib[] = { + {"getlocal", getlocal}, + {"getinfo", getinfo}, + {"setcallhook", setcallhook}, + {"setlinehook", setlinehook}, + {"setlocal", setlocal} +}; + + +LUALIB_API void lua_dblibopen (lua_State *L) { + luaL_openl(L, dblib); +} + diff --git a/src/lua/ldebug.c b/src/lua/ldebug.c new file mode 100644 index 00000000..02481b4c --- /dev/null +++ b/src/lua/ldebug.c @@ -0,0 +1,466 @@ +/* +** $Id: ldebug.c,v 1.2 2001/11/26 23:00:23 darkgod Exp $ +** Debug Interface +** See Copyright Notice in lua.h +*/ + + +#include <stdlib.h> + +#include "lua.h" + +#include "lapi.h" +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "luadebug.h" + + + +static const char *getfuncname (lua_State *L, StkId f, const char **name); + + +static void setnormalized (TObject *d, const TObject *s) { + if (ttype(s) == LUA_TMARK) { + clvalue(d) = infovalue(s)->func; + ttype(d) = LUA_TFUNCTION; + } + else *d = *s; +} + + +static int isLmark (StkId o) { + return (o && ttype(o) == LUA_TMARK && !infovalue(o)->func->isC); +} + + +LUA_API lua_Hook lua_setcallhook (lua_State *L, lua_Hook func) { + lua_Hook oldhook = L->callhook; + L->callhook = func; + return oldhook; +} + + +LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func) { + lua_Hook oldhook = L->linehook; + L->linehook = func; + return oldhook; +} + + +static StkId aux_stackedfunction (lua_State *L, int level, StkId top) { + int i; + for (i = (top-1) - L->stack; i>=0; i--) { + if (is_T_MARK(L->stack[i].ttype)) { + if (level == 0) + return L->stack+i; + level--; + } + } + return NULL; +} + + +LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { + StkId f = aux_stackedfunction(L, level, L->top); + if (f == NULL) return 0; /* there is no such level */ + else { + ar->_func = f; + return 1; + } +} + + +static int nups (StkId f) { + switch (ttype(f)) { + case LUA_TFUNCTION: + return clvalue(f)->nupvalues; + case LUA_TMARK: + return infovalue(f)->func->nupvalues; + default: + return 0; + } +} + + +int luaG_getline (int *lineinfo, int pc, int refline, int *prefi) { + int refi; + if (lineinfo == NULL || pc == -1) + return -1; /* no line info or function is not active */ + refi = prefi ? *prefi : 0; + if (lineinfo[refi] < 0) + refline += -lineinfo[refi++]; + LUA_ASSERT(lineinfo[refi] >= 0, "invalid line info"); + while (lineinfo[refi] > pc) { + refline--; + refi--; + if (lineinfo[refi] < 0) + refline -= -lineinfo[refi--]; + LUA_ASSERT(lineinfo[refi] >= 0, "invalid line info"); + } + for (;;) { + int nextline = refline + 1; + int nextref = refi + 1; + if (lineinfo[nextref] < 0) + nextline += -lineinfo[nextref++]; + LUA_ASSERT(lineinfo[nextref] >= 0, "invalid line info"); + if (lineinfo[nextref] > pc) + break; + refline = nextline; + refi = nextref; + } + if (prefi) *prefi = refi; + return refline; +} + + +static int currentpc (StkId f) { + CallInfo *ci = infovalue(f); + LUA_ASSERT(isLmark(f), "function has no pc"); + if (ci->pc) + return (*ci->pc - ci->func->f.l->code) - 1; + else + return -1; /* function is not active */ +} + + +static int currentline (StkId f) { + if (!isLmark(f)) + return -1; /* only active lua functions have current-line information */ + else { + CallInfo *ci = infovalue(f); + int *lineinfo = ci->func->f.l->lineinfo; + return luaG_getline(lineinfo, currentpc(f), 1, NULL); + } +} + + + +static Proto *getluaproto (StkId f) { + return (isLmark(f) ? infovalue(f)->func->f.l : NULL); +} + + +LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; + StkId f = ar->_func; + Proto *fp = getluaproto(f); + if (!fp) return NULL; /* `f' is not a Lua function? */ + name = luaF_getlocalname(fp, n, currentpc(f)); + if (!name) return NULL; + luaA_pushobject(L, (f+1)+(n-1)); /* push value */ + return name; +} + + +LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; + StkId f = ar->_func; + Proto *fp = getluaproto(f); + L->top--; /* pop new value */ + if (!fp) return NULL; /* `f' is not a Lua function? */ + name = luaF_getlocalname(fp, n, currentpc(f)); + if (!name || name[0] == '(') return NULL; /* `(' starts private locals */ + *((f+1)+(n-1)) = *L->top; + return name; +} + + +static void infoLproto (lua_Debug *ar, Proto *f) { + ar->source = f->source->str; + ar->linedefined = f->lineDefined; + ar->what = "Lua"; +} + + +static void funcinfo (lua_State *L, lua_Debug *ar, StkId func) { + Closure *cl = NULL; + switch (ttype(func)) { + case LUA_TFUNCTION: + cl = clvalue(func); + break; + case LUA_TMARK: + cl = infovalue(func)->func; + break; + default: + lua_error(L, "value for `lua_getinfo' is not a function"); + } + if (cl->isC) { + ar->source = "=C"; + ar->linedefined = -1; + ar->what = "C"; + } + else + infoLproto(ar, cl->f.l); + luaO_chunkid(ar->short_src, ar->source, sizeof(ar->short_src)); + if (ar->linedefined == 0) + ar->what = "main"; +} + + +static const char *travtagmethods (lua_State *L, const TObject *o) { + if (ttype(o) == LUA_TFUNCTION) { + int e; + for (e=0; e<TM_N; e++) { + int t; + for (t=0; t<=L->last_tag; t++) + if (clvalue(o) == luaT_gettm(L, t, e)) + return luaT_eventname[e]; + } + } + return NULL; +} + + +static const char *travglobals (lua_State *L, const TObject *o) { + Hash *g = L->gt; + int i; + for (i=0; i<g->size; i++) { + if (luaO_equalObj(o, val(node(g, i))) && + ttype(key(node(g, i))) == LUA_TSTRING) + return tsvalue(key(node(g, i)))->str; + } + return NULL; +} + + +static void getname (lua_State *L, StkId f, lua_Debug *ar) { + TObject o; + setnormalized(&o, f); + /* try to find a name for given function */ + if ((ar->name = travglobals(L, &o)) != NULL) + ar->namewhat = "global"; + /* not found: try tag methods */ + else if ((ar->name = travtagmethods(L, &o)) != NULL) + ar->namewhat = "tag-method"; + else ar->namewhat = ""; /* not found at all */ +} + + +LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { + StkId func; + int isactive = (*what != '>'); + if (isactive) + func = ar->_func; + else { + what++; /* skip the '>' */ + func = L->top - 1; + } + for (; *what; what++) { + switch (*what) { + case 'S': { + funcinfo(L, ar, func); + break; + } + case 'l': { + ar->currentline = currentline(func); + break; + } + case 'u': { + ar->nups = nups(func); + break; + } + case 'n': { + ar->namewhat = (isactive) ? getfuncname(L, func, &ar->name) : NULL; + if (ar->namewhat == NULL) + getname(L, func, ar); + break; + } + case 'f': { + setnormalized(L->top, func); + incr_top; /* push function */ + break; + } + default: return 0; /* invalid option */ + } + } + if (!isactive) L->top--; /* pop function */ + return 1; +} + + +/* +** {====================================================== +** Symbolic Execution +** ======================================================= +*/ + + +static int pushpc (int *stack, int pc, int top, int n) { + while (n--) + stack[top++] = pc-1; + return top; +} + + +static Instruction luaG_symbexec (const Proto *pt, int lastpc, int stackpos) { + int stack[MAXSTACK]; /* stores last instruction that changed a stack entry */ + const Instruction *code = pt->code; + int top = pt->numparams; + int pc = 0; + if (pt->is_vararg) /* varargs? */ + top++; /* `arg' */ + while (pc < lastpc) { + const Instruction i = code[pc++]; + LUA_ASSERT(0 <= top && top <= pt->maxstacksize, "wrong stack"); + switch (GET_OPCODE(i)) { + case OP_RETURN: { + LUA_ASSERT(top >= GETARG_U(i), "wrong stack"); + top = GETARG_U(i); + break; + } + case OP_TAILCALL: { + LUA_ASSERT(top >= GETARG_A(i), "wrong stack"); + top = GETARG_B(i); + break; + } + case OP_CALL: { + int nresults = GETARG_B(i); + if (nresults == MULT_RET) nresults = 1; + LUA_ASSERT(top >= GETARG_A(i), "wrong stack"); + top = pushpc(stack, pc, GETARG_A(i), nresults); + break; + } + case OP_PUSHNIL: { + top = pushpc(stack, pc, top, GETARG_U(i)); + break; + } + case OP_POP: { + top -= GETARG_U(i); + break; + } + case OP_SETTABLE: + case OP_SETLIST: { + top -= GETARG_B(i); + break; + } + case OP_SETMAP: { + top -= 2*GETARG_U(i); + break; + } + case OP_CONCAT: { + top -= GETARG_U(i); + stack[top++] = pc-1; + break; + } + case OP_CLOSURE: { + top -= GETARG_B(i); + stack[top++] = pc-1; + break; + } + case OP_JMPONT: + case OP_JMPONF: { + int newpc = pc + GETARG_S(i); + /* jump is forward and do not skip `lastpc'? */ + if (pc < newpc && newpc <= lastpc) { + stack[top-1] = pc-1; /* value comes from `and'/`or' */ + pc = newpc; /* do the jump */ + } + else + top--; /* do not jump; pop value */ + break; + } + default: { + OpCode op = GET_OPCODE(i); + LUA_ASSERT(luaK_opproperties[op].push != VD, + "invalid opcode for default"); + top -= luaK_opproperties[op].pop; + LUA_ASSERT(top >= 0, "wrong stack"); + top = pushpc(stack, pc, top, luaK_opproperties[op].push); + } + } + } + return code[stack[stackpos]]; +} + + +static const char *getobjname (lua_State *L, StkId obj, const char **name) { + StkId func = aux_stackedfunction(L, 0, obj); + if (!isLmark(func)) + return NULL; /* not an active Lua function */ + else { + Proto *p = infovalue(func)->func->f.l; + int pc = currentpc(func); + int stackpos = obj - (func+1); /* func+1 == function base */ + Instruction i = luaG_symbexec(p, pc, stackpos); + LUA_ASSERT(pc != -1, "function must be active"); + switch (GET_OPCODE(i)) { + case OP_GETGLOBAL: { + *name = p->kstr[GETARG_U(i)]->str; + return "global"; + } + case OP_GETLOCAL: { + *name = luaF_getlocalname(p, GETARG_U(i)+1, pc); + LUA_ASSERT(*name, "local must exist"); + return "local"; + } + case OP_PUSHSELF: + case OP_GETDOTTED: { + *name = p->kstr[GETARG_U(i)]->str; + return "field"; + } + default: + return NULL; /* no useful name found */ + } + } +} + + +static const char *getfuncname (lua_State *L, StkId f, const char **name) { + StkId func = aux_stackedfunction(L, 0, f); /* calling function */ + if (!isLmark(func)) + return NULL; /* not an active Lua function */ + else { + Proto *p = infovalue(func)->func->f.l; + int pc = currentpc(func); + Instruction i; + if (pc == -1) return NULL; /* function is not activated */ + i = p->code[pc]; + switch (GET_OPCODE(i)) { + case OP_CALL: case OP_TAILCALL: + return getobjname(L, (func+1)+GETARG_A(i), name); + default: + return NULL; /* no useful name found */ + } + } +} + + +/* }====================================================== */ + + +void luaG_typeerror (lua_State *L, StkId o, const char *op) { + const char *name; + const char *kind = getobjname(L, o, &name); + const char *t = luaO_typename(o); + if (kind) + luaO_verror(L, "attempt to %.30s %.20s `%.40s' (a %.10s value)", + op, kind, name, t); + else + luaO_verror(L, "attempt to %.30s a %.10s value", op, t); +} + + +void luaG_binerror (lua_State *L, StkId p1, int t, const char *op) { + if (ttype(p1) == t) p1++; + LUA_ASSERT(ttype(p1) != t, "must be an error"); + luaG_typeerror(L, p1, op); +} + + +void luaG_ordererror (lua_State *L, StkId top) { + const char *t1 = luaO_typename(top-2); + const char *t2 = luaO_typename(top-1); + if (t1[2] == t2[2]) + luaO_verror(L, "attempt to compare two %.10s values", t1); + else + luaO_verror(L, "attempt to compare %.10s with %.10s", t1, t2); +} + diff --git a/src/lua/ldebug.h b/src/lua/ldebug.h new file mode 100644 index 00000000..76865616 --- /dev/null +++ b/src/lua/ldebug.h @@ -0,0 +1,21 @@ +/* +** $Id: ldebug.h,v 1.2 2001/11/26 23:00:23 darkgod Exp $ +** Auxiliary functions from Debug Interface module +** See Copyright Notice in lua.h +*/ + +#ifndef ldebug_h +#define ldebug_h + + +#include "lstate.h" +#include "luadebug.h" + + +void luaG_typeerror (lua_State *L, StkId o, const char *op); +void luaG_binerror (lua_State *L, StkId p1, int t, const char *op); +int luaG_getline (int *lineinfo, int pc, int refline, int *refi); +void luaG_ordererror (lua_State *L, StkId top); + + +#endif diff --git a/src/lua/ldo.c b/src/lua/ldo.c new file mode 100644 index 00000000..5f23bfd9 --- /dev/null +++ b/src/lua/ldo.c @@ -0,0 +1,385 @@ +/* +** $Id: ldo.c,v 1.7 2004/06/04 13:42:10 neil Exp $ +** Stack and Call structure of Lua +** See Copyright Notice in lua.h +*/ + + +#include <setjmp.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lundump.h" +#include "lvm.h" +#include "lzio.h" + + +/* space to handle stack overflow errors */ +#define EXTRA_STACK (2*LUA_MINSTACK) + + +void luaD_init (lua_State *L, int stacksize) { + L->stack = luaM_newvector(L, stacksize+EXTRA_STACK, TObject); + L->nblocks += stacksize*sizeof(TObject); + L->stack_last = L->stack+(stacksize-1); + L->stacksize = stacksize; + L->Cbase = L->top = L->stack; +} + + +void luaD_checkstack (lua_State *L, int n) { + if (L->stack_last - L->top <= n) { /* stack overflow? */ + if (L->stack_last-L->stack > (L->stacksize-1)) { + /* overflow while handling overflow */ + luaD_breakrun(L, LUA_ERRERR); /* break run without error message */ + } + else { + L->stack_last += EXTRA_STACK; /* to be used by error message */ + lua_error(L, "stack overflow"); + } + } +} + + +static void restore_stack_limit (lua_State *L) { + if (L->top - L->stack < L->stacksize - 1) + L->stack_last = L->stack + (L->stacksize-1); +} + + +/* +** Adjust stack. Set top to base+extra, pushing NILs if needed. +** (we cannot add base+extra unless we are sure it fits in the stack; +** otherwise the result of such operation on pointers is undefined) +*/ +void luaD_adjusttop (lua_State *L, StkId base, int extra) { + int diff = extra-(L->top-base); + if (diff <= 0) + L->top = base+extra; + else { + luaD_checkstack(L, diff); + while (diff--) + ttype(L->top++) = LUA_TNIL; + } +} + + +/* +** Open a hole inside the stack at `pos' +*/ +static void luaD_openstack (lua_State *L, StkId pos) { + int i = L->top-pos; + while (i--) pos[i+1] = pos[i]; + incr_top; +} + + +static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) { + StkId old_Cbase = L->Cbase; + StkId old_top = L->Cbase = L->top; + luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ + L->allowhooks = 0; /* cannot call hooks inside a hook */ + (*hook)(L, ar); + LUA_ASSERT(L->allowhooks == 0, "invalid allow"); + L->allowhooks = 1; + L->top = old_top; + L->Cbase = old_Cbase; +} + + +void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook) { + if (L->allowhooks) { + lua_Debug ar; + ar._func = func; + ar.event = "line"; + ar.currentline = line; + dohook(L, &ar, linehook); + } +} + + +static void luaD_callHook (lua_State *L, StkId func, lua_Hook callhook, + const char *event) { + if (L->allowhooks) { + lua_Debug ar; + ar._func = func; + ar.event = event; + infovalue(func)->pc = NULL; /* function is not active */ + dohook(L, &ar, callhook); + } +} + + +static StkId callCclosure (lua_State *L, const struct Closure *cl, StkId base) { + int nup = cl->nupvalues; /* number of upvalues */ + StkId old_Cbase = L->Cbase; + int n; + L->Cbase = base; /* new base for C function */ + luaD_checkstack(L, nup+LUA_MINSTACK); /* ensure minimum stack size */ + for (n=0; n<nup; n++) /* copy upvalues as extra arguments */ + *(L->top++) = cl->upvalue[n]; + n = (*cl->f.c)(L); /* do the actual call */ + L->Cbase = old_Cbase; /* restore old C base */ + return L->top - n; /* return index of first result */ +} + + +void luaD_callTM (lua_State *L, Closure *f, int nParams, int nResults) { + StkId base = L->top - nParams; + luaD_openstack(L, base); + clvalue(base) = f; + ttype(base) = LUA_TFUNCTION; + luaD_call(L, base, nResults); +} + + +/* +** Call a function (C or Lua). The function to be called is at *func. +** The arguments are on the stack, right after the function. +** When returns, the results are on the stack, starting at the original +** function position. +** The number of results is nResults, unless nResults=LUA_MULTRET. +*/ +void luaD_call (lua_State *L, StkId func, int nResults) { + lua_Hook callhook; + StkId firstResult; + CallInfo ci; + Closure *cl; + if (ttype(func) != LUA_TFUNCTION) { + /* `func' is not a function; check the `function' tag method */ + Closure *tm = luaT_gettmbyObj(L, func, TM_FUNCTION); + if (tm == NULL) + luaG_typeerror(L, func, "call"); + luaD_openstack(L, func); + clvalue(func) = tm; /* tag method is the new function to be called */ + ttype(func) = LUA_TFUNCTION; + } + cl = clvalue(func); + ci.func = cl; + infovalue(func) = &ci; + ttype(func) = LUA_TMARK; + callhook = L->callhook; + if (callhook) + luaD_callHook(L, func, callhook, "call"); + firstResult = (cl->isC ? callCclosure(L, cl, func+1) : + luaV_execute(L, cl, func+1)); + if (callhook) /* same hook that was active at entry */ + luaD_callHook(L, func, callhook, "return"); + LUA_ASSERT(ttype(func) == LUA_TMARK, "invalid tag"); + /* move results to `func' (to erase parameters and function) */ + if (nResults == LUA_MULTRET) { + while (firstResult < L->top) /* copy all results */ + *func++ = *firstResult++; + L->top = func; + } + else { /* copy at most `nResults' */ + for (; nResults > 0 && firstResult < L->top; nResults--) + *func++ = *firstResult++; + L->top = func; + for (; nResults > 0; nResults--) { /* if there are not enough results */ + ttype(L->top) = LUA_TNIL; /* adjust the stack */ + incr_top; /* must check stack space */ + } + } + luaC_checkGC(L); +} + + +/* +** Execute a protected call. +*/ +struct CallS { /* data to `f_call' */ + StkId func; + int nresults; +}; + +static void f_call (lua_State *L, void *ud) { + struct CallS *c = (struct CallS *)ud; + luaD_call(L, c->func, c->nresults); +} + + +LUA_API int lua_call (lua_State *L, int nargs, int nresults) { + StkId func = L->top - (nargs+1); /* function to be called */ + struct CallS c; + int status; + c.func = func; c.nresults = nresults; + status = luaD_runprotected(L, f_call, &c); + if (status != 0) /* an error occurred? */ + L->top = func; /* remove parameters from the stack */ + return status; +} + + +/* +** Execute a protected parser. +*/ +struct ParserS { /* data to `f_parser' */ + ZIO *z; + int bin; +}; + +static void f_parser (lua_State *L, void *ud) { + struct ParserS *p = (struct ParserS *)ud; + Proto *tf = p->bin ? luaU_undump(L, p->z) : luaY_parser(L, p->z); + luaV_Lclosure(L, tf, 0); +} + + +static int protectedparser (lua_State *L, ZIO *z, int bin) { + struct ParserS p; + unsigned long old_blocks; + int status; + p.z = z; p.bin = bin; + luaC_checkGC(L); + old_blocks = L->nblocks; + status = luaD_runprotected(L, f_parser, &p); + if (status == 0) { + /* add new memory to threshold (as it probably will stay) */ + L->GCthreshold += (L->nblocks - old_blocks); + } + else if (status == LUA_ERRRUN) /* an error occurred: correct error code */ + status = LUA_ERRSYNTAX; + return status; +} + + +static int parse_file (lua_State *L, const char *filename) { + ZIO z; + int status; + int bin; /* flag for file mode */ + int c; /* look ahead char */ + FILE *f = (filename == NULL) ? stdin : fopen(filename, "r"); + if (f == NULL) return LUA_ERRFILE; /* unable to open file */ + c = fgetc(f); + ungetc(c, f); + bin = (c == ID_CHUNK); + if (bin && f != stdin) { + f = freopen(filename, "rb", f); /* set binary mode */ + if (f == NULL) return LUA_ERRFILE; /* unable to reopen file */ + } + lua_pushstring(L, "@"); + lua_pushstring(L, (filename == NULL) ? "(stdin)" : filename); + lua_concat(L, 2); + filename = lua_tostring(L, -1); /* filename = '@'..filename */ + lua_pop(L, 1); /* OK: there is no GC during parser */ + luaZ_Fopen(&z, f, filename); + status = protectedparser(L, &z, bin); + if (f != stdin) + fclose(f); + return status; +} + + +LUA_API int lua_dofile (lua_State *L, const char *filename) { + int status = parse_file(L, filename); + if (status == 0) /* parse OK? */ + status = lua_call(L, 0, LUA_MULTRET); /* call main */ + return status; +} + + +static int parse_buffer (lua_State *L, const char *buff, size_t size, + const char *name) { + ZIO z; + if (!name) name = "?"; + luaZ_mopen(&z, buff, size, name); + return protectedparser(L, &z, buff[0]==ID_CHUNK); +} + + +LUA_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, const char *name) { + int status = parse_buffer(L, buff, size, name); + if (status == 0) /* parse OK? */ + status = lua_call(L, 0, LUA_MULTRET); /* call main */ + return status; +} + + +LUA_API int lua_dostring (lua_State *L, const char *str) { + return lua_dobuffer(L, str, strlen(str), str); +} + + +/* +** {====================================================== +** Error-recover functions (based on long jumps) +** ======================================================= +*/ + +/* chain list of long jump buffers */ +struct lua_longjmp { + jmp_buf b; + struct lua_longjmp *previous; + volatile int status; /* error code */ +}; + + +static void message (lua_State *L, const char *s) { + const TObject *em = luaH_getglobal(L, LUA_ERRORMESSAGE); + if (ttype(em) == LUA_TFUNCTION) { + *L->top = *em; + incr_top; + lua_pushstring(L, s); + luaD_call(L, L->top-2, 0); + } +} + + +/* +** Reports an error, and jumps up to the available recovery label +*/ +LUA_API void lua_error (lua_State *L, const char *s) { + if (s) message(L, s); + luaD_breakrun(L, LUA_ERRRUN); +} + + +void luaD_breakrun (lua_State *L, int errcode) { + if (L->errorJmp) { + L->errorJmp->status = errcode; + longjmp(L->errorJmp->b, 1); + } + else { + if (errcode != LUA_ERRMEM) + message(L, "unable to recover; exiting\n"); + exit(EXIT_FAILURE); + } +} + + +int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud) { + StkId oldCbase = L->Cbase; + StkId oldtop = L->top; + struct lua_longjmp lj; + int allowhooks = L->allowhooks; + lj.status = 0; + lj.previous = L->errorJmp; /* chain new error handler */ + L->errorJmp = &lj; + if (setjmp(lj.b) == 0) + (*f)(L, ud); + else { /* an error occurred: restore the state */ + L->allowhooks = allowhooks; + L->Cbase = oldCbase; + L->top = oldtop; + restore_stack_limit(L); + } + L->errorJmp = lj.previous; /* restore old error handler */ + return lj.status; +} + +/* }====================================================== */ + diff --git a/src/lua/ldo.h b/src/lua/ldo.h new file mode 100644 index 00000000..d948ad35 --- /dev/null +++ b/src/lua/ldo.h @@ -0,0 +1,33 @@ +/* +** $Id: ldo.h,v 1.3 2001/11/26 23:00:23 darkgod Exp $ +** Stack and Call structure of Lua +** See Copyright Notice in lua.h +*/ + +#ifndef ldo_h +#define ldo_h + + +#include "lobject.h" +#include "lstate.h" + + +/* +** macro to increment stack top. +** There must be always an empty slot at the L->stack.top +*/ +#define incr_top {if (L->top == L->stack_last) luaD_checkstack(L, 1); L->top++;} + + +void luaD_init (lua_State *L, int stacksize); +void luaD_adjusttop (lua_State *L, StkId base, int extra); +void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook); +void luaD_call (lua_State *L, StkId func, int nResults); +void luaD_callTM (lua_State *L, Closure *f, int nParams, int nResults); +void luaD_checkstack (lua_State *L, int n); + +void luaD_breakrun (lua_State *L, int errcode); +int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud); + + +#endif diff --git a/src/lua/lfunc.c b/src/lua/lfunc.c new file mode 100644 index 00000000..d3427653 --- /dev/null +++ b/src/lua/lfunc.c @@ -0,0 +1,109 @@ +/* +** $Id: lfunc.c,v 1.3 2001/11/26 23:00:23 darkgod Exp $ +** Auxiliary functions to manipulate prototypes and closures +** See Copyright Notice in lua.h +*/ + + +#include <stdlib.h> + +#include "lua.h" + +#include "lfunc.h" +#include "lmem.h" +#include "lstate.h" + + +#define sizeclosure(n) ((int)sizeof(Closure) + (int)sizeof(TObject)*((n)-1)) + + +Closure *luaF_newclosure (lua_State *L, int nelems) { + int size = sizeclosure(nelems); + Closure *c = (Closure *)luaM_malloc(L, size); + c->next = L->rootcl; + L->rootcl = c; + c->mark = c; + c->nupvalues = nelems; + L->nblocks += size; + return c; +} + + +Proto *luaF_newproto (lua_State *L) { + Proto *f = luaM_new(L, Proto); + f->knum = NULL; + f->nknum = 0; + f->kstr = NULL; + f->nkstr = 0; + f->kproto = NULL; + f->nkproto = 0; + f->code = NULL; + f->ncode = 0; + f->numparams = 0; + f->is_vararg = 0; + f->maxstacksize = 0; + f->marked = 0; + f->lineinfo = NULL; + f->nlineinfo = 0; + f->nlocvars = 0; + f->locvars = NULL; + f->lineDefined = 0; + f->source = NULL; + f->next = L->rootproto; /* chain in list of protos */ + L->rootproto = f; + return f; +} + + +static size_t protosize (Proto *f) { + return sizeof(Proto) + + f->nknum*sizeof(Number) + + f->nkstr*sizeof(TString *) + + f->nkproto*sizeof(Proto *) + + f->ncode*sizeof(Instruction) + + f->nlocvars*sizeof(struct LocVar) + + f->nlineinfo*sizeof(int); +} + + +void luaF_protook (lua_State *L, Proto *f, int pc) { + f->ncode = pc; /* signal that proto was properly created */ + L->nblocks += protosize(f); +} + + +void luaF_freeproto (lua_State *L, Proto *f) { + if (f->ncode > 0) /* function was properly created? */ + L->nblocks -= protosize(f); + luaM_free(L, f->code); + luaM_free(L, f->locvars); + luaM_free(L, f->kstr); + luaM_free(L, f->knum); + luaM_free(L, f->kproto); + luaM_free(L, f->lineinfo); + luaM_free(L, f); +} + + +void luaF_freeclosure (lua_State *L, Closure *c) { + L->nblocks -= sizeclosure(c->nupvalues); + luaM_free(L, c); +} + + +/* +** Look for n-th local variable at line `line' in function `func'. +** Returns NULL if not found. +*/ +const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { + int i; + for (i = 0; i<f->nlocvars && f->locvars[i].startpc <= pc; i++) { + if (pc < f->locvars[i].endpc) { /* is variable active? */ + local_number--; + if (local_number == 0) + return f->locvars[i].varname->str; + } + } + return NULL; /* not found */ +} + diff --git a/src/lua/lfunc.h b/src/lua/lfunc.h new file mode 100644 index 00000000..1bd9722d --- /dev/null +++ b/src/lua/lfunc.h @@ -0,0 +1,24 @@ +/* +** $Id: lfunc.h,v 1.3 2001/11/26 23:00:23 darkgod Exp $ +** Auxiliary functions to manipulate prototypes and closures +** See Copyright Notice in lua.h +*/ + +#ifndef lfunc_h +#define lfunc_h + + +#include "lobject.h" + + + +Proto *luaF_newproto (lua_State *L); +void luaF_protook (lua_State *L, Proto *f, int pc); +Closure *luaF_newclosure (lua_State *L, int nelems); +void luaF_freeproto (lua_State *L, Proto *f); +void luaF_freeclosure (lua_State *L, Closure *c); + +const char *luaF_getlocalname (const Proto *func, int local_number, int pc); + + +#endif diff --git a/src/lua/lgc.c b/src/lua/lgc.c new file mode 100644 index 00000000..4e8b234d --- /dev/null +++ b/src/lua/lgc.c @@ -0,0 +1,353 @@ +/* +** $Id: lgc.c,v 1.3 2001/11/26 23:00:24 darkgod Exp $ +** Garbage Collector +** See Copyright Notice in lua.h +*/ + +#include "lua.h" + +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + +typedef struct GCState { + Hash *tmark; /* list of marked tables to be visited */ + Closure *cmark; /* list of marked closures to be visited */ +} GCState; + + + +static void markobject (GCState *st, TObject *o); + + +/* mark a string; marks larger than 1 cannot be changed */ +#define strmark(s) {if ((s)->marked == 0) (s)->marked = 1;} + + + +static void protomark (Proto *f) { + if (!f->marked) { + int i; + f->marked = 1; + strmark(f->source); + for (i=0; i<f->nkstr; i++) + strmark(f->kstr[i]); + for (i=0; i<f->nkproto; i++) + protomark(f->kproto[i]); + for (i=0; i<f->nlocvars; i++) /* mark local-variable names */ + strmark(f->locvars[i].varname); + } +} + + +static void markstack (lua_State *L, GCState *st) { + StkId o; + for (o=L->stack; o<L->top; o++) + markobject(st, o); +} + + +static void marklock (lua_State *L, GCState *st) { + int i; + for (i=0; i<L->refSize; i++) { + if (L->refArray[i].st == LOCK) + markobject(st, &L->refArray[i].o); + } +} + + +static void markclosure (GCState *st, Closure *cl) { + if (!ismarked(cl)) { + if (!cl->isC) + protomark(cl->f.l); + cl->mark = st->cmark; /* chain it for later traversal */ + st->cmark = cl; + } +} + + +static void marktagmethods (lua_State *L, GCState *st) { + int e; + for (e=0; e<TM_N; e++) { + int t; + for (t=0; t<=L->last_tag; t++) { + Closure *cl = luaT_gettm(L, t, e); + if (cl) markclosure(st, cl); + } + } +} + + +static void markobject (GCState *st, TObject *o) { + switch (ttype(o)) { + case LUA_TUSERDATA: case LUA_TSTRING: + strmark(tsvalue(o)); + break; + case LUA_TMARK: + markclosure(st, infovalue(o)->func); + break; + case LUA_TFUNCTION: + markclosure(st, clvalue(o)); + break; + case LUA_TTABLE: { + if (!ismarked(hvalue(o))) { + hvalue(o)->mark = st->tmark; /* chain it in list of marked */ + st->tmark = hvalue(o); + } + break; + } + default: break; /* numbers, etc */ + } +} + + +static void markall (lua_State *L) { + GCState st; + st.cmark = NULL; + st.tmark = L->gt; /* put table of globals in mark list */ + L->gt->mark = NULL; + marktagmethods(L, &st); /* mark tag methods */ + markstack(L, &st); /* mark stack objects */ + marklock(L, &st); /* mark locked objects */ + for (;;) { /* mark tables and closures */ + if (st.cmark) { + int i; + Closure *f = st.cmark; /* get first closure from list */ + st.cmark = f->mark; /* remove it from list */ + for (i=0; i<f->nupvalues; i++) /* mark its upvalues */ + markobject(&st, &f->upvalue[i]); + } + else if (st.tmark) { + int i; + Hash *h = st.tmark; /* get first table from list */ + st.tmark = h->mark; /* remove it from list */ + for (i=0; i<h->size; i++) { + Node *n = node(h, i); + if (ttype(key(n)) != LUA_TNIL) { + if (ttype(val(n)) == LUA_TNIL) + luaH_remove(h, key(n)); /* dead element; try to remove it */ + markobject(&st, &n->key); + markobject(&st, &n->val); + } + } + } + else break; /* nothing else to mark */ + } +} + + +static int hasmark (const TObject *o) { + /* valid only for locked objects */ + switch (o->ttype) { + case LUA_TSTRING: case LUA_TUSERDATA: + return tsvalue(o)->marked; + case LUA_TTABLE: + return ismarked(hvalue(o)); + case LUA_TFUNCTION: + return ismarked(clvalue(o)); + default: /* number */ + return 1; + } +} + + +/* macro for internal debugging; check if a link of free refs is valid */ +#define VALIDLINK(L, st,n) (NONEXT <= (st) && (st) < (n)) + +static void invalidaterefs (lua_State *L) { + int n = L->refSize; + int i; + for (i=0; i<n; i++) { + struct Ref *r = &L->refArray[i]; + if (r->st == HOLD && !hasmark(&r->o)) + r->st = COLLECTED; + LUA_ASSERT((r->st == LOCK && hasmark(&r->o)) || + (r->st == HOLD && hasmark(&r->o)) || + r->st == COLLECTED || + r->st == NONEXT || + (r->st < n && VALIDLINK(L, L->refArray[r->st].st, n)), + "inconsistent ref table"); + } + LUA_ASSERT(VALIDLINK(L, L->refFree, n), "inconsistent ref table"); +} + + + +static void collectproto (lua_State *L) { + Proto **p = &L->rootproto; + Proto *next; + while ((next = *p) != NULL) { + if (next->marked) { + next->marked = 0; + p = &next->next; + } + else { + *p = next->next; + luaF_freeproto(L, next); + } + } +} + + +static void collectclosure (lua_State *L) { + Closure **p = &L->rootcl; + Closure *next; + while ((next = *p) != NULL) { + if (ismarked(next)) { + next->mark = next; /* unmark */ + p = &next->next; + } + else { + *p = next->next; + luaF_freeclosure(L, next); + } + } +} + + +static void collecttable (lua_State *L) { + Hash **p = &L->roottable; + Hash *next; + while ((next = *p) != NULL) { + if (ismarked(next)) { + next->mark = next; /* unmark */ + p = &next->next; + } + else { + *p = next->next; + luaH_free(L, next); + } + } +} + + +static void checktab (lua_State *L, stringtable *tb) { + if (tb->nuse < (lint32)(tb->size/4) && tb->size > 10) + luaS_resize(L, tb, tb->size/2); /* table is too big */ +} + + +static void collectstrings (lua_State *L, int all) { + int i; + for (i=0; i<L->strt.size; i++) { /* for each list */ + TString **p = &L->strt.hash[i]; + TString *next; + while ((next = *p) != NULL) { + if (next->marked && !all) { /* preserve? */ + if (next->marked < FIXMARK) /* does not change FIXMARKs */ + next->marked = 0; + p = &next->nexthash; + } + else { /* collect */ + *p = next->nexthash; + L->strt.nuse--; + L->nblocks -= sizestring(next->len); + luaM_free(L, next); + } + } + } + checktab(L, &L->strt); +} + + +static void collectudata (lua_State *L, int all) { + int i; + for (i=0; i<L->udt.size; i++) { /* for each list */ + TString **p = &L->udt.hash[i]; + TString *next; + while ((next = *p) != NULL) { + LUA_ASSERT(next->marked <= 1, "udata cannot be fixed"); + if (next->marked && !all) { /* preserve? */ + next->marked = 0; + p = &next->nexthash; + } + else { /* collect */ + int tag = next->u.d.tag; + *p = next->nexthash; + next->nexthash = L->TMtable[tag].collected; /* chain udata */ + L->TMtable[tag].collected = next; + L->nblocks -= sizestring(next->len); + L->udt.nuse--; + } + } + } + checktab(L, &L->udt); +} + + +#define MINBUFFER 256 +static void checkMbuffer (lua_State *L) { + if (L->Mbuffsize > MINBUFFER*2) { /* is buffer too big? */ + size_t newsize = L->Mbuffsize/2; /* still larger than MINBUFFER */ + L->nblocks += (newsize - L->Mbuffsize)*sizeof(char); + L->Mbuffsize = newsize; + luaM_reallocvector(L, L->Mbuffer, newsize, char); + } +} + + +static void callgcTM (lua_State *L, const TObject *o) { + Closure *tm = luaT_gettmbyObj(L, o, TM_GC); + if (tm != NULL) { + int oldah = L->allowhooks; + L->allowhooks = 0; /* stop debug hooks during GC tag methods */ + luaD_checkstack(L, 2); + clvalue(L->top) = tm; + ttype(L->top) = LUA_TFUNCTION; + *(L->top+1) = *o; + L->top += 2; + luaD_call(L, L->top-2, 0); + L->allowhooks = oldah; /* restore hooks */ + } +} + + +static void callgcTMudata (lua_State *L) { + int tag; + TObject o; + ttype(&o) = LUA_TUSERDATA; + L->GCthreshold = 2*L->nblocks; /* avoid GC during tag methods */ + for (tag=L->last_tag; tag>=0; tag--) { /* for each tag (in reverse order) */ + TString *udata; + while ((udata = L->TMtable[tag].collected) != NULL) { + L->TMtable[tag].collected = udata->nexthash; /* remove it from list */ + tsvalue(&o) = udata; + callgcTM(L, &o); + luaM_free(L, udata); + } + } +} + + +void luaC_collect (lua_State *L, int all) { + collectudata(L, all); + callgcTMudata(L); + collectstrings(L, all); + collecttable(L); + collectproto(L); + collectclosure(L); +} + + +static void luaC_collectgarbage (lua_State *L) { + markall(L); + invalidaterefs(L); /* check unlocked references */ + luaC_collect(L, 0); + checkMbuffer(L); + L->GCthreshold = 2*L->nblocks; /* set new threshold */ + callgcTM(L, &luaO_nilobject); +} + + +void luaC_checkGC (lua_State *L) { + if (L->nblocks >= L->GCthreshold) + luaC_collectgarbage(L); +} + diff --git a/src/lua/lgc.h b/src/lua/lgc.h new file mode 100644 index 00000000..2dea9e4d --- /dev/null +++ b/src/lua/lgc.h @@ -0,0 +1,18 @@ +/* +** $Id: lgc.h,v 1.3 2001/11/26 23:00:24 darkgod Exp $ +** Garbage Collector +** See Copyright Notice in lua.h +*/ + +#ifndef lgc_h +#define lgc_h + + +#include "lobject.h" + + +void luaC_collect (lua_State *L, int all); +void luaC_checkGC (lua_State *L); + + +#endif diff --git a/src/lua/liolib.c b/src/lua/liolib.c new file mode 100644 index 00000000..4fb385f4 --- /dev/null +++ b/src/lua/liolib.c @@ -0,0 +1,710 @@ +/* +** $Id: liolib.c,v 1.5 2004/06/04 13:42:10 neil Exp $ +** Standard I/O (and system) library +** See Copyright Notice in lua.h +*/ + + +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +#include "lua.h" + +#include "lauxlib.h" +#include "luadebug.h" +#include "lualib.h" + + +#ifndef OLD_ANSI +#include <errno.h> +#include <locale.h> +#define realloc(b,s) ((b) == NULL ? malloc(s) : (realloc)(b, s)) +#define free(b) if (b) (free)(b) +#else +/* no support for locale and for strerror: fake them */ +#define setlocale(a,b) ((void)a, strcmp((b),"C")==0?"C":NULL) +#define LC_ALL 0 +#define LC_COLLATE 0 +#define LC_CTYPE 0 +#define LC_MONETARY 0 +#define LC_NUMERIC 0 +#define LC_TIME 0 +#define strerror(e) "generic I/O error" +#define errno (-1) +#endif + + + +#ifdef POPEN +/* FILE *popen(); +int pclose(); */ +#define CLOSEFILE(L, f) ((pclose(f) == -1) ? fclose(f) : 0) +#else +/* no support for popen */ +#define popen(x,y) NULL /* that is, popen always fails */ +#define CLOSEFILE(L, f) (fclose(f)) +#endif + + +#define INFILE 0 +#define OUTFILE 1 + +typedef struct IOCtrl { + int ref[2]; /* ref for strings _INPUT/_OUTPUT */ + int iotag; /* tag for file handles */ + int closedtag; /* tag for closed handles */ +} IOCtrl; + + + +static const char *const filenames[] = {"_INPUT", "_OUTPUT"}; + + +static int pushresult (lua_State *L, int i) { + if (i) { + lua_pushuserdata(L, NULL); + return 1; + } + else { + lua_pushnil(L); + lua_pushstring(L, strerror(errno)); + lua_pushnumber(L, errno); + return 3;; + } +} + + +/* +** {====================================================== +** FILE Operations +** ======================================================= +*/ + + +static FILE *gethandle (lua_State *L, IOCtrl *ctrl, int f) { + void *p = lua_touserdata(L, f); + if (p != NULL) { /* is `f' a userdata ? */ + int ftag = lua_tag(L, f); + if (ftag == ctrl->iotag) /* does it have the correct tag? */ + return (FILE *)p; + else if (ftag == ctrl->closedtag) + lua_error(L, "cannot access a closed file"); + /* else go through */ + } + return NULL; +} + + +static FILE *getnonullfile (lua_State *L, IOCtrl *ctrl, int arg) { + FILE *f = gethandle(L, ctrl, arg); + luaL_arg_check(L, f, arg, "invalid file handle"); + return f; +} + + +static FILE *getfilebyref (lua_State *L, IOCtrl *ctrl, int inout) { + FILE *f; + lua_getglobals(L); + lua_getref(L, ctrl->ref[inout]); + lua_rawget(L, -2); + f = gethandle(L, ctrl, -1); + if (f == NULL) + luaL_verror(L, "global variable `%.10s' is not a file handle", + filenames[inout]); + return f; +} + + +static void setfilebyname (lua_State *L, IOCtrl *ctrl, FILE *f, + const char *name) { + lua_pushusertag(L, f, ctrl->iotag); + lua_setglobal(L, name); +} + + +#define setfile(L,ctrl,f,inout) (setfilebyname(L,ctrl,f,filenames[inout])) + + +static int setreturn (lua_State *L, IOCtrl *ctrl, FILE *f, int inout) { + if (f == NULL) + return pushresult(L, 0); + else { + setfile(L, ctrl, f, inout); + lua_pushusertag(L, f, ctrl->iotag); + return 1; + } +} + + +static int closefile (lua_State *L, IOCtrl *ctrl, FILE *f) { + if (f == stdin || f == stdout || f == stderr) + return 1; + else { + lua_pushusertag(L, f, ctrl->iotag); + lua_settag(L, ctrl->closedtag); + return (CLOSEFILE(L, f) == 0); + } +} + + +static int io_close (lua_State *L) { + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + lua_pop(L, 1); /* remove upvalue */ + return pushresult(L, closefile(L, ctrl, getnonullfile(L, ctrl, 1))); +} + + +static int file_collect (lua_State *L) { + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + FILE *f = getnonullfile(L, ctrl, 1); + if (f != stdin && f != stdout && f != stderr) + CLOSEFILE(L, f); + return 0; +} + + +static int io_open (lua_State *L) { + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + FILE *f; + lua_pop(L, 1); /* remove upvalue */ + f = fopen(luaL_check_string(L, 1), luaL_check_string(L, 2)); + if (f) { + lua_pushusertag(L, f, ctrl->iotag); + return 1; + } + else + return pushresult(L, 0); +} + + + +static int io_fromto (lua_State *L, int inout, const char *mode) { + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + FILE *current; + lua_pop(L, 1); /* remove upvalue */ + if (lua_isnull(L, 1)) { + closefile(L, ctrl, getfilebyref(L, ctrl, inout)); + current = (inout == 0) ? stdin : stdout; + } + else if (lua_tag(L, 1) == ctrl->iotag) /* deprecated option */ + current = (FILE *)lua_touserdata(L, 1); + else { + const char *s = luaL_check_string(L, 1); + current = (*s == '|') ? popen(s+1, mode) : fopen(s, mode); + } + return setreturn(L, ctrl, current, inout); +} + + +static int io_readfrom (lua_State *L) { + return io_fromto(L, INFILE, "r"); +} + + +static int io_writeto (lua_State *L) { + return io_fromto(L, OUTFILE, "w"); +} + + +static int io_appendto (lua_State *L) { + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + FILE *current; + lua_pop(L, 1); /* remove upvalue */ + current = fopen(luaL_check_string(L, 1), "a"); + return setreturn(L, ctrl, current, OUTFILE); +} + + + +/* +** {====================================================== +** READ +** ======================================================= +*/ + + + +#ifdef LUA_COMPAT_READPATTERN + +/* +** We cannot lookahead without need, because this can lock stdin. +** This flag signals when we need to read a next char. +*/ +#define NEED_OTHER (EOF-1) /* just some flag different from EOF */ + + +static int read_pattern (lua_State *L, FILE *f, const char *p) { + int inskip = 0; /* {skip} level */ + int c = NEED_OTHER; + luaL_Buffer b; + luaL_buffinit(L, &b); + while (*p != '\0') { + switch (*p) { + case '{': + inskip++; + p++; + continue; + case '}': + if (!inskip) lua_error(L, "unbalanced braces in read pattern"); + inskip--; + p++; + continue; + default: { + const char *ep = luaI_classend(L, p); /* get what is next */ + int m; /* match result */ + if (c == NEED_OTHER) c = getc(f); + m = (c==EOF) ? 0 : luaI_singlematch(c, p, ep); + if (m) { + if (!inskip) luaL_putchar(&b, c); + c = NEED_OTHER; + } + switch (*ep) { + case '+': /* repetition (1 or more) */ + if (!m) goto break_while; /* pattern fails? */ + /* else go through */ + case '*': /* repetition (0 or more) */ + while (m) { /* reads the same item until it fails */ + c = getc(f); + m = (c==EOF) ? 0 : luaI_singlematch(c, p, ep); + if (m && !inskip) luaL_putchar(&b, c); + } + /* go through to continue reading the pattern */ + case '?': /* optional */ + p = ep+1; /* continues reading the pattern */ + continue; + default: + if (!m) goto break_while; /* pattern fails? */ + p = ep; /* else continues reading the pattern */ + } + } + } + } break_while: + if (c != NEED_OTHER) ungetc(c, f); + luaL_pushresult(&b); /* close buffer */ + return (*p == '\0'); +} + +#else + +#define read_pattern(L, f, p) (lua_error(L, "read patterns are deprecated"), 0) + +#endif + + +static int read_number (lua_State *L, FILE *f) { + long d; + if (fscanf(f, "%ld", &d) == 1) { + lua_pushnumber(L, d); + return 1; + } + else return 0; /* read fails */ +} + + +static int read_word (lua_State *L, FILE *f) { + int c; + luaL_Buffer b; + luaL_buffinit(L, &b); + do { c = fgetc(f); } while (isspace(c)); /* skip spaces */ + while (c != EOF && !isspace(c)) { + luaL_putchar(&b, c); + c = fgetc(f); + } + ungetc(c, f); + luaL_pushresult(&b); /* close buffer */ + return (lua_strlen(L, -1) > 0); +} + + +static int read_line (lua_State *L, FILE *f) { + int n = 0; + luaL_Buffer b; + luaL_buffinit(L, &b); + for (;;) { + char *p = luaL_prepbuffer(&b); + if (!fgets(p, LUAL_BUFFERSIZE, f)) /* read fails? */ + break; + n = strlen(p); + if (p[n-1] != '\n') + luaL_addsize(&b, n); + else { + luaL_addsize(&b, n-1); /* do not add the `\n' */ + break; + } + } + luaL_pushresult(&b); /* close buffer */ + return (n > 0); /* read something? */ +} + + +static void read_file (lua_State *L, FILE *f) { + size_t len = 0; + size_t size = BUFSIZ; + char *buffer = NULL; + for (;;) { + char *newbuffer = (char *)realloc(buffer, size); + if (newbuffer == NULL) { + free(buffer); + lua_error(L, "not enough memory to read a file"); + } + buffer = newbuffer; + len += fread(buffer+len, sizeof(char), size-len, f); + if (len < size) break; /* did not read all it could */ + size *= 2; + } + lua_pushlstring(L, buffer, len); + free(buffer); +} + + +static int read_chars (lua_State *L, FILE *f, size_t n) { + char *buffer; + size_t n1; + char statbuff[BUFSIZ]; + if (n <= BUFSIZ) + buffer = statbuff; + else { + buffer = (char *)malloc(n); + if (buffer == NULL) + lua_error(L, "not enough memory to read a file"); + } + n1 = fread(buffer, sizeof(char), n, f); + lua_pushlstring(L, buffer, n1); + if (buffer != statbuff) free(buffer); + return (n1 > 0 || n == 0); +} + + +static int io_read (lua_State *L) { + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + int lastarg = lua_gettop(L) - 1; + int firstarg = 1; + FILE *f = gethandle(L, ctrl, firstarg); + int n; + if (f) firstarg++; + else f = getfilebyref(L, ctrl, INFILE); /* get _INPUT */ + lua_pop(L, 1); + if (firstarg > lastarg) { /* no arguments? */ + lua_settop(L, 0); /* erase upvalue and other eventual garbage */ + firstarg = lastarg = 1; /* correct indices */ + lua_pushstring(L, "*l"); /* push default argument */ + } + else /* ensure stack space for all results and for auxlib's buffer */ + luaL_checkstack(L, lastarg-firstarg+1+LUA_MINSTACK, "too many arguments"); + for (n = firstarg; n<=lastarg; n++) { + int success; + if (lua_isnumber(L, n)) + success = read_chars(L, f, (size_t)lua_tonumber(L, n)); + else { + const char *p = luaL_check_string(L, n); + if (p[0] != '*') + success = read_pattern(L, f, p); /* deprecated! */ + else { + switch (p[1]) { + case 'n': /* number */ + if (!read_number(L, f)) goto endloop; /* read fails */ + continue; /* number is already pushed; avoid the "pushstring" */ + case 'l': /* line */ + success = read_line(L, f); + break; + case 'a': /* file */ + read_file(L, f); + success = 1; /* always success */ + break; + case 'w': /* word */ + success = read_word(L, f); + break; + default: + luaL_argerror(L, n, "invalid format"); + success = 0; /* to avoid warnings */ + } + } + } + if (!success) { + lua_pop(L, 1); /* remove last result */ + break; /* read fails */ + } + } endloop: + return n - firstarg; +} + +/* }====================================================== */ + + +static int io_write (lua_State *L) { + int lastarg = lua_gettop(L) - 1; + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + int arg = 1; + int status = 1; + FILE *f = gethandle(L, ctrl, arg); + if (f) arg++; + else f = getfilebyref(L, ctrl, OUTFILE); /* get _OUTPUT */ + for (; arg <= lastarg; arg++) { + if (lua_type(L, arg) == LUA_TNUMBER) { /* LUA_NUMBER */ + /* optimization: could be done exactly as for strings */ + status = status && fprintf(f, "%ld", lua_tonumber(L, arg)) > 0; + } + else { + size_t l; + const char *s = luaL_check_lstr(L, arg, &l); + status = status && (fwrite(s, sizeof(char), l, f) == l); + } + } + pushresult(L, status); + return 1; +} + + +static int io_seek (lua_State *L) { + static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END}; + static const char *const modenames[] = {"set", "cur", "end", NULL}; + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + FILE *f; + int op; + long offset; + lua_pop(L, 1); /* remove upvalue */ + f = getnonullfile(L, ctrl, 1); + op = luaL_findstring(luaL_opt_string(L, 2, "cur"), modenames); + offset = luaL_opt_long(L, 3, 0); + luaL_arg_check(L, op != -1, 2, "invalid mode"); + op = fseek(f, offset, mode[op]); + if (op) + return pushresult(L, 0); /* error */ + else { + lua_pushnumber(L, ftell(f)); + return 1; + } +} + + +static int io_flush (lua_State *L) { + IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, -1); + FILE *f; + lua_pop(L, 1); /* remove upvalue */ + f = gethandle(L, ctrl, 1); + luaL_arg_check(L, f || lua_isnull(L, 1), 1, "invalid file handle"); + return pushresult(L, fflush(f) == 0); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Other O.S. Operations +** ======================================================= +*/ + +static int io_execute (lua_State *L) { + lua_pushnumber(L, system(luaL_check_string(L, 1))); + return 1; +} + + +static int io_remove (lua_State *L) { + return pushresult(L, remove(luaL_check_string(L, 1)) == 0); +} + + +static int io_rename (lua_State *L) { + return pushresult(L, rename(luaL_check_string(L, 1), + luaL_check_string(L, 2)) == 0); +} + + +static int io_getenv (lua_State *L) { + lua_pushstring(L, getenv(luaL_check_string(L, 1))); /* if NULL push nil */ + return 1; +} + + +static int io_clock (lua_State *L) { + lua_pushnumber(L, ((long)clock())/CLOCKS_PER_SEC); + return 1; +} + + +static int io_date (lua_State *L) { + char b[256]; + const char *s = luaL_opt_string(L, 1, "%c"); + struct tm *stm; + time_t t; + time(&t); stm = localtime(&t); + if (strftime(b, sizeof(b), s, stm)) + lua_pushstring(L, b); + else + lua_error(L, "invalid `date' format"); + return 1; +} + + +static int setloc (lua_State *L) { + static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, + LC_NUMERIC, LC_TIME}; + static const char *const catnames[] = {"all", "collate", "ctype", "monetary", + "numeric", "time", NULL}; + int op = luaL_findstring(luaL_opt_string(L, 2, "all"), catnames); + luaL_arg_check(L, op != -1, 2, "invalid option"); + lua_pushstring(L, setlocale(cat[op], luaL_check_string(L, 1))); + return 1; +} + + +static int io_exit (lua_State *L) { + exit(luaL_opt_int(L, 1, EXIT_SUCCESS)); + return 0; /* to avoid warnings */ +} + +/* }====================================================== */ + + + +static int io_debug (lua_State *L) { + for (;;) { + char buffer[250]; + fprintf(stderr, "lua_debug> "); + if (fgets(buffer, sizeof(buffer), stdin) == 0 || + strcmp(buffer, "cont\n") == 0) + return 0; + lua_dostring(L, buffer); + lua_settop(L, 0); /* remove eventual returns */ + } +} + + +#define LEVELS1 12 /* size of the first part of the stack */ +#define LEVELS2 10 /* size of the second part of the stack */ + +static int errorfb (lua_State *L) { + int level = 1; /* skip level 0 (it's this function) */ + int firstpart = 1; /* still before eventual `...' */ + lua_Debug ar; + luaL_Buffer b; + luaL_buffinit(L, &b); + luaL_addstring(&b, "error: "); + luaL_addstring(&b, luaL_check_string(L, 1)); + luaL_addstring(&b, "\n"); + while (lua_getstack(L, level++, &ar)) { + char buff[120]; /* enough to fit following `sprintf's */ + if (level == 2) + luaL_addstring(&b, "stack traceback:\n"); + else if (level > LEVELS1 && firstpart) { + /* no more than `LEVELS2' more levels? */ + if (!lua_getstack(L, level+LEVELS2, &ar)) + level--; /* keep going */ + else { + luaL_addstring(&b, " ...\n"); /* too many levels */ + while (lua_getstack(L, level+LEVELS2, &ar)) /* find last levels */ + level++; + } + firstpart = 0; + continue; + } + sprintf(buff, "%4d: ", level-1); + luaL_addstring(&b, buff); + lua_getinfo(L, "Snl", &ar); + switch (*ar.namewhat) { + case 'g': case 'l': /* global, local */ + sprintf(buff, "function `%.50s'", ar.name); + break; + case 'f': /* field */ + sprintf(buff, "method `%.50s'", ar.name); + break; + case 't': /* tag method */ + sprintf(buff, "`%.50s' tag method", ar.name); + break; + default: { + if (*ar.what == 'm') /* main? */ + sprintf(buff, "main of %.70s", ar.short_src); + else if (*ar.what == 'C') /* C function? */ + sprintf(buff, "%.70s", ar.short_src); + else + sprintf(buff, "function <%d:%.70s>", ar.linedefined, ar.short_src); + ar.source = NULL; /* do not print source again */ + } + } + luaL_addstring(&b, buff); + if (ar.currentline > 0) { + sprintf(buff, " at line %d", ar.currentline); + luaL_addstring(&b, buff); + } + if (ar.source) { + sprintf(buff, " [%.70s]", ar.short_src); + luaL_addstring(&b, buff); + } + luaL_addstring(&b, "\n"); + } + luaL_pushresult(&b); + lua_getglobal(L, LUA_ALERT); + if (lua_isfunction(L, -1)) { /* avoid loop if _ALERT is not defined */ + lua_pushvalue(L, -2); /* error message */ + lua_rawcall(L, 1, 0); + } + return 0; +} + + + +static const struct luaL_reg iolib[] = { + {LUA_ERRORMESSAGE, errorfb}, + {"clock", io_clock}, + {"date", io_date}, + {"debug", io_debug}, + {"execute", io_execute}, + {"exit", io_exit}, + {"getenv", io_getenv}, + {"remove", io_remove}, + {"rename", io_rename}, + {"setlocale", setloc}, +}; + + +static const struct luaL_reg iolibtag[] = { + {"appendto", io_appendto}, + {"closefile", io_close}, + {"flush", io_flush}, + {"openfile", io_open}, + {"read", io_read}, + {"readfrom", io_readfrom}, + {"seek", io_seek}, + {"write", io_write}, + {"writeto", io_writeto} +}; + + +static void openwithcontrol (lua_State *L) { + IOCtrl *ctrl = (IOCtrl *)lua_newuserdata(L, sizeof(IOCtrl)); + unsigned int i; + ctrl->iotag = lua_newtag(L); + ctrl->closedtag = lua_newtag(L); + for (i=0; i<sizeof(iolibtag)/sizeof(iolibtag[0]); i++) { + /* put `ctrl' as upvalue for these functions */ + lua_pushvalue(L, -1); + lua_pushcclosure(L, iolibtag[i].func, 1); + lua_setglobal(L, iolibtag[i].name); + } + /* create references to variable names */ + lua_pushstring(L, filenames[INFILE]); + ctrl->ref[INFILE] = lua_ref(L, 1); + lua_pushstring(L, filenames[OUTFILE]); + ctrl->ref[OUTFILE] = lua_ref(L, 1); + /* predefined file handles */ + setfile(L, ctrl, stdin, INFILE); + setfile(L, ctrl, stdout, OUTFILE); + setfilebyname(L, ctrl, stdin, "_STDIN"); + setfilebyname(L, ctrl, stdout, "_STDOUT"); + setfilebyname(L, ctrl, stderr, "_STDERR"); + /* close files when collected */ + lua_pushcclosure(L, file_collect, 1); /* pops `ctrl' from stack */ + lua_settagmethod(L, ctrl->iotag, "gc"); +} + + +LUALIB_API void lua_iolibopen (lua_State *L) { + luaL_openl(L, iolib); + openwithcontrol(L); +} + diff --git a/src/lua/llex.c b/src/lua/llex.c new file mode 100644 index 00000000..86fb69ab --- /dev/null +++ b/src/lua/llex.c @@ -0,0 +1,411 @@ +/* +** $Id: llex.c,v 1.6 2004/06/04 13:42:10 neil Exp $ +** Lexical Analyzer +** See Copyright Notice in lua.h +*/ + + +#include <ctype.h> +#include <stdio.h> +#include <string.h> + +#include "lua.h" + +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "luadebug.h" +#include "lzio.h" + + + +#define next(LS) (LS->current = zgetc(LS->z)) + + + +/* ORDER RESERVED */ +static const char *const token2string [] = { + "and", "break", "do", "else", "elseif", "end", "for", + "function", "if", "local", "nil", "not", "or", "repeat", "return", "then", + "until", "while", "", "..", "...", "==", ">=", "<=", "~=", "", "", "<eof>"}; + + +void luaX_init (lua_State *L) { + int i; + for (i=0; i<NUM_RESERVED; i++) { + TString *ts = luaS_new(L, token2string[i]); + ts->marked = (unsigned char)(RESERVEDMARK+i); /* reserved word */ + } +} + + +#define MAXSRC 80 + + +void luaX_checklimit (LexState *ls, int val, int limit, const char *msg) { + if (val > limit) { + char buff[100]; + sprintf(buff, "too many %.50s (limit=%d)", msg, limit); + luaX_error(ls, buff, ls->t.token); + } +} + + +void luaX_syntaxerror (LexState *ls, const char *s, const char *token) { + char buff[MAXSRC]; + luaO_chunkid(buff, ls->source->str, sizeof(buff)); + luaO_verror(ls->L, "%.99s;\n last token read: `%.30s' at line %d in %.80s", + s, token, ls->linenumber, buff); +} + + +void luaX_error (LexState *ls, const char *s, int token) { + char buff[TOKEN_LEN]; + luaX_token2str(token, buff); + if (buff[0] == '\0') + luaX_syntaxerror(ls, s, ls->L->Mbuffer); + else + luaX_syntaxerror(ls, s, buff); +} + + +void luaX_token2str (int token, char *s) { + if (token < 256) { + s[0] = (char)token; + s[1] = '\0'; + } + else + strcpy(s, token2string[token-FIRST_RESERVED]); +} + + +static void luaX_invalidchar (LexState *ls, int c) { + char buff[8]; + sprintf(buff, "0x%02X", c); + luaX_syntaxerror(ls, "invalid control char", buff); +} + + +static void inclinenumber (LexState *LS) { + next(LS); /* skip '\n' */ + ++LS->linenumber; + luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk"); +} + + +void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) { + LS->L = L; + LS->lookahead.token = TK_EOS; /* no look-ahead token */ + LS->z = z; + LS->fs = NULL; + LS->linenumber = 1; + LS->lastline = 1; + LS->source = source; + next(LS); /* read first char */ + if (LS->current == '#') { + do { /* skip first line */ + next(LS); + } while (LS->current != '\n' && LS->current != '\r' && LS->current != EOZ); + } +} + + + +/* +** ======================================================= +** LEXICAL ANALYZER +** ======================================================= +*/ + + +/* use Mbuffer to store names, literal strings and numbers */ + +#define EXTRABUFF 128 +#define checkbuffer(L, n, len) if ((len)+(n) > L->Mbuffsize) \ + luaO_openspace(L, (len)+(n)+EXTRABUFF) + +#define save(L, c, l) (L->Mbuffer[l++] = (char)c) +#define save_and_next(L, LS, l) (save(L, LS->current, l), next(LS)) + + +static const char *readname (LexState *LS) { + lua_State *L = LS->L; + size_t l = 0; + checkbuffer(L, 10, l); + do { + checkbuffer(L, 10, l); + save_and_next(L, LS, l); + } while (isalnum(LS->current) || LS->current == '_'); + save(L, '\0', l); + return L->Mbuffer; +} + + +/* LUA_NUMBER */ +static void read_number (LexState *LS, int comma, SemInfo *seminfo) { + lua_State *L = LS->L; + size_t l = 0; + checkbuffer(L, 10, l); + if (comma) save(L, '.', l); + while (isdigit(LS->current)) { + checkbuffer(L, 10, l); + save_and_next(L, LS, l); + } + if (LS->current == '.') { + save_and_next(L, LS, l); + if (LS->current == '.') { + save_and_next(L, LS, l); + save(L, '\0', l); + luaX_error(LS, "ambiguous syntax" + " (decimal point x string concatenation)", TK_NUMBER); + } + } + while (isdigit(LS->current)) { + checkbuffer(L, 10, l); + save_and_next(L, LS, l); + } + if (LS->current == 'e' || LS->current == 'E') { + save_and_next(L, LS, l); /* read 'E' */ + if (LS->current == '+' || LS->current == '-') + save_and_next(L, LS, l); /* optional exponent sign */ + while (isdigit(LS->current)) { + checkbuffer(L, 10, l); + save_and_next(L, LS, l); + } + } + save(L, '\0', l); + if (!luaO_str2d(L->Mbuffer, &seminfo->r)) + luaX_error(LS, "malformed number", TK_NUMBER); +} + + +static void read_long_string (LexState *LS, SemInfo *seminfo) { + lua_State *L = LS->L; + int cont = 0; + size_t l = 0; + checkbuffer(L, 10, l); + save(L, '[', l); /* save first '[' */ + save_and_next(L, LS, l); /* pass the second '[' */ + for (;;) { + checkbuffer(L, 10, l); + switch (LS->current) { + case EOZ: + save(L, '\0', l); + if (seminfo) + luaX_error(LS, "unfinished long string", TK_STRING); + else + luaX_error(LS, "unfinished comment", TK_EOS); + break; /* to avoid warnings */ + case '[': + save_and_next(L, LS, l); + if (LS->current == '[') { + cont++; + save_and_next(L, LS, l); + } + continue; + case ']': + save_and_next(L, LS, l); + if (LS->current == ']') { + if (cont == 0) goto endloop; + cont--; + save_and_next(L, LS, l); + } + continue; + case '\n': + save(L, '\n', l); + inclinenumber(LS); + if (LS->current == '\r') next(LS); + continue; + case '\r': + save(L, '\n', l); + inclinenumber(LS); + if (LS->current == '\n') next(LS); + continue; + default: + if (seminfo) /* no need to save complete comment */ + save(L, LS->current, l); + next(LS); + } + } endloop: + save_and_next(L, LS, l); /* skip the second ']' */ + save(L, '\0', l); + if (seminfo) + seminfo->ts = luaS_newlstr(L, L->Mbuffer+2, l-5); +} + + +static void read_string (LexState *LS, int del, SemInfo *seminfo) { + lua_State *L = LS->L; + size_t l = 0; + checkbuffer(L, 10, l); + save_and_next(L, LS, l); + while (LS->current != del) { + checkbuffer(L, 10, l); + switch (LS->current) { + case EOZ: case '\n': case '\r': + save(L, '\0', l); + luaX_error(LS, "unfinished string", TK_STRING); + break; /* to avoid warnings */ + case '\\': + next(LS); /* do not save the '\' */ + switch (LS->current) { + case 'a': save(L, '\a', l); next(LS); break; + case 'b': save(L, '\b', l); next(LS); break; + case 'f': save(L, '\f', l); next(LS); break; + case 'n': save(L, '\n', l); next(LS); break; + case 'r': save(L, '\r', l); next(LS); break; + case 't': save(L, '\t', l); next(LS); break; + case 'v': save(L, '\v', l); next(LS); break; + case '\n': + save(L, '\n', l); + inclinenumber(LS); + if (LS->current == '\r') next(LS); + break; + case '\r': + save(L, '\n', l); + inclinenumber(LS); + if (LS->current == '\n') next(LS); + break; + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': { + int c = 0; + int i = 0; + do { + c = 10*c + (LS->current-'0'); + next(LS); + } while (++i<3 && isdigit(LS->current)); + if (c != (unsigned char)c) { + save(L, '\0', l); + luaX_error(LS, "escape sequence too large", TK_STRING); + } + save(L, c, l); + break; + } + default: /* handles \\, \", \', and \? */ + save_and_next(L, LS, l); + } + break; + default: + save_and_next(L, LS, l); + } + } + save_and_next(L, LS, l); /* skip delimiter */ + save(L, '\0', l); + seminfo->ts = luaS_newlstr(L, L->Mbuffer+1, l-3); +} + + +int luaX_lex (LexState *LS, SemInfo *seminfo) { + for (;;) { + switch (LS->current) { + + case ' ': case '\t': + next(LS); + continue; + + case '\n': + inclinenumber(LS); + if (LS->current == '\r') next(LS); + continue; + + case '\r': + inclinenumber(LS); + if (LS->current == '\n') next(LS); + continue; + + case '$': + luaX_error(LS, "unexpected `$' (pragmas are no longer supported)", '$'); + break; + + case '-': + next(LS); + if (LS->current != '-') return '-'; + if (next(LS) == '[' && next(LS) == '[') + read_long_string(LS, NULL); + else + while (LS->current != '\n' && LS->current != '\r' && LS->current != EOZ) + next(LS); + continue; + + case '[': + next(LS); + if (LS->current != '[') return '['; + else { + read_long_string(LS, seminfo); + return TK_STRING; + } + + case '=': + next(LS); + if (LS->current != '=') return '='; + else { next(LS); return TK_EQ; } + + case '<': + next(LS); + if (LS->current != '=') return '<'; + else { next(LS); return TK_LE; } + + case '>': + next(LS); + if (LS->current != '=') return '>'; + else { next(LS); return TK_GE; } + + case '~': + next(LS); + if (LS->current != '=') return '~'; + else { next(LS); return TK_NE; } + + case '"': + case '\'': + read_string(LS, LS->current, seminfo); + return TK_STRING; + + case '.': + next(LS); + if (LS->current == '.') { + next(LS); + if (LS->current == '.') { + next(LS); + return TK_DOTS; /* ... */ + } + else return TK_CONCAT; /* .. */ + } + else if (!isdigit(LS->current)) return '.'; + else { + read_number(LS, 1, seminfo); + return TK_NUMBER; + } + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + read_number(LS, 0, seminfo); + return TK_NUMBER; + + case EOZ: + return TK_EOS; + + case '_': goto tname; + + default: + if (!isalpha(LS->current)) { + int c = LS->current; + if (iscntrl(c)) + luaX_invalidchar(LS, c); + next(LS); + return c; + } + tname: { /* identifier or reserved word */ + TString *ts = luaS_new(LS->L, readname(LS)); + if (ts->marked >= RESERVEDMARK) /* reserved word? */ + return ts->marked-RESERVEDMARK+FIRST_RESERVED; + seminfo->ts = ts; + return TK_NAME; + } + } + } +} + diff --git a/src/lua/llex.h b/src/lua/llex.h new file mode 100644 index 00000000..5fb13c88 --- /dev/null +++ b/src/lua/llex.h @@ -0,0 +1,72 @@ +/* +** $Id: llex.h,v 1.3 2001/11/26 23:00:24 darkgod Exp $ +** Lexical Analyzer +** See Copyright Notice in lua.h +*/ + +#ifndef llex_h +#define llex_h + +#include "lobject.h" +#include "lzio.h" + + +#define FIRST_RESERVED 257 + +/* maximum length of a reserved word (+1 for final 0) */ +#define TOKEN_LEN 15 + + +/* +* WARNING: if you change the order of this enumeration, +* grep "ORDER RESERVED" +*/ +enum RESERVED { + /* terminal symbols denoted by reserved words */ + TK_AND = FIRST_RESERVED, TK_BREAK, + TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FOR, TK_FUNCTION, TK_IF, TK_LOCAL, + TK_NIL, TK_NOT, TK_OR, TK_REPEAT, TK_RETURN, TK_THEN, TK_UNTIL, TK_WHILE, + /* other terminal symbols */ + TK_NAME, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER, + TK_STRING, TK_EOS +}; + +/* number of reserved words */ +#define NUM_RESERVED ((int)(TK_WHILE-FIRST_RESERVED+1)) + + +typedef union { + Number r; + TString *ts; +} SemInfo; /* semantics information */ + + +typedef struct Token { + int token; + SemInfo seminfo; +} Token; + + +typedef struct LexState { + int current; /* current character */ + Token t; /* current token */ + Token lookahead; /* look ahead token */ + struct FuncState *fs; /* `FuncState' is private to the parser */ + struct lua_State *L; + struct zio *z; /* input stream */ + int linenumber; /* input line counter */ + int lastline; /* line of last token `consumed' */ + TString *source; /* current source name */ +} LexState; + + +void luaX_init (lua_State *L); +void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source); +int luaX_lex (LexState *LS, SemInfo *seminfo); +void luaX_checklimit (LexState *ls, int val, int limit, const char *msg); +void luaX_syntaxerror (LexState *ls, const char *s, const char *token); +void luaX_error (LexState *ls, const char *s, int token); +void luaX_token2str (int token, char *s); + + +#endif diff --git a/src/lua/llimits.h b/src/lua/llimits.h new file mode 100644 index 00000000..39a1e0df --- /dev/null +++ b/src/lua/llimits.h @@ -0,0 +1,205 @@ +/* +** $Id: llimits.h,v 1.2 2001/11/26 23:00:24 darkgod Exp $ +** Limits, basic types, and some other "installation-dependent" definitions +** See Copyright Notice in lua.h +*/ + +#ifndef llimits_h +#define llimits_h + + +#include <limits.h> +#include <stddef.h> +#include <stdint.h> + + + +/* +** try to find number of bits in an integer +*/ +#ifndef BITS_INT +/* avoid overflows in comparison */ +#if INT_MAX-20 < 32760 +#define BITS_INT 16 +#else +#if INT_MAX > 2147483640L +/* machine has at least 32 bits */ +#define BITS_INT 32 +#else +#error "you must define BITS_INT with number of bits in an integer" +#endif +#endif +#endif + + +/* +** Define the type `number' of Lua +** GREP LUA_NUMBER to change that +*/ +#ifndef LUA_NUM_TYPE +#define LUA_NUM_TYPE int32_t +#endif + +typedef LUA_NUM_TYPE Number; + +/* function to convert a Number to a string */ +#define NUMBER_FMT "%ld" /* LUA_NUMBER */ +#define lua_number2str(s,n) sprintf((s), NUMBER_FMT, (n)) + +/* function to convert a string to a Number */ +#define lua_str2number(s,p) strtol((s), (p), 10) + + + +typedef int_least32_t lint32; /* unsigned int with at least 32 bits */ + + +#define MAX_SIZET ((size_t)(~(size_t)0)-2) + + +#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */ + +/* +** conversion of pointer to int (for hashing only) +** (the shift removes bits that are usually 0 because of alignment) +*/ +#define IntPoint(p) (((unsigned long)(p)) >> 3) + + + +#define MINPOWER2 4 /* minimum size for "growing" vectors */ + + + +#ifndef DEFAULT_STACK_SIZE +#define DEFAULT_STACK_SIZE 1024 +#endif + + + +/* type to ensure maximum alignment */ +union L_Umaxalign { long d; char *s; long l; }; + + + +/* +** type for virtual-machine instructions +** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h) +** For a very small machine, you may change that to 2 bytes (and adjust +** the following limits accordingly) +*/ +typedef unsigned long Instruction; + + +/* +** size and position of opcode arguments. +** For an instruction with 2 bytes, size is 16, and size_b can be 5 +** (accordingly, size_u will be 10, and size_a will be 5) +*/ +#define SIZE_INSTRUCTION 32 +#define SIZE_B 9 + +#define SIZE_OP 6 +#define SIZE_U (SIZE_INSTRUCTION-SIZE_OP) +#define POS_U SIZE_OP +#define POS_B SIZE_OP +#define SIZE_A (SIZE_INSTRUCTION-(SIZE_OP+SIZE_B)) +#define POS_A (SIZE_OP+SIZE_B) + + +/* +** limits for opcode arguments. +** we use (signed) int to manipulate most arguments, +** so they must fit in BITS_INT-1 bits (-1 for sign) +*/ +#if SIZE_U < BITS_INT-1 +#define MAXARG_U ((1<<SIZE_U)-1) +#define MAXARG_S (MAXARG_U>>1) /* `S' is signed */ +#else +#define MAXARG_U MAX_INT +#define MAXARG_S MAX_INT +#endif + +#if SIZE_A < BITS_INT-1 +#define MAXARG_A ((1<<SIZE_A)-1) +#else +#define MAXARG_A MAX_INT +#endif + +#if SIZE_B < BITS_INT-1 +#define MAXARG_B ((1<<SIZE_B)-1) +#else +#define MAXARG_B MAX_INT +#endif + + +/* maximum stack size in a function */ +#ifndef MAXSTACK +#define MAXSTACK 250 +#endif + +#if MAXSTACK > MAXARG_B +#undef MAXSTACK +#define MAXSTACK MAXARG_B +#endif + + +/* maximum number of local variables */ +#ifndef MAXLOCALS +#define MAXLOCALS 200 /* arbitrary limit (<MAXSTACK) */ +#endif +#if MAXLOCALS>=MAXSTACK +#undef MAXLOCALS +#define MAXLOCALS (MAXSTACK-1) +#endif + + +/* maximum number of upvalues */ +#ifndef MAXUPVALUES +#define MAXUPVALUES 32 /* arbitrary limit (<=MAXARG_B) */ +#endif +#if MAXUPVALUES>MAXARG_B +#undef MAXUPVALUES +#define MAXUPVALUES MAXARG_B +#endif + + +/* maximum number of variables in the left side of an assignment */ +#ifndef MAXVARSLH +#define MAXVARSLH 100 /* arbitrary limit (<MULT_RET) */ +#endif +#if MAXVARSLH>=MULT_RET +#undef MAXVARSLH +#define MAXVARSLH (MULT_RET-1) +#endif + + +/* maximum number of parameters in a function */ +#ifndef MAXPARAMS +#define MAXPARAMS 100 /* arbitrary limit (<MAXLOCALS) */ +#endif +#if MAXPARAMS>=MAXLOCALS +#undef MAXPARAMS +#define MAXPARAMS (MAXLOCALS-1) +#endif + + +/* number of list items to accumulate before a SETLIST instruction */ +#define LFIELDS_PER_FLUSH 64 +#if LFIELDS_PER_FLUSH>(MAXSTACK/4) +#undef LFIELDS_PER_FLUSH +#define LFIELDS_PER_FLUSH (MAXSTACK/4) +#endif + +/* number of record items to accumulate before a SETMAP instruction */ +/* (each item counts 2 elements on the stack: an index and a value) */ +#define RFIELDS_PER_FLUSH (LFIELDS_PER_FLUSH/2) + + +/* maximum lookback to find a real constant (for code generation) */ +#ifndef LOOKBACKNUMS +#define LOOKBACKNUMS 20 /* arbitrary constant */ +#endif + + +#endif diff --git a/src/lua/lmem.c b/src/lua/lmem.c new file mode 100644 index 00000000..8fdecef3 --- /dev/null +++ b/src/lua/lmem.c @@ -0,0 +1,150 @@ +/* +** $Id: lmem.c,v 1.3 2001/11/26 23:00:24 darkgod Exp $ +** Interface to Memory Manager +** See Copyright Notice in lua.h +*/ + + +#include <stdlib.h> + +#include "lua.h" + +#include "ldo.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + + + +#ifdef LUA_DEBUG +/* +** {====================================================================== +** Controlled version for realloc. +** ======================================================================= +*/ + + +#include <assert.h> +#include <limits.h> +#include <string.h> + +#define realloc(b, s) debug_realloc(b, s) +#define malloc(b) debug_realloc(NULL, b) +#define free(b) debug_realloc(b, 0) + + +/* ensures maximum alignment for HEADER */ +#define HEADER (sizeof(union L_Umaxalign)) + +#define MARKSIZE 16 +#define MARK 0x55 /* 01010101 (a nice pattern) */ + + +#define blocksize(b) ((unsigned long *)((char *)(b) - HEADER)) + +unsigned long memdebug_numblocks = 0; +unsigned long memdebug_total = 0; +unsigned long memdebug_maxmem = 0; +unsigned long memdebug_memlimit = LONG_MAX; + + +static void *checkblock (void *block) { + unsigned long *b = blocksize(block); + unsigned long size = *b; + int i; + for (i=0;i<MARKSIZE;i++) + assert(*(((char *)b)+HEADER+size+i) == MARK+i); /* corrupted block? */ + memdebug_numblocks--; + memdebug_total -= size; + return b; +} + + +static void freeblock (void *block) { + if (block) { + size_t size = *blocksize(block); + block = checkblock(block); + memset(block, -1, size+HEADER+MARKSIZE); /* erase block */ + (free)(block); /* free original block */ + } +} + + +static void *debug_realloc (void *block, size_t size) { + if (size == 0) { + freeblock(block); + return NULL; + } + else if (memdebug_total+size > memdebug_memlimit) + return NULL; /* to test memory allocation errors */ + else { + size_t realsize = HEADER+size+MARKSIZE; + char *newblock = (char *)(malloc)(realsize); /* alloc a new block */ + int i; + if (realsize < size) return NULL; /* overflow! */ + if (newblock == NULL) return NULL; + if (block) { + size_t oldsize = *blocksize(block); + if (oldsize > size) oldsize = size; + memcpy(newblock+HEADER, block, oldsize); + freeblock(block); /* erase (and check) old copy */ + } + memdebug_total += size; + if (memdebug_total > memdebug_maxmem) memdebug_maxmem = memdebug_total; + memdebug_numblocks++; + *(unsigned long *)newblock = size; + for (i=0;i<MARKSIZE;i++) + *(newblock+HEADER+size+i) = (char)(MARK+i); + return newblock+HEADER; + } +} + + +/* }====================================================================== */ +#endif + + + +/* +** Real ISO (ANSI) systems do not need these tests; +** but some systems (Sun OS) are not that ISO... +*/ +#ifdef OLD_ANSI +#define realloc(b,s) ((b) == NULL ? malloc(s) : (realloc)(b, s)) +#define free(b) if (b) (free)(b) +#endif + + +void *luaM_growaux (lua_State *L, void *block, size_t nelems, + int inc, size_t size, const char *errormsg, size_t limit) { + size_t newn = nelems+inc; + if (nelems >= limit-inc) lua_error(L, errormsg); + if ((newn ^ nelems) <= nelems || /* still the same power-of-2 limit? */ + (nelems > 0 && newn < MINPOWER2)) /* or block already is MINPOWER2? */ + return block; /* do not need to reallocate */ + else /* it crossed a power-of-2 boundary; grow to next power */ + return luaM_realloc(L, block, luaO_power2(newn)*size); +} + + +/* +** generic allocation routine. +*/ +void *luaM_realloc (lua_State *L, void *block, lint32 size) { + if (size == 0) { + free(block); /* block may be NULL; that is OK for free */ + return NULL; + } + else if (size >= MAX_SIZET) + lua_error(L, "memory allocation error: block too big"); + block = realloc(block, size); + if (block == NULL) { + if (L) + luaD_breakrun(L, LUA_ERRMEM); /* break run without error message */ + else return NULL; /* error before creating state! */ + } + return block; +} + + diff --git a/src/lua/lmem.h b/src/lua/lmem.h new file mode 100644 index 00000000..0d27c336 --- /dev/null +++ b/src/lua/lmem.h @@ -0,0 +1,42 @@ +/* +** $Id: lmem.h,v 1.3 2001/11/26 23:00:24 darkgod Exp $ +** Interface to Memory Manager +** See Copyright Notice in lua.h +*/ + +#ifndef lmem_h +#define lmem_h + + +#include <stddef.h> + +#include "llimits.h" +#include "lua.h" + +void *luaM_realloc (lua_State *L, void *oldblock, lint32 size); +void *luaM_growaux (lua_State *L, void *block, size_t nelems, + int inc, size_t size, const char *errormsg, + size_t limit); + +#define luaM_free(L, b) luaM_realloc(L, (b), 0) +#define luaM_malloc(L, t) luaM_realloc(L, NULL, (t)) +#define luaM_new(L, t) ((t *)luaM_malloc(L, sizeof(t))) +#define luaM_newvector(L, n,t) ((t *)luaM_malloc(L, (n)*(lint32)sizeof(t))) + +#define luaM_growvector(L, v,nelems,inc,t,e,l) \ + ((v)=(t *)luaM_growaux(L, v,nelems,inc,sizeof(t),e,l)) + +#define luaM_reallocvector(L, v,n,t) \ + ((v)=(t *)luaM_realloc(L, v,(n)*(lint32)sizeof(t))) + + +#ifdef LUA_DEBUG +extern unsigned long memdebug_numblocks; +extern unsigned long memdebug_total; +extern unsigned long memdebug_maxmem; +extern unsigned long memdebug_memlimit; +#endif + + +#endif + diff --git a/src/lua/lobject.c b/src/lua/lobject.c new file mode 100644 index 00000000..cd9d1f0b --- /dev/null +++ b/src/lua/lobject.c @@ -0,0 +1,125 @@ +/* +** $Id: lobject.c,v 1.3 2001/11/26 23:00:24 darkgod Exp $ +** Some generic functions over Lua objects +** See Copyright Notice in lua.h +*/ + +#include <ctype.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "lua.h" + +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + + +const TObject luaO_nilobject = {LUA_TNIL, {NULL}}; + + +const char *const luaO_typenames[] = { + "userdata", "nil", "number", "string", "table", "function" +}; + + + +/* +** returns smaller power of 2 larger than `n' (minimum is MINPOWER2) +*/ +lint32 luaO_power2 (lint32 n) { + lint32 p = MINPOWER2; + while (p<=n) p<<=1; + return p; +} + + +int luaO_equalObj (const TObject *t1, const TObject *t2) { + if (ttype(t1) != ttype(t2)) return 0; + switch (ttype(t1)) { + case LUA_TNUMBER: + return nvalue(t1) == nvalue(t2); + case LUA_TSTRING: case LUA_TUSERDATA: + return tsvalue(t1) == tsvalue(t2); + case LUA_TTABLE: + return hvalue(t1) == hvalue(t2); + case LUA_TFUNCTION: + return clvalue(t1) == clvalue(t2); + default: + LUA_ASSERT(ttype(t1) == LUA_TNIL, "invalid type"); + return 1; /* LUA_TNIL */ + } +} + + +char *luaO_openspace (lua_State *L, size_t n) { + if (n > L->Mbuffsize) { + luaM_reallocvector(L, L->Mbuffer, n, char); + L->nblocks += (n - L->Mbuffsize)*sizeof(char); + L->Mbuffsize = n; + } + return L->Mbuffer; +} + + +int luaO_str2d (const char *s, Number *result) { /* LUA_NUMBER */ + char *endptr; + Number res = lua_str2number(s, &endptr); + if (endptr == s) return 0; /* no conversion */ + while (isspace((unsigned char)*endptr)) endptr++; + if (*endptr != '\0') return 0; /* invalid trailing characters? */ + *result = res; + return 1; +} + + +/* maximum length of a string format for `luaO_verror' */ +#define MAX_VERROR 280 + +/* this function needs to handle only '%d' and '%.XXs' formats */ +void luaO_verror (lua_State *L, const char *fmt, ...) { + va_list argp; + char buff[MAX_VERROR]; /* to hold formatted message */ + va_start(argp, fmt); + vsprintf(buff, fmt, argp); + va_end(argp); + lua_error(L, buff); +} + + +void luaO_chunkid (char *out, const char *source, int bufflen) { + if (*source == '=') { + strncpy(out, source+1, bufflen); /* remove first char */ + out[bufflen-1] = '\0'; /* ensures null termination */ + } + else { + if (*source == '@') { + int l; + source++; /* skip the `@' */ + bufflen -= sizeof("file `...%s'"); + l = strlen(source); + if (l>bufflen) { + source += (l-bufflen); /* get last part of file name */ + sprintf(out, "file `...%.99s'", source); + } + else + sprintf(out, "file `%.99s'", source); + } + else { + int len = strcspn(source, "\n"); /* stop at first newline */ + bufflen -= sizeof("string \"%.*s...\""); + if (len > bufflen) len = bufflen; + if (source[len] != '\0') { /* must truncate? */ + strcpy(out, "string \""); + out += strlen(out); + strncpy(out, source, len); + strcpy(out+len, "...\""); + } + else + sprintf(out, "string \"%.99s\"", source); + } + } +} diff --git a/src/lua/lobject.h b/src/lua/lobject.h new file mode 100644 index 00000000..ce978205 --- /dev/null +++ b/src/lua/lobject.h @@ -0,0 +1,204 @@ +/* +** $Id: lobject.h,v 1.3 2001/11/26 23:00:24 darkgod Exp $ +** Type definitions for Lua objects +** See Copyright Notice in lua.h +*/ + +#ifndef lobject_h +#define lobject_h + + +#include "llimits.h" +#include "lua.h" + + +#ifdef LUA_DEBUG +#undef NDEBUG +#include <assert.h> +#define LUA_INTERNALERROR(s) assert(((void)s,0)) +#define LUA_ASSERT(c,s) assert(((void)s,(c))) +#else +#define LUA_INTERNALERROR(s) /* empty */ +#define LUA_ASSERT(c,s) /* empty */ +#endif + + +#ifdef LUA_DEBUG +/* to avoid warnings, and make sure value is really unused */ +#define UNUSED(x) (x=0, (void)(x)) +#else +#define UNUSED(x) ((void)(x)) /* to avoid warnings */ +#endif + + +/* mark for closures active in the stack */ +#define LUA_TMARK 6 + + +/* tags for values visible from Lua == first user-created tag */ +#define NUM_TAGS 6 + + +/* check whether `t' is a mark */ +#define is_T_MARK(t) ((t) == LUA_TMARK) + + +typedef union { + struct TString *ts; /* LUA_TSTRING, LUA_TUSERDATA */ + struct Closure *cl; /* LUA_TFUNCTION */ + struct Hash *a; /* LUA_TTABLE */ + struct CallInfo *i; /* LUA_TLMARK */ + Number n; /* LUA_TNUMBER */ +} Value; + + +/* Macros to access values */ +#define ttype(o) ((o)->ttype) +#define nvalue(o) ((o)->value.n) +#define tsvalue(o) ((o)->value.ts) +#define clvalue(o) ((o)->value.cl) +#define hvalue(o) ((o)->value.a) +#define infovalue(o) ((o)->value.i) +#define svalue(o) (tsvalue(o)->str) + + +typedef struct lua_TObject { + int ttype; + Value value; +} TObject; + + +/* +** String headers for string table +*/ + +/* +** most `malloc' libraries allocate memory in blocks of 8 bytes. TSPACK +** tries to make sizeof(TString) a multiple of this granularity, to reduce +** waste of space. +*/ +#define TSPACK ((int)sizeof(int)) + +typedef struct TString { + union { + struct { /* for strings */ + unsigned long hash; + int constindex; /* hint to reuse constants */ + } s; + struct { /* for userdata */ + int tag; + void *value; + } d; + } u; + size_t len; + struct TString *nexthash; /* chain for hash table */ + int marked; + char str[TSPACK]; /* variable length string!! must be the last field! */ +} TString; + + +/* +** Function Prototypes +*/ +typedef struct Proto { + Number *knum; /* Number numbers used by the function */ + int nknum; /* size of `knum' */ + struct TString **kstr; /* strings used by the function */ + int nkstr; /* size of `kstr' */ + struct Proto **kproto; /* functions defined inside the function */ + int nkproto; /* size of `kproto' */ + Instruction *code; + int ncode; /* size of `code'; when 0 means an incomplete `Proto' */ + short numparams; + short is_vararg; + short maxstacksize; + short marked; + struct Proto *next; + /* debug information */ + int *lineinfo; /* map from opcodes to source lines */ + int nlineinfo; /* size of `lineinfo' */ + int nlocvars; + struct LocVar *locvars; /* information about local variables */ + int lineDefined; + TString *source; +} Proto; + + +typedef struct LocVar { + TString *varname; + int startpc; /* first point where variable is active */ + int endpc; /* first point where variable is dead */ +} LocVar; + + +/* +** Closures +*/ +typedef struct Closure { + union { + lua_CFunction c; /* C functions */ + struct Proto *l; /* Lua functions */ + } f; + struct Closure *next; + struct Closure *mark; /* marked closures (point to itself when not marked) */ + short isC; /* 0 for Lua functions, 1 for C functions */ + short nupvalues; + TObject upvalue[1]; +} Closure; + + +#define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->isC) + + +typedef struct Node { + TObject key; + TObject val; + struct Node *next; /* for chaining */ +} Node; + +typedef struct Hash { + Node *node; + int htag; + int size; + Node *firstfree; /* this position is free; all positions after it are full */ + struct Hash *next; + struct Hash *mark; /* marked tables (point to itself when not marked) */ +} Hash; + + +/* unmarked tables and closures are represented by pointing `mark' to +** themselves +*/ +#define ismarked(x) ((x)->mark != (x)) + + +/* +** informations about a call (for debugging) +*/ +typedef struct CallInfo { + struct Closure *func; /* function being called */ + const Instruction **pc; /* current pc of called function */ + int lastpc; /* last pc traced */ + int line; /* current line */ + int refi; /* current index in `lineinfo' */ +} CallInfo; + + +extern const TObject luaO_nilobject; +extern const char *const luaO_typenames[]; + + +#define luaO_typename(o) (luaO_typenames[ttype(o)]) + + +lint32 luaO_power2 (lint32 n); +char *luaO_openspace (lua_State *L, size_t n); + +int luaO_equalObj (const TObject *t1, const TObject *t2); +int luaO_str2d (const char *s, Number *result); + +void luaO_verror (lua_State *L, const char *fmt, ...); +void luaO_chunkid (char *out, const char *source, int len); + + +#endif diff --git a/src/lua/lopcodes.h b/src/lua/lopcodes.h new file mode 100644 index 00000000..59740896 --- /dev/null +++ b/src/lua/lopcodes.h @@ -0,0 +1,168 @@ +/* +** $Id: lopcodes.h,v 1.5 2004/06/04 13:42:10 neil Exp $ +** Opcodes for Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#ifndef lopcodes_h +#define lopcodes_h + +#include "llimits.h" + + +/*=========================================================================== + We assume that instructions are unsigned numbers. + All instructions have an opcode in the first 6 bits. Moreover, + an instruction can have 0, 1, or 2 arguments. Instructions can + have the following types: + type 0: no arguments + type 1: 1 unsigned argument in the higher bits (called `U') + type 2: 1 signed argument in the higher bits (`S') + type 3: 1st unsigned argument in the higher bits (`A') + 2nd unsigned argument in the middle bits (`B') + + A signed argument is represented in excess K; that is, the number + value is the unsigned value minus K. K is exactly the maximum value + for that argument (so that -max is represented by 0, and +max is + represented by 2*max), which is half the maximum for the corresponding + unsigned argument. + + The size of each argument is defined in `llimits.h'. The usual is an + instruction with 32 bits, U arguments with 26 bits (32-6), B arguments + with 9 bits, and A arguments with 17 bits (32-6-9). For small + installations, the instruction size can be 16, so U has 10 bits, + and A and B have 5 bits each. +===========================================================================*/ + + + + +/* creates a mask with `n' 1 bits at position `p' */ +#define MASK1(n,p) ((~((~(Instruction)0)<<n))<<p) + +/* creates a mask with `n' 0 bits at position `p' */ +#define MASK0(n,p) (~MASK1(n,p)) + +/* +** the following macros help to manipulate instructions +*/ + +#define CREATE_0(o) ((Instruction)(o)) +#define GET_OPCODE(i) ((OpCode)((i)&MASK1(SIZE_OP,0))) +#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,0)) | (Instruction)(o))) + +#define CREATE_U(o,u) ((Instruction)(o) | ((Instruction)(u)<<POS_U)) +#define GETARG_U(i) ((int)((i)>>POS_U)) +#define SETARG_U(i,u) ((i) = (((i)&MASK0(SIZE_U,POS_U)) | \ + ((Instruction)(u)<<POS_U))) + +#define CREATE_S(o,s) CREATE_U((o),(s)+MAXARG_S) +#define GETARG_S(i) (GETARG_U(i)-MAXARG_S) +#define SETARG_S(i,s) SETARG_U((i),(s)+MAXARG_S) + + +#define CREATE_AB(o,a,b) ((Instruction)(o) | ((Instruction)(a)<<POS_A) \ + | ((Instruction)(b)<<POS_B)) +#define GETARG_A(i) ((int)((i)>>POS_A)) +#define SETARG_A(i,a) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \ + ((Instruction)(a)<<POS_A))) +#define GETARG_B(i) ((int)(((i)>>POS_B) & MASK1(SIZE_B,0))) +#define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \ + ((Instruction)(b)<<POS_B))) + + +/* +** K = U argument used as index to `kstr' +** J = S argument used as jump offset (relative to pc of next instruction) +** L = unsigned argument used as index of local variable +** N = U argument used as index to `knum' +*/ + +typedef enum { +/*---------------------------------------------------------------------- +name args stack before stack after side effects +------------------------------------------------------------------------*/ +OP_END,/* - - (return) no results */ +OP_RETURN,/* U v_n-v_x(at u) (return) returns v_x-v_n */ + +OP_CALL,/* A B v_n-v_1 f(at a) r_b-r_1 f(v1,...,v_n) */ +OP_TAILCALL,/* A B v_n-v_1 f(at a) (return) f(v1,...,v_n) */ + +OP_PUSHNIL,/* U - nil_1-nil_u */ +OP_POP,/* U a_u-a_1 - */ + +OP_PUSHINT,/* S - (Number)s */ +OP_PUSHSTRING,/* K - KSTR[k] */ +OP_PUSHNUM,/* N - KNUM[n] */ +OP_PUSHNEGNUM,/* N - -KNUM[n] */ + +OP_PUSHUPVALUE,/* U - Closure[u] */ + +OP_GETLOCAL,/* L - LOC[l] */ +OP_GETGLOBAL,/* K - VAR[KSTR[k]] */ + +OP_GETTABLE,/* - i t t[i] */ +OP_GETDOTTED,/* K t t[KSTR[k]] */ +OP_GETINDEXED,/* L t t[LOC[l]] */ +OP_PUSHSELF,/* K t t t[KSTR[k]] */ + +OP_CREATETABLE,/* U - newarray(size = u) */ + +OP_SETLOCAL,/* L x - LOC[l]=x */ +OP_SETGLOBAL,/* K x - VAR[KSTR[k]]=x */ +OP_SETTABLE,/* A B v a_a-a_1 i t (pops b values) t[i]=v */ + +OP_SETLIST,/* A B v_b-v_1 t t t[i+a*FPF]=v_i */ +OP_SETMAP,/* U v_u k_u - v_1 k_1 t t t[k_i]=v_i */ + +OP_ADD,/* - y x x+y */ +OP_ADDI,/* S x x+s */ +OP_SUB,/* - y x x-y */ +OP_MULT,/* - y x x*y */ +OP_DIV,/* - y x x/y */ +OP_POW,/* - y x x^y */ +OP_CONCAT,/* U v_u-v_1 v1..-..v_u */ +OP_MINUS,/* - x -x */ +OP_NOT,/* - x (x==nil)? 1 : nil */ + +OP_JMPNE,/* J y x - (x~=y)? PC+=s */ +OP_JMPEQ,/* J y x - (x==y)? PC+=s */ +OP_JMPLT,/* J y x - (x<y)? PC+=s */ +OP_JMPLE,/* J y x - (x<y)? PC+=s */ +OP_JMPGT,/* J y x - (x>y)? PC+=s */ +OP_JMPGE,/* J y x - (x>=y)? PC+=s */ + +OP_JMPT,/* J x - (x~=nil)? PC+=s */ +OP_JMPF,/* J x - (x==nil)? PC+=s */ +OP_JMPONT,/* J x (x~=nil)? x : - (x~=nil)? PC+=s */ +OP_JMPONF,/* J x (x==nil)? x : - (x==nil)? PC+=s */ +OP_JMP,/* J - - PC+=s */ + +OP_PUSHNILJMP,/* - - nil PC++; */ + +OP_FORPREP,/* J */ +OP_FORLOOP,/* J */ + +OP_LFORPREP,/* J */ +OP_LFORLOOP,/* J */ + +OP_CLOSURE/* A B v_b-v_1 closure(KPROTO[a], v_1-v_b) */ + +} OpCode; + +#define NUM_OPCODES ((int)OP_CLOSURE+1) + + +#define ISJUMP(o) (OP_JMPNE <= (o) && (o) <= OP_JMP) + + + +/* special code to fit a LUA_MULTRET inside an argB */ +#define MULT_RET 255 /* (<=MAXARG_B) */ +#if MULT_RET>MAXARG_B +#undef MULT_RET +#define MULT_RET MAXARG_B +#endif + + +#endif diff --git a/src/lua/lparser.c b/src/lua/lparser.c new file mode 100644 index 00000000..1ac1f37b --- /dev/null +++ b/src/lua/lparser.c @@ -0,0 +1,1129 @@ +/* +** $Id: lparser.c,v 1.8 2004/06/04 13:42:10 neil Exp $ +** LL(1) Parser and code generator for Lua +** See Copyright Notice in lua.h +*/ + + +#include <stdio.h> +#include <string.h> + +#include "lua.h" + +#include "lcode.h" +#include "lfunc.h" +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" + +#ifdef __MWERKS__ +/* To avoid name conflict resulting from the use of prefix header */ +#define stat lua_hack_stat +#endif /* __MWERKS__ */ + + +/* +** Constructors descriptor: +** `n' indicates number of elements, and `k' signals whether +** it is a list constructor (k = 0) or a record constructor (k = 1) +** or empty (k = ';' or '}') +*/ +typedef struct Constdesc { + int n; + int k; +} Constdesc; + + +typedef struct Breaklabel { + struct Breaklabel *previous; /* chain */ + int breaklist; + int stacklevel; +} Breaklabel; + + + + +/* +** prototypes for recursive non-terminal functions +*/ +static void body (LexState *ls, int needself, int line); +static void chunk (LexState *ls); +static void constructor (LexState *ls); +static void expr (LexState *ls, expdesc *v); +static void exp1 (LexState *ls); + + + +static void next (LexState *ls) { + ls->lastline = ls->linenumber; + if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ + ls->t = ls->lookahead; /* use this one */ + ls->lookahead.token = TK_EOS; /* and discharge it */ + } + else + ls->t.token = luaX_lex(ls, &ls->t.seminfo); /* read next token */ +} + + +static void lookahead (LexState *ls) { + LUA_ASSERT(ls->lookahead.token == TK_EOS, "two look-aheads"); + ls->lookahead.token = luaX_lex(ls, &ls->lookahead.seminfo); +} + + +static void error_expected (LexState *ls, int token) { + char buff[100], t[TOKEN_LEN]; + luaX_token2str(token, t); + sprintf(buff, "`%.20s' expected", t); + luaK_error(ls, buff); +} + + +static void check (LexState *ls, int c) { + if (ls->t.token != c) + error_expected(ls, c); + next(ls); +} + + +static void check_condition (LexState *ls, int c, const char *msg) { + if (!c) luaK_error(ls, msg); +} + + +static int optional (LexState *ls, int c) { + if (ls->t.token == c) { + next(ls); + return 1; + } + else return 0; +} + + +static void check_match (LexState *ls, int what, int who, int where) { + if (ls->t.token != what) { + if (where == ls->linenumber) + error_expected(ls, what); + else { + char buff[100]; + char t_what[TOKEN_LEN], t_who[TOKEN_LEN]; + luaX_token2str(what, t_what); + luaX_token2str(who, t_who); + sprintf(buff, "`%.20s' expected (to close `%.20s' at line %d)", + t_what, t_who, where); + luaK_error(ls, buff); + } + } + next(ls); +} + + +static int string_constant (FuncState *fs, TString *s) { + Proto *f = fs->f; + int c = s->u.s.constindex; + if (c >= f->nkstr || f->kstr[c] != s) { + luaM_growvector(fs->L, f->kstr, f->nkstr, 1, TString *, + "constant table overflow", MAXARG_U); + c = f->nkstr++; + f->kstr[c] = s; + s->u.s.constindex = c; /* hint for next time */ + } + return c; +} + + +static void code_string (LexState *ls, TString *s) { + luaK_kstr(ls, string_constant(ls->fs, s)); +} + + +static TString *str_checkname (LexState *ls) { + TString *ts; + check_condition(ls, (ls->t.token == TK_NAME), "<name> expected"); + ts = ls->t.seminfo.ts; + next(ls); + return ts; +} + + +static int checkname (LexState *ls) { + return string_constant(ls->fs, str_checkname(ls)); +} + + +static int luaI_registerlocalvar (LexState *ls, TString *varname) { + Proto *f = ls->fs->f; + luaM_growvector(ls->L, f->locvars, f->nlocvars, 1, LocVar, "", MAX_INT); + f->locvars[f->nlocvars].varname = varname; + return f->nlocvars++; +} + + +static void new_localvar (LexState *ls, TString *name, int n) { + FuncState *fs = ls->fs; + luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, "local variables"); + fs->actloc[fs->nactloc+n] = luaI_registerlocalvar(ls, name); +} + + +static void adjustlocalvars (LexState *ls, int nvars) { + FuncState *fs = ls->fs; + while (nvars--) + fs->f->locvars[fs->actloc[fs->nactloc++]].startpc = fs->pc; +} + + +static void removelocalvars (LexState *ls, int nvars) { + FuncState *fs = ls->fs; + while (nvars--) + fs->f->locvars[fs->actloc[--fs->nactloc]].endpc = fs->pc; +} + + +static void new_localvarstr (LexState *ls, const char *name, int n) { + new_localvar(ls, luaS_newfixed(ls->L, name), n); +} + + +static int search_local (LexState *ls, TString *n, expdesc *var) { + FuncState *fs; + int level = 0; + for (fs=ls->fs; fs; fs=fs->prev) { + int i; + for (i=fs->nactloc-1; i >= 0; i--) { + if (n == fs->f->locvars[fs->actloc[i]].varname) { + var->k = VLOCAL; + var->u.index = i; + return level; + } + } + level++; /* `var' not found; check outer level */ + } + var->k = VGLOBAL; /* not found in any level; must be global */ + return -1; +} + + +static void singlevar (LexState *ls, TString *n, expdesc *var) { + int level = search_local(ls, n, var); + if (level >= 1) /* neither local (0) nor global (-1)? */ + luaX_syntaxerror(ls, "cannot access a variable in outer scope", n->str); + else if (level == -1) /* global? */ + var->u.index = string_constant(ls->fs, n); +} + + +static int indexupvalue (LexState *ls, expdesc *v) { + FuncState *fs = ls->fs; + int i; + for (i=0; i<fs->nupvalues; i++) { + if (fs->upvalues[i].k == v->k && fs->upvalues[i].u.index == v->u.index) + return i; + } + /* new one */ + luaX_checklimit(ls, fs->nupvalues+1, MAXUPVALUES, "upvalues"); + fs->upvalues[fs->nupvalues] = *v; + return fs->nupvalues++; +} + + +static void pushupvalue (LexState *ls, TString *n) { + FuncState *fs = ls->fs; + expdesc v; + int level = search_local(ls, n, &v); + if (level == -1) { /* global? */ + if (fs->prev == NULL) + luaX_syntaxerror(ls, "cannot access upvalue in main", n->str); + v.u.index = string_constant(fs->prev, n); + } + else if (level != 1) + luaX_syntaxerror(ls, + "upvalue must be global or local to immediately outer scope", n->str); + luaK_code1(fs, OP_PUSHUPVALUE, indexupvalue(ls, &v)); +} + + +static void adjust_mult_assign (LexState *ls, int nvars, int nexps) { + FuncState *fs = ls->fs; + int diff = nexps - nvars; + if (nexps > 0 && luaK_lastisopen(fs)) { /* list ends in a function call */ + diff--; /* do not count function call itself */ + if (diff <= 0) { /* more variables than values? */ + luaK_setcallreturns(fs, -diff); /* function call provide extra values */ + diff = 0; /* no more difference */ + } + else /* more values than variables */ + luaK_setcallreturns(fs, 0); /* call should provide no value */ + } + /* push or pop eventual difference between list lengths */ + luaK_adjuststack(fs, diff); +} + + +static void code_params (LexState *ls, int nparams, int dots) { + FuncState *fs = ls->fs; + adjustlocalvars(ls, nparams); + luaX_checklimit(ls, fs->nactloc, MAXPARAMS, "parameters"); + fs->f->numparams = fs->nactloc; /* `self' could be there already */ + fs->f->is_vararg = dots; + if (dots) { + new_localvarstr(ls, "arg", 0); + adjustlocalvars(ls, 1); + } + luaK_deltastack(fs, fs->nactloc); /* count parameters in the stack */ +} + + +static void enterbreak (FuncState *fs, Breaklabel *bl) { + bl->stacklevel = fs->stacklevel; + bl->breaklist = NO_JUMP; + bl->previous = fs->bl; + fs->bl = bl; +} + + +static void leavebreak (FuncState *fs, Breaklabel *bl) { + fs->bl = bl->previous; + LUA_ASSERT(bl->stacklevel == fs->stacklevel, "wrong levels"); + luaK_patchlist(fs, bl->breaklist, luaK_getlabel(fs)); +} + + +static void pushclosure (LexState *ls, FuncState *func) { + FuncState *fs = ls->fs; + Proto *f = fs->f; + int i; + for (i=0; i<func->nupvalues; i++) + luaK_tostack(ls, &func->upvalues[i], 1); + luaM_growvector(ls->L, f->kproto, f->nkproto, 1, Proto *, + "constant table overflow", MAXARG_A); + f->kproto[f->nkproto++] = func->f; + luaK_code2(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues); +} + + +static void open_func (LexState *ls, FuncState *fs) { + Proto *f = luaF_newproto(ls->L); + fs->prev = ls->fs; /* linked list of funcstates */ + fs->ls = ls; + fs->L = ls->L; + ls->fs = fs; + fs->stacklevel = 0; + fs->nactloc = 0; + fs->nupvalues = 0; + fs->bl = NULL; + fs->f = f; + f->source = ls->source; + fs->pc = 0; + fs->lasttarget = 0; + fs->lastline = 0; + fs->jlt = NO_JUMP; + f->code = NULL; + f->maxstacksize = 0; + f->numparams = 0; /* default for main chunk */ + f->is_vararg = 0; /* default for main chunk */ +} + + +static void close_func (LexState *ls) { + lua_State *L = ls->L; + FuncState *fs = ls->fs; + Proto *f = fs->f; + luaK_code0(fs, OP_END); + luaK_getlabel(fs); /* close eventual list of pending jumps */ + luaM_reallocvector(L, f->code, fs->pc, Instruction); + luaM_reallocvector(L, f->kstr, f->nkstr, TString *); + luaM_reallocvector(L, f->knum, f->nknum, Number); + luaM_reallocvector(L, f->kproto, f->nkproto, Proto *); + removelocalvars(ls, fs->nactloc); + luaM_reallocvector(L, f->locvars, f->nlocvars, LocVar); + luaM_reallocvector(L, f->lineinfo, f->nlineinfo+1, int); + f->lineinfo[f->nlineinfo++] = MAX_INT; /* end flag */ + luaF_protook(L, f, fs->pc); /* proto is ok now */ + ls->fs = fs->prev; + LUA_ASSERT(fs->bl == NULL, "wrong list end"); +} + + +Proto *luaY_parser (lua_State *L, ZIO *z) { + struct LexState lexstate; + struct FuncState funcstate; + luaX_setinput(L, &lexstate, z, luaS_new(L, zname(z))); + open_func(&lexstate, &funcstate); + next(&lexstate); /* read first token */ + chunk(&lexstate); + check_condition(&lexstate, (lexstate.t.token == TK_EOS), "<eof> expected"); + close_func(&lexstate); + LUA_ASSERT(funcstate.prev == NULL, "wrong list end"); + LUA_ASSERT(funcstate.nupvalues == 0, "no upvalues in main"); + return funcstate.f; +} + + + +/*============================================================*/ +/* GRAMMAR RULES */ +/*============================================================*/ + + +static int explist1 (LexState *ls) { + /* explist1 -> expr { ',' expr } */ + int n = 1; /* at least one expression */ + expdesc v; + expr(ls, &v); + while (ls->t.token == ',') { + luaK_tostack(ls, &v, 1); /* gets only 1 value from previous expression */ + next(ls); /* skip comma */ + expr(ls, &v); + n++; + } + luaK_tostack(ls, &v, 0); /* keep open number of values of last expression */ + return n; +} + + +static void funcargs (LexState *ls, int slf) { + FuncState *fs = ls->fs; + int slevel = fs->stacklevel - slf - 1; /* where is func in the stack */ + switch (ls->t.token) { + case '(': { /* funcargs -> '(' [ explist1 ] ')' */ + int line = ls->linenumber; + int nargs = 0; + next(ls); + if (ls->t.token != ')') /* arg list not empty? */ + nargs = explist1(ls); + check_match(ls, ')', '(', line); +#ifdef LUA_COMPAT_ARGRET + if (nargs > 0) /* arg list is not empty? */ + luaK_setcallreturns(fs, 1); /* last call returns only 1 value */ +#else + UNUSED(nargs); /* to avoid warnings */ +#endif + break; + } + case '{': { /* funcargs -> constructor */ + constructor(ls); + break; + } + case TK_STRING: { /* funcargs -> STRING */ + code_string(ls, ls->t.seminfo.ts); /* must use `seminfo' before `next' */ + next(ls); + break; + } + default: { + luaK_error(ls, "function arguments expected"); + break; + } + } + fs->stacklevel = slevel; /* call will remove function and arguments */ + luaK_code2(fs, OP_CALL, slevel, MULT_RET); +} + + +static void var_or_func_tail (LexState *ls, expdesc *v) { + for (;;) { + switch (ls->t.token) { + case '.': { /* var_or_func_tail -> '.' NAME */ + next(ls); + luaK_tostack(ls, v, 1); /* `v' must be on stack */ + luaK_kstr(ls, checkname(ls)); + v->k = VINDEXED; + break; + } + case '[': { /* var_or_func_tail -> '[' exp1 ']' */ + next(ls); + luaK_tostack(ls, v, 1); /* `v' must be on stack */ + v->k = VINDEXED; + exp1(ls); + check(ls, ']'); + break; + } + case ':': { /* var_or_func_tail -> ':' NAME funcargs */ + int name; + next(ls); + name = checkname(ls); + luaK_tostack(ls, v, 1); /* `v' must be on stack */ + luaK_code1(ls->fs, OP_PUSHSELF, name); + funcargs(ls, 1); + v->k = VEXP; + v->u.l.t = v->u.l.f = NO_JUMP; + break; + } + case '(': case TK_STRING: case '{': { /* var_or_func_tail -> funcargs */ + luaK_tostack(ls, v, 1); /* `v' must be on stack */ + funcargs(ls, 0); + v->k = VEXP; + v->u.l.t = v->u.l.f = NO_JUMP; + break; + } + default: return; /* should be follow... */ + } + } +} + + +static void var_or_func (LexState *ls, expdesc *v) { + /* var_or_func -> ['%'] NAME var_or_func_tail */ + if (optional(ls, '%')) { /* upvalue? */ + pushupvalue(ls, str_checkname(ls)); + v->k = VEXP; + v->u.l.t = v->u.l.f = NO_JUMP; + } + else /* variable name */ + singlevar(ls, str_checkname(ls), v); + var_or_func_tail(ls, v); +} + + + +/* +** {====================================================================== +** Rules for Constructors +** ======================================================================= +*/ + + +static void recfield (LexState *ls) { + /* recfield -> (NAME | '['exp1']') = exp1 */ + switch (ls->t.token) { + case TK_NAME: { + luaK_kstr(ls, checkname(ls)); + break; + } + case '[': { + next(ls); + exp1(ls); + check(ls, ']'); + break; + } + default: luaK_error(ls, "<name> or `[' expected"); + } + check(ls, '='); + exp1(ls); +} + + +static int recfields (LexState *ls) { + /* recfields -> recfield { ',' recfield } [','] */ + FuncState *fs = ls->fs; + int n = 1; /* at least one element */ + recfield(ls); + while (ls->t.token == ',') { + next(ls); + if (ls->t.token == ';' || ls->t.token == '}') + break; + recfield(ls); + n++; + if (n%RFIELDS_PER_FLUSH == 0) + luaK_code1(fs, OP_SETMAP, RFIELDS_PER_FLUSH); + } + luaK_code1(fs, OP_SETMAP, n%RFIELDS_PER_FLUSH); + return n; +} + + +static int listfields (LexState *ls) { + /* listfields -> exp1 { ',' exp1 } [','] */ + FuncState *fs = ls->fs; + int n = 1; /* at least one element */ + exp1(ls); + while (ls->t.token == ',') { + next(ls); + if (ls->t.token == ';' || ls->t.token == '}') + break; + exp1(ls); + n++; + luaX_checklimit(ls, n/LFIELDS_PER_FLUSH, MAXARG_A, + "`item groups' in a list initializer"); + if (n%LFIELDS_PER_FLUSH == 0) + luaK_code2(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH); + } + luaK_code2(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH, n%LFIELDS_PER_FLUSH); + return n; +} + + + +static void constructor_part (LexState *ls, Constdesc *cd) { + switch (ls->t.token) { + case ';': case '}': { /* constructor_part -> empty */ + cd->n = 0; + cd->k = ls->t.token; + break; + } + case TK_NAME: { /* may be listfields or recfields */ + lookahead(ls); + if (ls->lookahead.token != '=') /* expression? */ + goto case_default; + /* else go through to recfields */ + } + case '[': { /* constructor_part -> recfields */ + cd->n = recfields(ls); + cd->k = 1; /* record */ + break; + } + default: { /* constructor_part -> listfields */ + case_default: + cd->n = listfields(ls); + cd->k = 0; /* list */ + break; + } + } +} + + +static void constructor (LexState *ls) { + /* constructor -> '{' constructor_part [';' constructor_part] '}' */ + FuncState *fs = ls->fs; + int line = ls->linenumber; + int pc = luaK_code1(fs, OP_CREATETABLE, 0); + int nelems; + Constdesc cd; + check(ls, '{'); + constructor_part(ls, &cd); + nelems = cd.n; + if (optional(ls, ';')) { + Constdesc other_cd; + constructor_part(ls, &other_cd); + check_condition(ls, (cd.k != other_cd.k), "invalid constructor syntax"); + nelems += other_cd.n; + } + check_match(ls, '}', '{', line); + luaX_checklimit(ls, nelems, MAXARG_U, "elements in a table constructor"); + SETARG_U(fs->f->code[pc], nelems); /* set initial table size */ +} + +/* }====================================================================== */ + + + + +/* +** {====================================================================== +** Expression parsing +** ======================================================================= +*/ + + +static void simpleexp (LexState *ls, expdesc *v) { + FuncState *fs = ls->fs; + switch (ls->t.token) { + case TK_NUMBER: { /* simpleexp -> NUMBER */ + Number r = ls->t.seminfo.r; + next(ls); + luaK_number(fs, r); + break; + } + case TK_STRING: { /* simpleexp -> STRING */ + code_string(ls, ls->t.seminfo.ts); /* must use `seminfo' before `next' */ + next(ls); + break; + } + case TK_NIL: { /* simpleexp -> NIL */ + luaK_adjuststack(fs, -1); + next(ls); + break; + } + case '{': { /* simpleexp -> constructor */ + constructor(ls); + break; + } + case TK_FUNCTION: { /* simpleexp -> FUNCTION body */ + next(ls); + body(ls, 0, ls->linenumber); + break; + } + case '(': { /* simpleexp -> '(' expr ')' */ + next(ls); + expr(ls, v); + check(ls, ')'); + return; + } + case TK_NAME: case '%': { + var_or_func(ls, v); + return; + } + default: { + luaK_error(ls, "<expression> expected"); + return; + } + } + v->k = VEXP; + v->u.l.t = v->u.l.f = NO_JUMP; +} + + +static void exp1 (LexState *ls) { + expdesc v; + expr(ls, &v); + luaK_tostack(ls, &v, 1); +} + + +static UnOpr getunopr (int op) { + switch (op) { + case TK_NOT: return OPR_NOT; + case '-': return OPR_MINUS; + default: return OPR_NOUNOPR; + } +} + + +static BinOpr getbinopr (int op) { + switch (op) { + case '+': return OPR_ADD; + case '-': return OPR_SUB; + case '*': return OPR_MULT; + case '/': return OPR_DIV; + case '^': return OPR_POW; + case TK_CONCAT: return OPR_CONCAT; + case TK_NE: return OPR_NE; + case TK_EQ: return OPR_EQ; + case '<': return OPR_LT; + case TK_LE: return OPR_LE; + case '>': return OPR_GT; + case TK_GE: return OPR_GE; + case TK_AND: return OPR_AND; + case TK_OR: return OPR_OR; + default: return OPR_NOBINOPR; + } +} + + +static const struct { + char left; /* left priority for each binary operator */ + char right; /* right priority */ +} priority[] = { /* ORDER OPR */ + {5, 5}, {5, 5}, {6, 6}, {6, 6}, /* arithmetic */ + {9, 8}, {4, 3}, /* power and concat (right associative) */ + {2, 2}, {2, 2}, /* equality */ + {2, 2}, {2, 2}, {2, 2}, {2, 2}, /* order */ + {1, 1}, {1, 1} /* logical */ +}; + +#define UNARY_PRIORITY 7 /* priority for unary operators */ + + +/* +** subexpr -> (simplexep | unop subexpr) { binop subexpr } +** where `binop' is any binary operator with a priority higher than `limit' +*/ +static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { + BinOpr op; + UnOpr uop = getunopr(ls->t.token); + if (uop != OPR_NOUNOPR) { + next(ls); + subexpr(ls, v, UNARY_PRIORITY); + luaK_prefix(ls, uop, v); + } + else simpleexp(ls, v); + /* expand while operators have priorities higher than `limit' */ + op = getbinopr(ls->t.token); + while (op != OPR_NOBINOPR && priority[op].left > limit) { + expdesc v2; + BinOpr nextop; + next(ls); + luaK_infix(ls, op, v); + /* read sub-expression with higher priority */ + nextop = subexpr(ls, &v2, priority[op].right); + luaK_posfix(ls, op, v, &v2); + op = nextop; + } + return op; /* return first untreated operator */ +} + + +static void expr (LexState *ls, expdesc *v) { + subexpr(ls, v, -1); +} + +/* }==================================================================== */ + + +/* +** {====================================================================== +** Rules for Statements +** ======================================================================= +*/ + + +static int block_follow (int token) { + switch (token) { + case TK_ELSE: case TK_ELSEIF: case TK_END: + case TK_UNTIL: case TK_EOS: + return 1; + default: return 0; + } +} + + +static void block (LexState *ls) { + /* block -> chunk */ + FuncState *fs = ls->fs; + int nactloc = fs->nactloc; + chunk(ls); + luaK_adjuststack(fs, fs->nactloc - nactloc); /* remove local variables */ + removelocalvars(ls, fs->nactloc - nactloc); +} + + +static int assignment (LexState *ls, expdesc *v, int nvars) { + int left = 0; /* number of values left in the stack after assignment */ + luaX_checklimit(ls, nvars, MAXVARSLH, "variables in a multiple assignment"); + if (ls->t.token == ',') { /* assignment -> ',' NAME assignment */ + expdesc nv; + next(ls); + var_or_func(ls, &nv); + check_condition(ls, (nv.k != VEXP), "syntax error"); + left = assignment(ls, &nv, nvars+1); + } + else { /* assignment -> '=' explist1 */ + int nexps; + check(ls, '='); + nexps = explist1(ls); + adjust_mult_assign(ls, nvars, nexps); + } + if (v->k != VINDEXED) + luaK_storevar(ls, v); + else { /* there may be garbage between table-index and value */ + luaK_code2(ls->fs, OP_SETTABLE, left+nvars+2, 1); + left += 2; + } + return left; +} + + +static void cond (LexState *ls, expdesc *v) { + /* cond -> exp */ + expr(ls, v); /* read condition */ + luaK_goiftrue(ls->fs, v, 0); +} + + +static void whilestat (LexState *ls, int line) { + /* whilestat -> WHILE cond DO block END */ + FuncState *fs = ls->fs; + int while_init = luaK_getlabel(fs); + expdesc v; + Breaklabel bl; + enterbreak(fs, &bl); + next(ls); + cond(ls, &v); + check(ls, TK_DO); + block(ls); + luaK_patchlist(fs, luaK_jump(fs), while_init); + luaK_patchlist(fs, v.u.l.f, luaK_getlabel(fs)); + check_match(ls, TK_END, TK_WHILE, line); + leavebreak(fs, &bl); +} + + +static void repeatstat (LexState *ls, int line) { + /* repeatstat -> REPEAT block UNTIL cond */ + FuncState *fs = ls->fs; + int repeat_init = luaK_getlabel(fs); + expdesc v; + Breaklabel bl; + enterbreak(fs, &bl); + next(ls); + block(ls); + check_match(ls, TK_UNTIL, TK_REPEAT, line); + cond(ls, &v); + luaK_patchlist(fs, v.u.l.f, repeat_init); + leavebreak(fs, &bl); +} + + +static void forbody (LexState *ls, int nvar, OpCode prepfor, OpCode loopfor) { + /* forbody -> DO block END */ + FuncState *fs = ls->fs; + int prep = luaK_code1(fs, prepfor, NO_JUMP); + int blockinit = luaK_getlabel(fs); + check(ls, TK_DO); + adjustlocalvars(ls, nvar); /* scope for control variables */ + block(ls); + luaK_patchlist(fs, luaK_code1(fs, loopfor, NO_JUMP), blockinit); + luaK_patchlist(fs, prep, luaK_getlabel(fs)); + removelocalvars(ls, nvar); +} + + +static void fornum (LexState *ls, TString *varname) { + /* fornum -> NAME = exp1,exp1[,exp1] forbody */ + FuncState *fs = ls->fs; + check(ls, '='); + exp1(ls); /* initial value */ + check(ls, ','); + exp1(ls); /* limit */ + if (optional(ls, ',')) + exp1(ls); /* optional step */ + else + luaK_code1(fs, OP_PUSHINT, 1); /* default step */ + new_localvar(ls, varname, 0); + new_localvarstr(ls, "(limit)", 1); + new_localvarstr(ls, "(step)", 2); + forbody(ls, 3, OP_FORPREP, OP_FORLOOP); +} + + +static void forlist (LexState *ls, TString *indexname) { + /* forlist -> NAME,NAME IN exp1 forbody */ + TString *valname; + check(ls, ','); + valname = str_checkname(ls); + /* next test is dirty, but avoids `in' being a reserved word */ + check_condition(ls, + (ls->t.token == TK_NAME && ls->t.seminfo.ts == luaS_new(ls->L, "in")), + "`in' expected"); + next(ls); /* skip `in' */ + exp1(ls); /* table */ + new_localvarstr(ls, "(table)", 0); + new_localvar(ls, indexname, 1); + new_localvar(ls, valname, 2); + forbody(ls, 3, OP_LFORPREP, OP_LFORLOOP); +} + + +static void forstat (LexState *ls, int line) { + /* forstat -> fornum | forlist */ + FuncState *fs = ls->fs; + TString *varname; + Breaklabel bl; + enterbreak(fs, &bl); + next(ls); /* skip `for' */ + varname = str_checkname(ls); /* first variable name */ + switch (ls->t.token) { + case '=': fornum(ls, varname); break; + case ',': forlist(ls, varname); break; + default: luaK_error(ls, "`=' or `,' expected"); + } + check_match(ls, TK_END, TK_FOR, line); + leavebreak(fs, &bl); +} + + +static void test_then_block (LexState *ls, expdesc *v) { + /* test_then_block -> [IF | ELSEIF] cond THEN block */ + next(ls); /* skip IF or ELSEIF */ + cond(ls, v); + check(ls, TK_THEN); + block(ls); /* `then' part */ +} + + +static void ifstat (LexState *ls, int line) { + /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ + FuncState *fs = ls->fs; + expdesc v; + int escapelist = NO_JUMP; + test_then_block(ls, &v); /* IF cond THEN block */ + while (ls->t.token == TK_ELSEIF) { + luaK_concat(fs, &escapelist, luaK_jump(fs)); + luaK_patchlist(fs, v.u.l.f, luaK_getlabel(fs)); + test_then_block(ls, &v); /* ELSEIF cond THEN block */ + } + if (ls->t.token == TK_ELSE) { + luaK_concat(fs, &escapelist, luaK_jump(fs)); + luaK_patchlist(fs, v.u.l.f, luaK_getlabel(fs)); + next(ls); /* skip ELSE */ + block(ls); /* `else' part */ + } + else + luaK_concat(fs, &escapelist, v.u.l.f); + luaK_patchlist(fs, escapelist, luaK_getlabel(fs)); + check_match(ls, TK_END, TK_IF, line); +} + + +static void localstat (LexState *ls) { + /* stat -> LOCAL NAME {',' NAME} ['=' explist1] */ + int nvars = 0; + int nexps; + do { + next(ls); /* skip LOCAL or ',' */ + new_localvar(ls, str_checkname(ls), nvars++); + } while (ls->t.token == ','); + if (optional(ls, '=')) + nexps = explist1(ls); + else + nexps = 0; + adjust_mult_assign(ls, nvars, nexps); + adjustlocalvars(ls, nvars); +} + + +static int funcname (LexState *ls, expdesc *v) { + /* funcname -> NAME [':' NAME | '.' NAME] */ + int needself = 0; + singlevar(ls, str_checkname(ls), v); + if (ls->t.token == ':' || ls->t.token == '.') { + needself = (ls->t.token == ':'); + next(ls); + luaK_tostack(ls, v, 1); + luaK_kstr(ls, checkname(ls)); + v->k = VINDEXED; + } + return needself; +} + + +static void funcstat (LexState *ls, int line) { + /* funcstat -> FUNCTION funcname body */ + int needself; + expdesc v; + next(ls); /* skip FUNCTION */ + needself = funcname(ls, &v); + body(ls, needself, line); + luaK_storevar(ls, &v); +} + + +static void namestat (LexState *ls) { + /* stat -> func | ['%'] NAME assignment */ + FuncState *fs = ls->fs; + expdesc v; + var_or_func(ls, &v); + if (v.k == VEXP) { /* stat -> func */ + check_condition(ls, luaK_lastisopen(fs), "syntax error"); /* an upvalue? */ + luaK_setcallreturns(fs, 0); /* call statement uses no results */ + } + else { /* stat -> ['%'] NAME assignment */ + int left = assignment(ls, &v, 1); + luaK_adjuststack(fs, left); /* remove eventual garbage left on stack */ + } +} + + +static void retstat (LexState *ls) { + /* stat -> RETURN explist */ + FuncState *fs = ls->fs; + next(ls); /* skip RETURN */ + if (!block_follow(ls->t.token)) + explist1(ls); /* optional return values */ + luaK_code1(fs, OP_RETURN, ls->fs->nactloc); + fs->stacklevel = fs->nactloc; /* removes all temp values */ +} + + +static void breakstat (LexState *ls) { + /* stat -> BREAK [NAME] */ + FuncState *fs = ls->fs; + int currentlevel = fs->stacklevel; + Breaklabel *bl = fs->bl; + if (!bl) + luaK_error(ls, "no loop to break"); + next(ls); /* skip BREAK */ + luaK_adjuststack(fs, currentlevel - bl->stacklevel); + luaK_concat(fs, &bl->breaklist, luaK_jump(fs)); + /* correct stack for compiler and symbolic execution */ + luaK_adjuststack(fs, bl->stacklevel - currentlevel); +} + + +static int stat (LexState *ls) { + int line = ls->linenumber; /* may be needed for error messages */ + switch (ls->t.token) { + case TK_IF: { /* stat -> ifstat */ + ifstat(ls, line); + return 0; + } + case TK_WHILE: { /* stat -> whilestat */ + whilestat(ls, line); + return 0; + } + case TK_DO: { /* stat -> DO block END */ + next(ls); /* skip DO */ + block(ls); + check_match(ls, TK_END, TK_DO, line); + return 0; + } + case TK_FOR: { /* stat -> forstat */ + forstat(ls, line); + return 0; + } + case TK_REPEAT: { /* stat -> repeatstat */ + repeatstat(ls, line); + return 0; + } + case TK_FUNCTION: { /* stat -> funcstat */ + funcstat(ls, line); + return 0; + } + case TK_LOCAL: { /* stat -> localstat */ + localstat(ls); + return 0; + } + case TK_NAME: case '%': { /* stat -> namestat */ + namestat(ls); + return 0; + } + case TK_RETURN: { /* stat -> retstat */ + retstat(ls); + return 1; /* must be last statement */ + } + case TK_BREAK: { /* stat -> breakstat */ + breakstat(ls); + return 1; /* must be last statement */ + } + default: { + luaK_error(ls, "<statement> expected"); + return 0; /* to avoid warnings */ + } + } +} + + +static void parlist (LexState *ls) { + /* parlist -> [ param { ',' param } ] */ + int nparams = 0; + int dots = 0; + if (ls->t.token != ')') { /* is `parlist' not empty? */ + do { + switch (ls->t.token) { + case TK_DOTS: next(ls); dots = 1; break; + case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break; + default: luaK_error(ls, "<name> or `...' expected"); + } + } while (!dots && optional(ls, ',')); + } + code_params(ls, nparams, dots); +} + + +static void body (LexState *ls, int needself, int line) { + /* body -> '(' parlist ')' chunk END */ + FuncState new_fs; + open_func(ls, &new_fs); + new_fs.f->lineDefined = line; + check(ls, '('); + if (needself) { + new_localvarstr(ls, "self", 0); + adjustlocalvars(ls, 1); + } + parlist(ls); + check(ls, ')'); + chunk(ls); + check_match(ls, TK_END, TK_FUNCTION, line); + close_func(ls); + pushclosure(ls, &new_fs); +} + + +/* }====================================================================== */ + + +static void chunk (LexState *ls) { + /* chunk -> { stat [';'] } */ + int islast = 0; + while (!islast && !block_follow(ls->t.token)) { + islast = stat(ls); + optional(ls, ';'); + LUA_ASSERT(ls->fs->stacklevel == ls->fs->nactloc, + "stack size != # local vars"); + } +} + diff --git a/src/lua/lparser.h b/src/lua/lparser.h new file mode 100644 index 00000000..d83fb5f1 --- /dev/null +++ b/src/lua/lparser.h @@ -0,0 +1,60 @@ +/* +** $Id: lparser.h,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** LL(1) Parser and code generator for Lua +** See Copyright Notice in lua.h +*/ + +#ifndef lparser_h +#define lparser_h + +#include "lobject.h" +#include "lzio.h" + + +/* +** Expression descriptor +*/ + +typedef enum { + VGLOBAL, + VLOCAL, + VINDEXED, + VEXP +} expkind; + +typedef struct expdesc { + expkind k; + union { + int index; /* VGLOBAL: `kstr' index of global name; VLOCAL: stack index */ + struct { + int t; /* patch list of `exit when true' */ + int f; /* patch list of `exit when false' */ + } l; + } u; +} expdesc; + + + +/* state needed to generate code for a given function */ +typedef struct FuncState { + Proto *f; /* current function header */ + struct FuncState *prev; /* enclosing function */ + struct LexState *ls; /* lexical state */ + struct lua_State *L; /* copy of the Lua state */ + int pc; /* next position to code */ + int lasttarget; /* `pc' of last `jump target' */ + int jlt; /* list of jumps to `lasttarget' */ + short stacklevel; /* number of values on activation register */ + short nactloc; /* number of active local variables */ + short nupvalues; /* number of upvalues */ + int lastline; /* line where last `lineinfo' was generated */ + struct Breaklabel *bl; /* chain of breakable blocks */ + expdesc upvalues[MAXUPVALUES]; /* upvalues */ + int actloc[MAXLOCALS]; /* local-variable stack (indices to locvars) */ +} FuncState; + + +Proto *luaY_parser (lua_State *L, ZIO *z); + + +#endif diff --git a/src/lua/lstate.c b/src/lua/lstate.c new file mode 100644 index 00000000..6310cb7e --- /dev/null +++ b/src/lua/lstate.c @@ -0,0 +1,121 @@ +/* +** $Id: lstate.c,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Global State +** See Copyright Notice in lua.h +*/ + + +#include <stdio.h> + +#include "lua.h" + +#include "ldo.h" +#include "lgc.h" +#include "llex.h" +#include "lmem.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + +#ifdef LUA_DEBUG +static lua_State *lua_state = NULL; +void luaB_opentests (lua_State *L); +#endif + + +/* +** built-in implementation for ERRORMESSAGE. In a "correct" environment +** ERRORMESSAGE should have an external definition, and so this function +** would not be used. +*/ +static int errormessage (lua_State *L) { + const char *s = lua_tostring(L, 1); + if (s == NULL) s = "(no message)"; + fprintf(stderr, "error: %s\n", s); + return 0; +} + + +/* +** open parts that may cause memory-allocation errors +*/ +static void f_luaopen (lua_State *L, void *ud) { + int stacksize = *(int *)ud; + if (stacksize == 0) + stacksize = DEFAULT_STACK_SIZE; + else + stacksize += LUA_MINSTACK; + L->gt = luaH_new(L, 10); /* table of globals */ + luaD_init(L, stacksize); + luaS_init(L); + luaX_init(L); + luaT_init(L); + lua_newtable(L); + lua_ref(L, 1); /* create registry */ + lua_register(L, LUA_ERRORMESSAGE, errormessage); +#ifdef LUA_DEBUG + luaB_opentests(L); + if (lua_state == NULL) lua_state = L; /* keep first state to be opened */ +#endif + LUA_ASSERT(lua_gettop(L) == 0, "wrong API stack"); +} + + +LUA_API lua_State *lua_open (int stacksize) { + lua_State *L = luaM_new(NULL, lua_State); + if (L == NULL) return NULL; /* memory allocation error */ + L->stack = NULL; + L->strt.size = L->udt.size = 0; + L->strt.nuse = L->udt.nuse = 0; + L->strt.hash = NULL; + L->udt.hash = NULL; + L->Mbuffer = NULL; + L->Mbuffsize = 0; + L->rootproto = NULL; + L->rootcl = NULL; + L->roottable = NULL; + L->TMtable = NULL; + L->last_tag = -1; + L->refArray = NULL; + L->refSize = 0; + L->refFree = NONEXT; + L->nblocks = sizeof(lua_State); + L->GCthreshold = MAX_INT; /* to avoid GC during pre-definitions */ + L->callhook = NULL; + L->linehook = NULL; + L->allowhooks = 1; + L->errorJmp = NULL; + if (luaD_runprotected(L, f_luaopen, &stacksize) != 0) { + /* memory allocation error: free partial state */ + lua_close(L); + return NULL; + } + L->GCthreshold = 2*L->nblocks; + return L; +} + + +LUA_API void lua_close (lua_State *L) { + LUA_ASSERT(L != lua_state || lua_gettop(L) == 0, "garbage in C stack"); + luaC_collect(L, 1); /* collect all elements */ + LUA_ASSERT(L->rootproto == NULL, "list should be empty"); + LUA_ASSERT(L->rootcl == NULL, "list should be empty"); + LUA_ASSERT(L->roottable == NULL, "list should be empty"); + luaS_freeall(L); + if (L->stack) + L->nblocks -= (L->stack_last - L->stack + 1)*sizeof(TObject); + luaM_free(L, L->stack); + L->nblocks -= (L->last_tag+1)*sizeof(struct TM); + luaM_free(L, L->TMtable); + L->nblocks -= (L->refSize)*sizeof(struct Ref); + luaM_free(L, L->refArray); + L->nblocks -= (L->Mbuffsize)*sizeof(char); + luaM_free(L, L->Mbuffer); + LUA_ASSERT(L->nblocks == sizeof(lua_State), "wrong count for nblocks"); + luaM_free(L, L); + LUA_ASSERT(L != lua_state || memdebug_numblocks == 0, "memory leak!"); + LUA_ASSERT(L != lua_state || memdebug_total == 0,"memory leak!"); +} + diff --git a/src/lua/lstate.h b/src/lua/lstate.h new file mode 100644 index 00000000..ee02db01 --- /dev/null +++ b/src/lua/lstate.h @@ -0,0 +1,77 @@ +/* +** $Id: lstate.h,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Global State +** See Copyright Notice in lua.h +*/ + +#ifndef lstate_h +#define lstate_h + +#include "lobject.h" +#include "lua.h" +#include "luadebug.h" + + + +typedef TObject *StkId; /* index to stack elements */ + + +/* +** marks for Reference array +*/ +#define NONEXT -1 /* to end the free list */ +#define HOLD -2 +#define COLLECTED -3 +#define LOCK -4 + + +struct Ref { + TObject o; + int st; /* can be LOCK, HOLD, COLLECTED, or next (for free list) */ +}; + + +struct lua_longjmp; /* defined in ldo.c */ +struct TM; /* defined in ltm.h */ + + +typedef struct stringtable { + int size; + lint32 nuse; /* number of elements */ + TString **hash; +} stringtable; + + + +struct lua_State { + /* thread-specific state */ + StkId top; /* first free slot in the stack */ + StkId stack; /* stack base */ + StkId stack_last; /* last free slot in the stack */ + int stacksize; + StkId Cbase; /* base for current C function */ + struct lua_longjmp *errorJmp; /* current error recover point */ + char *Mbuffer; /* global buffer */ + size_t Mbuffsize; /* size of Mbuffer */ + /* global state */ + Proto *rootproto; /* list of all prototypes */ + Closure *rootcl; /* list of all closures */ + Hash *roottable; /* list of all tables */ + stringtable strt; /* hash table for strings */ + stringtable udt; /* hash table for udata */ + Hash *gt; /* table for globals */ + struct TM *TMtable; /* table for tag methods */ + int last_tag; /* last used tag in TMtable */ + struct Ref *refArray; /* locked objects */ + int refSize; /* size of refArray */ + int refFree; /* list of free positions in refArray */ + unsigned long GCthreshold; + unsigned long nblocks; /* number of `bytes' currently allocated */ + lua_Hook callhook; + lua_Hook linehook; + int allowhooks; +}; + + +#endif + diff --git a/src/lua/lstring.c b/src/lua/lstring.c new file mode 100644 index 00000000..7293e195 --- /dev/null +++ b/src/lua/lstring.c @@ -0,0 +1,155 @@ +/* +** $Id: lstring.c,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** String table (keeps all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + + +#include <string.h> + +#include "lua.h" + +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" + + +/* +** type equivalent to TString, but with maximum alignment requirements +*/ +union L_UTString { + TString ts; + union L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ +}; + + + +void luaS_init (lua_State *L) { + L->strt.hash = luaM_newvector(L, 1, TString *); + L->udt.hash = luaM_newvector(L, 1, TString *); + L->nblocks += 2*sizeof(TString *); + L->strt.size = L->udt.size = 1; + L->strt.nuse = L->udt.nuse = 0; + L->strt.hash[0] = L->udt.hash[0] = NULL; +} + + +void luaS_freeall (lua_State *L) { + LUA_ASSERT(L->strt.nuse==0, "non-empty string table"); + L->nblocks -= (L->strt.size + L->udt.size)*sizeof(TString *); + luaM_free(L, L->strt.hash); + LUA_ASSERT(L->udt.nuse==0, "non-empty udata table"); + luaM_free(L, L->udt.hash); +} + + +static unsigned long hash_s (const char *s, size_t l) { + unsigned long h = l; /* seed */ + size_t step = (l>>5)|1; /* if string is too long, don't hash all its chars */ + for (; l>=step; l-=step) + h = h ^ ((h<<5)+(h>>2)+(unsigned char)*(s++)); + return h; +} + + +void luaS_resize (lua_State *L, stringtable *tb, int newsize) { + TString **newhash = luaM_newvector(L, newsize, TString *); + int i; + for (i=0; i<newsize; i++) newhash[i] = NULL; + /* rehash */ + for (i=0; i<tb->size; i++) { + TString *p = tb->hash[i]; + while (p) { /* for each node in the list */ + TString *next = p->nexthash; /* save next */ + unsigned long h = (tb == &L->strt) ? p->u.s.hash : IntPoint(p->u.d.value); + int h1 = h&(newsize-1); /* new position */ + LUA_ASSERT(h%newsize == (h&(newsize-1)), + "a&(x-1) == a%x, for x power of 2"); + p->nexthash = newhash[h1]; /* chain it in new position */ + newhash[h1] = p; + p = next; + } + } + luaM_free(L, tb->hash); + L->nblocks += (newsize - tb->size)*sizeof(TString *); + tb->size = newsize; + tb->hash = newhash; +} + + +static void newentry (lua_State *L, stringtable *tb, TString *ts, int h) { + ts->nexthash = tb->hash[h]; /* chain new entry */ + tb->hash[h] = ts; + tb->nuse++; + if (tb->nuse > (lint32)tb->size && tb->size < MAX_INT/2) /* too crowded? */ + luaS_resize(L, tb, tb->size*2); +} + + + +TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { + unsigned long h = hash_s(str, l); + int h1 = h & (L->strt.size-1); + TString *ts; + for (ts = L->strt.hash[h1]; ts; ts = ts->nexthash) { + if (ts->len == l && (memcmp(str, ts->str, l) == 0)) + return ts; + } + /* not found */ + ts = (TString *)luaM_malloc(L, sizestring(l)); + ts->marked = 0; + ts->nexthash = NULL; + ts->len = l; + ts->u.s.hash = h; + ts->u.s.constindex = 0; + memcpy(ts->str, str, l); + ts->str[l] = 0; /* ending 0 */ + L->nblocks += sizestring(l); + newentry(L, &L->strt, ts, h1); /* insert it on table */ + return ts; +} + + +TString *luaS_newudata (lua_State *L, size_t s, void *udata) { + union L_UTString *uts = (union L_UTString *)luaM_malloc(L, + (lint32)sizeof(union L_UTString)+s); + TString *ts = &uts->ts; + ts->marked = 0; + ts->nexthash = NULL; + ts->len = s; + ts->u.d.tag = 0; + ts->u.d.value = (udata == NULL) ? uts+1 : udata; + L->nblocks += sizestring(s); + /* insert it on table */ + newentry(L, &L->udt, ts, IntPoint(ts->u.d.value) & (L->udt.size-1)); + return ts; +} + + +TString *luaS_createudata (lua_State *L, void *udata, int tag) { + int h1 = IntPoint(udata) & (L->udt.size-1); + TString *ts; + for (ts = L->udt.hash[h1]; ts; ts = ts->nexthash) { + if (udata == ts->u.d.value && (tag == ts->u.d.tag || tag == LUA_ANYTAG)) + return ts; + } + /* not found */ + ts = luaS_newudata(L, 0, udata); + if (tag != LUA_ANYTAG) + ts->u.d.tag = tag; + return ts; +} + + +TString *luaS_new (lua_State *L, const char *str) { + return luaS_newlstr(L, str, strlen(str)); +} + + +TString *luaS_newfixed (lua_State *L, const char *str) { + TString *ts = luaS_new(L, str); + if (ts->marked == 0) ts->marked = FIXMARK; /* avoid GC */ + return ts; +} + diff --git a/src/lua/lstring.h b/src/lua/lstring.h new file mode 100644 index 00000000..f23159ec --- /dev/null +++ b/src/lua/lstring.h @@ -0,0 +1,37 @@ +/* +** $Id: lstring.h,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** String table (keep all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + +#ifndef lstring_h +#define lstring_h + + +#include "lobject.h" +#include "lstate.h" + + +/* +** any TString with mark>=FIXMARK is never collected. +** Marks>=RESERVEDMARK are used to identify reserved words. +*/ +#define FIXMARK 2 +#define RESERVEDMARK 3 + + +#define sizestring(l) ((long)sizeof(TString) + \ + ((long)(l+1)-TSPACK)*(long)sizeof(char)) + + +void luaS_init (lua_State *L); +void luaS_resize (lua_State *L, stringtable *tb, int newsize); +TString *luaS_newudata (lua_State *L, size_t s, void *udata); +TString *luaS_createudata (lua_State *L, void *udata, int tag); +void luaS_freeall (lua_State *L); +TString *luaS_newlstr (lua_State *L, const char *str, size_t l); +TString *luaS_new (lua_State *L, const char *str); +TString *luaS_newfixed (lua_State *L, const char *str); + + +#endif diff --git a/src/lua/lstrlib.c b/src/lua/lstrlib.c new file mode 100644 index 00000000..051eccf7 --- /dev/null +++ b/src/lua/lstrlib.c @@ -0,0 +1,621 @@ +/* +** $Id: lstrlib.c,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Standard library for string operations and pattern-matching +** See Copyright Notice in lua.h +*/ + + +#include <ctype.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + + +static int str_len (lua_State *L) { + size_t l; + luaL_check_lstr(L, 1, &l); + lua_pushnumber(L, l); + return 1; +} + + +static long posrelat (long pos, size_t len) { + /* relative string position: negative means back from end */ + return (pos>=0) ? pos : (long)len+pos+1; +} + + +static int str_sub (lua_State *L) { + size_t l; + const char *s = luaL_check_lstr(L, 1, &l); + long start = posrelat(luaL_check_long(L, 2), l); + long end = posrelat(luaL_opt_long(L, 3, -1), l); + if (start < 1) start = 1; + if (end > (long)l) end = l; + if (start <= end) + lua_pushlstring(L, s+start-1, end-start+1); + else lua_pushstring(L, ""); + return 1; +} + + +static int str_lower (lua_State *L) { + size_t l; + size_t i; + luaL_Buffer b; + const char *s = luaL_check_lstr(L, 1, &l); + luaL_buffinit(L, &b); + for (i=0; i<l; i++) + luaL_putchar(&b, tolower((unsigned char)(s[i]))); + luaL_pushresult(&b); + return 1; +} + + +static int str_upper (lua_State *L) { + size_t l; + size_t i; + luaL_Buffer b; + const char *s = luaL_check_lstr(L, 1, &l); + luaL_buffinit(L, &b); + for (i=0; i<l; i++) + luaL_putchar(&b, toupper((unsigned char)(s[i]))); + luaL_pushresult(&b); + return 1; +} + +static int str_rep (lua_State *L) { + size_t l; + luaL_Buffer b; + const char *s = luaL_check_lstr(L, 1, &l); + int n = luaL_check_int(L, 2); + luaL_buffinit(L, &b); + while (n-- > 0) + luaL_addlstring(&b, s, l); + luaL_pushresult(&b); + return 1; +} + + +static int str_byte (lua_State *L) { + size_t l; + const char *s = luaL_check_lstr(L, 1, &l); + long pos = posrelat(luaL_opt_long(L, 2, 1), l); + luaL_arg_check(L, 0<pos && (size_t)pos<=l, 2, "out of range"); + lua_pushnumber(L, (unsigned char)s[pos-1]); + return 1; +} + + +static int str_char (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int i; + luaL_Buffer b; + luaL_buffinit(L, &b); + for (i=1; i<=n; i++) { + int c = luaL_check_int(L, i); + luaL_arg_check(L, (unsigned char)c == c, i, "invalid value"); + luaL_putchar(&b, (unsigned char)c); + } + luaL_pushresult(&b); + return 1; +} + + + +/* +** {====================================================== +** PATTERN MATCHING +** ======================================================= +*/ + +#ifndef MAX_CAPTURES +#define MAX_CAPTURES 32 /* arbitrary limit */ +#endif + + +struct Capture { + const char *src_end; /* end ('\0') of source string */ + int level; /* total number of captures (finished or unfinished) */ + struct { + const char *init; + long len; /* -1 signals unfinished capture */ + } capture[MAX_CAPTURES]; +}; + + +#define ESC '%' +#define SPECIALS "^$*+?.([%-" + + +static int check_capture (lua_State *L, int l, struct Capture *cap) { + l -= '1'; + if (!(0 <= l && l < cap->level && cap->capture[l].len != -1)) + lua_error(L, "invalid capture index"); + return l; +} + + +static int capture_to_close (lua_State *L, struct Capture *cap) { + int level = cap->level; + for (level--; level>=0; level--) + if (cap->capture[level].len == -1) return level; + lua_error(L, "invalid pattern capture"); + return 0; /* to avoid warnings */ +} + + +const char *luaI_classend (lua_State *L, const char *p) { + switch (*p++) { + case ESC: + if (*p == '\0') lua_error(L, "malformed pattern (ends with `%')"); + return p+1; + case '[': + if (*p == '^') p++; + do { /* look for a ']' */ + if (*p == '\0') lua_error(L, "malformed pattern (missing `]')"); + if (*(p++) == ESC && *p != '\0') p++; /* skip escapes (e.g. '%]') */ + } while (*p != ']'); + return p+1; + default: + return p; + } +} + + +static int match_class (int c, int cl) { + int res; + switch (tolower(cl)) { + case 'a' : res = isalpha(c); break; + case 'c' : res = iscntrl(c); break; + case 'd' : res = isdigit(c); break; + case 'l' : res = islower(c); break; + case 'p' : res = ispunct(c); break; + case 's' : res = isspace(c); break; + case 'u' : res = isupper(c); break; + case 'w' : res = isalnum(c); break; + case 'x' : res = isxdigit(c); break; + case 'z' : res = (c == '\0'); break; + default: return (cl == c); + } + return (islower(cl) ? res : !res); +} + + + +static int matchbracketclass (int c, const char *p, const char *endclass) { + int sig = 1; + if (*(p+1) == '^') { + sig = 0; + p++; /* skip the '^' */ + } + while (++p < endclass) { + if (*p == ESC) { + p++; + if (match_class(c, (unsigned char)*p)) + return sig; + } + else if ((*(p+1) == '-') && (p+2 < endclass)) { + p+=2; + if ((int)(unsigned char)*(p-2) <= c && c <= (int)(unsigned char)*p) + return sig; + } + else if ((int)(unsigned char)*p == c) return sig; + } + return !sig; +} + + + +int luaI_singlematch (int c, const char *p, const char *ep) { + switch (*p) { + case '.': /* matches any char */ + return 1; + case ESC: + return match_class(c, (unsigned char)*(p+1)); + case '[': + return matchbracketclass(c, p, ep-1); + default: + return ((unsigned char)*p == c); + } +} + + +static const char *match (lua_State *L, const char *s, const char *p, + struct Capture *cap); + + +static const char *matchbalance (lua_State *L, const char *s, const char *p, + struct Capture *cap) { + if (*p == 0 || *(p+1) == 0) + lua_error(L, "unbalanced pattern"); + if (*s != *p) return NULL; + else { + int b = *p; + int e = *(p+1); + int cont = 1; + while (++s < cap->src_end) { + if (*s == e) { + if (--cont == 0) return s+1; + } + else if (*s == b) cont++; + } + } + return NULL; /* string ends out of balance */ +} + + +static const char *max_expand (lua_State *L, const char *s, const char *p, + const char *ep, struct Capture *cap) { + long i = 0; /* counts maximum expand for item */ + while ((s+i)<cap->src_end && luaI_singlematch((unsigned char)*(s+i), p, ep)) + i++; + /* keeps trying to match with the maximum repetitions */ + while (i>=0) { + const char *res = match(L, (s+i), ep+1, cap); + if (res) return res; + i--; /* else didn't match; reduce 1 repetition to try again */ + } + return NULL; +} + + +static const char *min_expand (lua_State *L, const char *s, const char *p, + const char *ep, struct Capture *cap) { + for (;;) { + const char *res = match(L, s, ep+1, cap); + if (res != NULL) + return res; + else if (s<cap->src_end && luaI_singlematch((unsigned char)*s, p, ep)) + s++; /* try with one more repetition */ + else return NULL; + } +} + + +static const char *start_capture (lua_State *L, const char *s, const char *p, + struct Capture *cap) { + const char *res; + int level = cap->level; + if (level >= MAX_CAPTURES) lua_error(L, "too many captures"); + cap->capture[level].init = s; + cap->capture[level].len = -1; + cap->level = level+1; + if ((res=match(L, s, p+1, cap)) == NULL) /* match failed? */ + cap->level--; /* undo capture */ + return res; +} + + +static const char *end_capture (lua_State *L, const char *s, const char *p, + struct Capture *cap) { + int l = capture_to_close(L, cap); + const char *res; + cap->capture[l].len = s - cap->capture[l].init; /* close capture */ + if ((res = match(L, s, p+1, cap)) == NULL) /* match failed? */ + cap->capture[l].len = -1; /* undo capture */ + return res; +} + + +static const char *match_capture (lua_State *L, const char *s, int level, + struct Capture *cap) { + int l = check_capture(L, level, cap); + size_t len = cap->capture[l].len; + if ((size_t)(cap->src_end-s) >= len && + memcmp(cap->capture[l].init, s, len) == 0) + return s+len; + else return NULL; +} + + +static const char *match (lua_State *L, const char *s, const char *p, + struct Capture *cap) { + init: /* using goto's to optimize tail recursion */ + switch (*p) { + case '(': /* start capture */ + return start_capture(L, s, p, cap); + case ')': /* end capture */ + return end_capture(L, s, p, cap); + case ESC: /* may be %[0-9] or %b */ + if (isdigit((unsigned char)(*(p+1)))) { /* capture? */ + s = match_capture(L, s, *(p+1), cap); + if (s == NULL) return NULL; + p+=2; goto init; /* else return match(L, s, p+2, cap) */ + } + else if (*(p+1) == 'b') { /* balanced string? */ + s = matchbalance(L, s, p+2, cap); + if (s == NULL) return NULL; + p+=4; goto init; /* else return match(L, s, p+4, cap); */ + } + else goto dflt; /* case default */ + case '\0': /* end of pattern */ + return s; /* match succeeded */ + case '$': + if (*(p+1) == '\0') /* is the '$' the last char in pattern? */ + return (s == cap->src_end) ? s : NULL; /* check end of string */ + else goto dflt; + default: dflt: { /* it is a pattern item */ + const char *ep = luaI_classend(L, p); /* points to what is next */ + int m = s<cap->src_end && luaI_singlematch((unsigned char)*s, p, ep); + switch (*ep) { + case '?': { /* optional */ + const char *res; + if (m && ((res=match(L, s+1, ep+1, cap)) != NULL)) + return res; + p=ep+1; goto init; /* else return match(L, s, ep+1, cap); */ + } + case '*': /* 0 or more repetitions */ + return max_expand(L, s, p, ep, cap); + case '+': /* 1 or more repetitions */ + return (m ? max_expand(L, s+1, p, ep, cap) : NULL); + case '-': /* 0 or more repetitions (minimum) */ + return min_expand(L, s, p, ep, cap); + default: + if (!m) return NULL; + s++; p=ep; goto init; /* else return match(L, s+1, ep, cap); */ + } + } + } +} + + + +static const char *lmemfind (const char *s1, size_t l1, + const char *s2, size_t l2) { + if (l2 == 0) return s1; /* empty strings are everywhere */ + else if (l2 > l1) return NULL; /* avoids a negative `l1' */ + else { + const char *init; /* to search for a `*s2' inside `s1' */ + l2--; /* 1st char will be checked by `memchr' */ + l1 = l1-l2; /* `s2' cannot be found after that */ + while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) { + init++; /* 1st char is already checked */ + if (memcmp(init, s2+1, l2) == 0) + return init-1; + else { /* correct `l1' and `s1' to try again */ + l1 -= init-s1; + s1 = init; + } + } + return NULL; /* not found */ + } +} + + +static int push_captures (lua_State *L, struct Capture *cap) { + int i; + luaL_checkstack(L, cap->level, "too many captures"); + for (i=0; i<cap->level; i++) { + int l = cap->capture[i].len; + if (l == -1) lua_error(L, "unfinished capture"); + lua_pushlstring(L, cap->capture[i].init, l); + } + return cap->level; /* number of strings pushed */ +} + + +static int str_find (lua_State *L) { + size_t l1, l2; + const char *s = luaL_check_lstr(L, 1, &l1); + const char *p = luaL_check_lstr(L, 2, &l2); + long init = posrelat(luaL_opt_long(L, 3, 1), l1) - 1; + struct Capture cap; + luaL_arg_check(L, 0 <= init && (size_t)init <= l1, 3, "out of range"); + if (lua_gettop(L) > 3 || /* extra argument? */ + strpbrk(p, SPECIALS) == NULL) { /* or no special characters? */ + const char *s2 = lmemfind(s+init, l1-init, p, l2); + if (s2) { + lua_pushnumber(L, s2-s+1); + lua_pushnumber(L, s2-s+l2); + return 2; + } + } + else { + int anchor = (*p == '^') ? (p++, 1) : 0; + const char *s1=s+init; + cap.src_end = s+l1; + do { + const char *res; + cap.level = 0; + if ((res=match(L, s1, p, &cap)) != NULL) { + lua_pushnumber(L, s1-s+1); /* start */ + lua_pushnumber(L, res-s); /* end */ + return push_captures(L, &cap) + 2; + } + } while (s1++<cap.src_end && !anchor); + } + lua_pushnil(L); /* not found */ + return 1; +} + + +static void add_s (lua_State *L, luaL_Buffer *b, struct Capture *cap) { + if (lua_isstring(L, 3)) { + const char *news = lua_tostring(L, 3); + size_t l = lua_strlen(L, 3); + size_t i; + for (i=0; i<l; i++) { + if (news[i] != ESC) + luaL_putchar(b, news[i]); + else { + i++; /* skip ESC */ + if (!isdigit((unsigned char)news[i])) + luaL_putchar(b, news[i]); + else { + int level = check_capture(L, news[i], cap); + luaL_addlstring(b, cap->capture[level].init, cap->capture[level].len); + } + } + } + } + else { /* is a function */ + int n; + lua_pushvalue(L, 3); + n = push_captures(L, cap); + lua_rawcall(L, n, 1); + if (lua_isstring(L, -1)) + luaL_addvalue(b); /* add return to accumulated result */ + else + lua_pop(L, 1); /* function result is not a string: pop it */ + } +} + + +static int str_gsub (lua_State *L) { + size_t srcl; + const char *src = luaL_check_lstr(L, 1, &srcl); + const char *p = luaL_check_string(L, 2); + int max_s = luaL_opt_int(L, 4, srcl+1); + int anchor = (*p == '^') ? (p++, 1) : 0; + int n = 0; + struct Capture cap; + luaL_Buffer b; + luaL_arg_check(L, + lua_gettop(L) >= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)), + 3, "string or function expected"); + luaL_buffinit(L, &b); + cap.src_end = src+srcl; + while (n < max_s) { + const char *e; + cap.level = 0; + e = match(L, src, p, &cap); + if (e) { + n++; + add_s(L, &b, &cap); + } + if (e && e>src) /* non empty match? */ + src = e; /* skip it */ + else if (src < cap.src_end) + luaL_putchar(&b, *src++); + else break; + if (anchor) break; + } + luaL_addlstring(&b, src, cap.src_end-src); + luaL_pushresult(&b); + lua_pushnumber(L, n); /* number of substitutions */ + return 2; +} + +/* }====================================================== */ + + +static void luaI_addquoted (lua_State *L, luaL_Buffer *b, int arg) { + size_t l; + const char *s = luaL_check_lstr(L, arg, &l); + luaL_putchar(b, '"'); + while (l--) { + switch (*s) { + case '"': case '\\': case '\n': + luaL_putchar(b, '\\'); + luaL_putchar(b, *s); + break; + case '\0': luaL_addlstring(b, "\\000", 4); break; + default: luaL_putchar(b, *s); + } + s++; + } + luaL_putchar(b, '"'); +} + +/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */ +#define MAX_ITEM 512 +/* maximum size of each format specification (such as '%-099.99d') */ +#define MAX_FORMAT 20 + +static int str_format (lua_State *L) { + int arg = 1; + const char *strfrmt = luaL_check_string(L, arg); + luaL_Buffer b; + luaL_buffinit(L, &b); + while (*strfrmt) { + if (*strfrmt != '%') + luaL_putchar(&b, *strfrmt++); + else if (*++strfrmt == '%') + luaL_putchar(&b, *strfrmt++); /* %% */ + else { /* format item */ + struct Capture cap; + char form[MAX_FORMAT]; /* to store the format ('%...') */ + char buff[MAX_ITEM]; /* to store the formatted item */ + const char *initf = strfrmt; + form[0] = '%'; + if (isdigit((unsigned char)*initf) && *(initf+1) == '$') { + arg = *initf - '0'; + initf += 2; /* skip the 'n$' */ + } + arg++; + cap.src_end = strfrmt+strlen(strfrmt)+1; + cap.level = 0; + strfrmt = match(L, initf, "[-+ #0]*(%d*)%.?(%d*)", &cap); + if (cap.capture[0].len > 2 || cap.capture[1].len > 2 || /* < 100? */ + strfrmt-initf > MAX_FORMAT-2) + lua_error(L, "invalid format (width or precision too long)"); + strncpy(form+1, initf, strfrmt-initf+1); /* +1 to include conversion */ + form[strfrmt-initf+2] = 0; + switch (*strfrmt++) { + case 'c': case 'd': case 'i': + sprintf(buff, form, luaL_check_int(L, arg)); + break; + case 'o': case 'u': case 'x': case 'X': + sprintf(buff, form, (unsigned int)luaL_check_number(L, arg)); + break; + case 'e': case 'E': case 'f': case 'g': case 'G': + sprintf(buff, form, luaL_check_number(L, arg)); + break; + case 'q': + luaI_addquoted(L, &b, arg); + continue; /* skip the "addsize" at the end */ + case 's': { + size_t l; + const char *s = luaL_check_lstr(L, arg, &l); + if (cap.capture[1].len == 0 && l >= 100) { + /* no precision and string is too long to be formatted; + keep original string */ + lua_pushvalue(L, arg); + luaL_addvalue(&b); + continue; /* skip the "addsize" at the end */ + } + else { + sprintf(buff, form, s); + break; + } + } + default: /* also treat cases 'pnLlh' */ + lua_error(L, "invalid option in `format'"); + } + luaL_addlstring(&b, buff, strlen(buff)); + } + } + luaL_pushresult(&b); + return 1; +} + + +static const struct luaL_reg strlib[] = { +{"strlen", str_len}, +{"strsub", str_sub}, +{"strlower", str_lower}, +{"strupper", str_upper}, +{"strchar", str_char}, +{"strrep", str_rep}, +{"ascii", str_byte}, /* for compatibility with 3.0 and earlier */ +{"strbyte", str_byte}, +{"format", str_format}, +{"strfind", str_find}, +{"gsub", str_gsub} +}; + + +/* +** Open string library +*/ +LUALIB_API void lua_strlibopen (lua_State *L) { + luaL_openl(L, strlib); +} diff --git a/src/lua/ltable.c b/src/lua/ltable.c new file mode 100644 index 00000000..1e3eb4f5 --- /dev/null +++ b/src/lua/ltable.c @@ -0,0 +1,303 @@ +/* +** $Id: ltable.c,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Lua tables (hash) +** See Copyright Notice in lua.h +*/ + + +/* +** Implementation of tables (aka arrays, objects, or hash tables); +** uses a mix of chained scatter table with Brent's variation. +** A main invariant of these tables is that, if an element is not +** in its main position (i.e. the `original' position that its hash gives +** to it), then the colliding element is in its own main position. +** In other words, there are collisions only when two elements have the +** same main position (i.e. the same hash values for that table size). +** Because of that, the load factor of these tables can be 100% without +** performance penalties. +*/ + + +#include "lua.h" + +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" + + +#define gcsize(L, n) (sizeof(Hash)+(n)*sizeof(Node)) + + + +#define TagDefault LUA_TTABLE + + + +/* +** returns the `main' position of an element in a table (that is, the index +** of its hash value) +*/ +Node *luaH_mainposition (const Hash *t, const TObject *key) { + unsigned long h; + switch (ttype(key)) { + case LUA_TNUMBER: + h = (unsigned long)(long)nvalue(key); + break; + case LUA_TSTRING: + h = tsvalue(key)->u.s.hash; + break; + case LUA_TUSERDATA: + h = IntPoint(tsvalue(key)); + break; + case LUA_TTABLE: + h = IntPoint(hvalue(key)); + break; + case LUA_TFUNCTION: + h = IntPoint(clvalue(key)); + break; + default: + return NULL; /* invalid key */ + } + LUA_ASSERT(h%(unsigned int)t->size == (h&((unsigned int)t->size-1)), + "a&(x-1) == a%x, for x power of 2"); + return &t->node[h&(t->size-1)]; +} + + +static const TObject *luaH_getany (lua_State *L, const Hash *t, + const TObject *key) { + Node *n = luaH_mainposition(t, key); + if (!n) + lua_error(L, "table index is nil"); + else do { + if (luaO_equalObj(key, &n->key)) + return &n->val; + n = n->next; + } while (n); + return &luaO_nilobject; /* key not found */ +} + + +/* specialized version for numbers */ +const TObject *luaH_getnum (const Hash *t, Number key) { + Node *n = &t->node[(unsigned long)(long)key&(t->size-1)]; + do { + if (ttype(&n->key) == LUA_TNUMBER && nvalue(&n->key) == key) + return &n->val; + n = n->next; + } while (n); + return &luaO_nilobject; /* key not found */ +} + + +/* specialized version for strings */ +const TObject *luaH_getstr (const Hash *t, TString *key) { + Node *n = &t->node[key->u.s.hash&(t->size-1)]; + do { + if (ttype(&n->key) == LUA_TSTRING && tsvalue(&n->key) == key) + return &n->val; + n = n->next; + } while (n); + return &luaO_nilobject; /* key not found */ +} + + +const TObject *luaH_get (lua_State *L, const Hash *t, const TObject *key) { + switch (ttype(key)) { + case LUA_TNUMBER: return luaH_getnum(t, nvalue(key)); + case LUA_TSTRING: return luaH_getstr(t, tsvalue(key)); + default: return luaH_getany(L, t, key); + } +} + + +Node *luaH_next (lua_State *L, const Hash *t, const TObject *key) { + int i; + if (ttype(key) == LUA_TNIL) + i = 0; /* first iteration */ + else { + const TObject *v = luaH_get(L, t, key); + if (v == &luaO_nilobject) + lua_error(L, "invalid key for `next'"); + i = (int)(((const char *)v - + (const char *)(&t->node[0].val)) / sizeof(Node)) + 1; + } + for (; i<t->size; i++) { + Node *n = node(t, i); + if (ttype(val(n)) != LUA_TNIL) + return n; + } + return NULL; /* no more elements */ +} + + +/* +** try to remove a key without value from a table. To avoid problems with +** hash, change `key' for a number with the same hash. +*/ +void luaH_remove (Hash *t, TObject *key) { + if (ttype(key) == LUA_TNUMBER || + (ttype(key) == LUA_TSTRING && tsvalue(key)->len <= 30)) + return; /* do not remove numbers nor small strings */ + else { + /* try to find a number `n' with the same hash as `key' */ + Node *mp = luaH_mainposition(t, key); + int n = mp - &t->node[0]; + /* make sure `n' is not in `t' */ + while (luaH_getnum(t, n) != &luaO_nilobject) { + if (n >= MAX_INT - t->size) + return; /* give up; (to avoid overflow) */ + n += t->size; + } + ttype(key) = LUA_TNUMBER; + nvalue(key) = n; + LUA_ASSERT(luaH_mainposition(t, key) == mp, "cannot change hash"); + } +} + + +static void setnodevector (lua_State *L, Hash *t, lint32 size) { + int i; + if (size > MAX_INT) + lua_error(L, "table overflow"); + t->node = luaM_newvector(L, size, Node); + for (i=0; i<(int)size; i++) { + ttype(&t->node[i].key) = ttype(&t->node[i].val) = LUA_TNIL; + t->node[i].next = NULL; + } + L->nblocks += gcsize(L, size) - gcsize(L, t->size); + t->size = size; + t->firstfree = &t->node[size-1]; /* first free position to be used */ +} + + +Hash *luaH_new (lua_State *L, int size) { + Hash *t = luaM_new(L, Hash); + t->htag = TagDefault; + t->next = L->roottable; + L->roottable = t; + t->mark = t; + t->size = 0; + L->nblocks += gcsize(L, 0); + t->node = NULL; + setnodevector(L, t, luaO_power2(size)); + return t; +} + + +void luaH_free (lua_State *L, Hash *t) { + L->nblocks -= gcsize(L, t->size); + luaM_free(L, t->node); + luaM_free(L, t); +} + + +static int numuse (const Hash *t) { + Node *v = t->node; + int size = t->size; + int realuse = 0; + int i; + for (i=0; i<size; i++) { + if (ttype(&v[i].val) != LUA_TNIL) + realuse++; + } + return realuse; +} + + +static void rehash (lua_State *L, Hash *t) { + int oldsize = t->size; + Node *nold = t->node; + int nelems = numuse(t); + int i; + LUA_ASSERT(nelems<=oldsize, "wrong count"); + if (nelems >= oldsize-oldsize/4) /* using more than 3/4? */ + setnodevector(L, t, (lint32)oldsize*2); + else if (nelems <= oldsize/4 && /* less than 1/4? */ + oldsize > MINPOWER2) + setnodevector(L, t, oldsize/2); + else + setnodevector(L, t, oldsize); + for (i=0; i<oldsize; i++) { + Node *old = nold+i; + if (ttype(&old->val) != LUA_TNIL) + *luaH_set(L, t, &old->key) = old->val; + } + luaM_free(L, nold); /* free old array */ +} + + +/* +** inserts a key into a hash table; first, check whether key is +** already present; if not, check whether key's main position is free; +** if not, check whether colliding node is in its main position or not; +** if it is not, move colliding node to an empty place and put new key +** in its main position; otherwise (colliding node is in its main position), +** new key goes to an empty position. +*/ +TObject *luaH_set (lua_State *L, Hash *t, const TObject *key) { + Node *mp = luaH_mainposition(t, key); + Node *n = mp; + if (!mp) + lua_error(L, "table index is nil"); + do { /* check whether `key' is somewhere in the chain */ + if (luaO_equalObj(key, &n->key)) + return &n->val; /* that's all */ + else n = n->next; + } while (n); + /* `key' not found; must insert it */ + if (ttype(&mp->key) != LUA_TNIL) { /* main position is not free? */ + Node *othern; /* main position of colliding node */ + n = t->firstfree; /* get a free place */ + /* is colliding node out of its main position? (can only happens if + its position is after "firstfree") */ + if (mp > n && (othern=luaH_mainposition(t, &mp->key)) != mp) { + /* yes; move colliding node into free position */ + while (othern->next != mp) othern = othern->next; /* find previous */ + othern->next = n; /* redo the chain with `n' in place of `mp' */ + *n = *mp; /* copy colliding node into free pos. (mp->next also goes) */ + mp->next = NULL; /* now `mp' is free */ + } + else { /* colliding node is in its own main position */ + /* new node will go into free position */ + n->next = mp->next; /* chain new position */ + mp->next = n; + mp = n; + } + } + mp->key = *key; + for (;;) { /* correct `firstfree' */ + if (ttype(&t->firstfree->key) == LUA_TNIL) + return &mp->val; /* OK; table still has a free place */ + else if (t->firstfree == t->node) break; /* cannot decrement from here */ + else (t->firstfree)--; + } + rehash(L, t); /* no more free places */ + return luaH_set(L, t, key); /* `rehash' invalidates this insertion */ +} + + +TObject *luaH_setint (lua_State *L, Hash *t, int key) { + TObject index; + ttype(&index) = LUA_TNUMBER; + nvalue(&index) = key; + return luaH_set(L, t, &index); +} + + +void luaH_setstrnum (lua_State *L, Hash *t, TString *key, Number val) { + TObject *value, index; + ttype(&index) = LUA_TSTRING; + tsvalue(&index) = key; + value = luaH_set(L, t, &index); + ttype(value) = LUA_TNUMBER; + nvalue(value) = val; +} + + +const TObject *luaH_getglobal (lua_State *L, const char *name) { + return luaH_getstr(L->gt, luaS_new(L, name)); +} + diff --git a/src/lua/ltable.h b/src/lua/ltable.h new file mode 100644 index 00000000..3bc2a5df --- /dev/null +++ b/src/lua/ltable.h @@ -0,0 +1,34 @@ +/* +** $Id: ltable.h,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Lua tables (hash) +** See Copyright Notice in lua.h +*/ + +#ifndef ltable_h +#define ltable_h + +#include "lobject.h" + + +#define node(t,i) (&(t)->node[i]) +#define key(n) (&(n)->key) +#define val(n) (&(n)->val) + +Hash *luaH_new (lua_State *L, int nhash); +void luaH_free (lua_State *L, Hash *t); +const TObject *luaH_get (lua_State *L, const Hash *t, const TObject *key); +const TObject *luaH_getnum (const Hash *t, Number key); +const TObject *luaH_getstr (const Hash *t, TString *key); +void luaH_remove (Hash *t, TObject *key); +TObject *luaH_set (lua_State *L, Hash *t, const TObject *key); +Node * luaH_next (lua_State *L, const Hash *t, const TObject *r); +TObject *luaH_setint (lua_State *L, Hash *t, int key); +void luaH_setstrnum (lua_State *L, Hash *t, TString *key, Number val); +unsigned long luaH_hash (lua_State *L, const TObject *key); +const TObject *luaH_getglobal (lua_State *L, const char *name); + +/* exported only for debugging */ +Node *luaH_mainposition (const Hash *t, const TObject *key); + + +#endif diff --git a/src/lua/ltests.c b/src/lua/ltests.c new file mode 100644 index 00000000..06e08f5a --- /dev/null +++ b/src/lua/ltests.c @@ -0,0 +1,543 @@ +/* +** $Id: ltests.c,v 1.2 2001/11/26 23:00:26 darkgod Exp $ +** Internal Module for Debugging of the Lua Implementation +** See Copyright Notice in lua.h +*/ + + +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +#include "lua.h" + +#include "lapi.h" +#include "lauxlib.h" +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lmem.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "luadebug.h" +#include "lualib.h" + + +void luaB_opentests (lua_State *L); + + +/* +** The whole module only makes sense with LUA_DEBUG on +*/ +#ifdef LUA_DEBUG + + + +static void setnameval (lua_State *L, const char *name, int val) { + lua_pushstring(L, name); + lua_pushnumber(L, val); + lua_settable(L, -3); +} + + +/* +** {====================================================== +** Disassembler +** ======================================================= +*/ + + +static const char *const instrname[NUM_OPCODES] = { + "END", "RETURN", "CALL", "TAILCALL", "PUSHNIL", "POP", "PUSHINT", + "PUSHSTRING", "PUSHNUM", "PUSHNEGNUM", "PUSHUPVALUE", "GETLOCAL", + "GETGLOBAL", "GETTABLE", "GETDOTTED", "GETINDEXED", "PUSHSELF", + "CREATETABLE", "SETLOCAL", "SETGLOBAL", "SETTABLE", "SETLIST", "SETMAP", + "ADD", "ADDI", "SUB", "MULT", "DIV", "POW", "CONCAT", "MINUS", "NOT", + "JMPNE", "JMPEQ", "JMPLT", "JMPLE", "JMPGT", "JMPGE", "JMPT", "JMPF", + "JMPONT", "JMPONF", "JMP", "PUSHNILJMP", "FORPREP", "FORLOOP", "LFORPREP", + "LFORLOOP", "CLOSURE" +}; + + +static int pushop (lua_State *L, Proto *p, int pc) { + char buff[100]; + Instruction i = p->code[pc]; + OpCode o = GET_OPCODE(i); + const char *name = instrname[o]; + sprintf(buff, "%5d - ", luaG_getline(p->lineinfo, pc, 1, NULL)); + switch ((enum Mode)luaK_opproperties[o].mode) { + case iO: + sprintf(buff+8, "%-12s", name); + break; + case iU: + sprintf(buff+8, "%-12s%4u", name, GETARG_U(i)); + break; + case iS: + sprintf(buff+8, "%-12s%4d", name, GETARG_S(i)); + break; + case iAB: + sprintf(buff+8, "%-12s%4d %4d", name, GETARG_A(i), GETARG_B(i)); + break; + } + lua_pushstring(L, buff); + return (o != OP_END); +} + + +static int listcode (lua_State *L) { + int pc; + Proto *p; + int res; + luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), + 1, "Lua function expected"); + p = clvalue(luaA_index(L, 1))->f.l; + lua_newtable(L); + setnameval(L, "maxstack", p->maxstacksize); + setnameval(L, "numparams", p->numparams); + pc = 0; + do { + lua_pushnumber(L, pc+1); + res = pushop(L, p, pc++); + lua_settable(L, -3); + } while (res); + return 1; +} + + +static int liststrings (lua_State *L) { + Proto *p; + int i; + luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), + 1, "Lua function expected"); + p = clvalue(luaA_index(L, 1))->f.l; + lua_newtable(L); + for (i=0; i<p->nkstr; i++) { + lua_pushnumber(L, i+1); + lua_pushstring(L, p->kstr[i]->str); + lua_settable(L, -3); + } + return 1; +} + + +static int listlocals (lua_State *L) { + Proto *p; + int pc = luaL_check_int(L, 2) - 1; + int i = 0; + const char *name; + luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), + 1, "Lua function expected"); + p = clvalue(luaA_index(L, 1))->f.l; + while ((name = luaF_getlocalname(p, ++i, pc)) != NULL) + lua_pushstring(L, name); + return i-1; +} + +/* }====================================================== */ + + + +static int get_limits (lua_State *L) { + lua_newtable(L); + setnameval(L, "BITS_INT", BITS_INT); + setnameval(L, "LFPF", LFIELDS_PER_FLUSH); + setnameval(L, "MAXARG_A", MAXARG_A); + setnameval(L, "MAXARG_B", MAXARG_B); + setnameval(L, "MAXARG_S", MAXARG_S); + setnameval(L, "MAXARG_U", MAXARG_U); + setnameval(L, "MAXLOCALS", MAXLOCALS); + setnameval(L, "MAXPARAMS", MAXPARAMS); + setnameval(L, "MAXSTACK", MAXSTACK); + setnameval(L, "MAXUPVALUES", MAXUPVALUES); + setnameval(L, "MAXVARSLH", MAXVARSLH); + setnameval(L, "RFPF", RFIELDS_PER_FLUSH); + setnameval(L, "SIZE_A", SIZE_A); + setnameval(L, "SIZE_B", SIZE_B); + setnameval(L, "SIZE_OP", SIZE_OP); + setnameval(L, "SIZE_U", SIZE_U); + return 1; +} + + +static int mem_query (lua_State *L) { + if (lua_isnull(L, 1)) { + lua_pushnumber(L, memdebug_total); + lua_pushnumber(L, memdebug_numblocks); + lua_pushnumber(L, memdebug_maxmem); + return 3; + } + else { + memdebug_memlimit = luaL_check_int(L, 1); + return 0; + } +} + + +static int hash_query (lua_State *L) { + if (lua_isnull(L, 2)) { + luaL_arg_check(L, lua_tag(L, 1) == LUA_TSTRING, 1, "string expected"); + lua_pushnumber(L, tsvalue(luaA_index(L, 1))->u.s.hash); + } + else { + Hash *t; + luaL_checktype(L, 2, LUA_TTABLE); + t = hvalue(luaA_index(L, 2)); + lua_pushnumber(L, luaH_mainposition(t, luaA_index(L, 1)) - t->node); + } + return 1; +} + + +static int table_query (lua_State *L) { + const Hash *t; + int i = luaL_opt_int(L, 2, -1); + luaL_checktype(L, 1, LUA_TTABLE); + t = hvalue(luaA_index(L, 1)); + if (i == -1) { + lua_pushnumber(L, t->size); + lua_pushnumber(L, t->firstfree - t->node); + return 2; + } + else if (i < t->size) { + luaA_pushobject(L, &t->node[i].key); + luaA_pushobject(L, &t->node[i].val); + if (t->node[i].next) { + lua_pushnumber(L, t->node[i].next - t->node); + return 3; + } + else + return 2; + } + return 0; +} + + +static int string_query (lua_State *L) { + stringtable *tb = (*luaL_check_string(L, 1) == 's') ? &L->strt : &L->udt; + int s = luaL_opt_int(L, 2, 0) - 1; + if (s==-1) { + lua_pushnumber(L ,tb->nuse); + lua_pushnumber(L ,tb->size); + return 2; + } + else if (s < tb->size) { + TString *ts; + int n = 0; + for (ts = tb->hash[s]; ts; ts = ts->nexthash) { + ttype(L->top) = LUA_TSTRING; + tsvalue(L->top) = ts; + incr_top; + n++; + } + return n; + } + return 0; +} + + +static int tref (lua_State *L) { + luaL_checkany(L, 1); + lua_pushvalue(L, 1); + lua_pushnumber(L, lua_ref(L, luaL_opt_int(L, 2, 1))); + return 1; +} + +static int getref (lua_State *L) { + if (lua_getref(L, luaL_check_int(L, 1))) + return 1; + else + return 0; +} + +static int unref (lua_State *L) { + lua_unref(L, luaL_check_int(L, 1)); + return 0; +} + +static int newuserdata (lua_State *L) { + if (lua_isnumber(L, 2)) + lua_pushusertag(L, (void *)luaL_check_int(L, 1), luaL_check_int(L, 2)); + else + lua_newuserdata(L, luaL_check_int(L, 1)); + return 1; +} + +static int udataval (lua_State *L) { + luaL_checktype(L, 1, LUA_TUSERDATA); + lua_pushnumber(L, (int)lua_touserdata(L, 1)); + return 1; +} + +static int newstate (lua_State *L) { + lua_State *L1 = lua_open(luaL_check_int(L, 1)); + if (L1) + lua_pushuserdata(L, L1); + else + lua_pushnil(L); + return 1; +} + +static int loadlib (lua_State *L) { + lua_State *L1 = (lua_State *)lua_touserdata(L, 1); + switch (*luaL_check_string(L, 2)) { + case 'm': lua_mathlibopen(L1); break; + case 's': lua_strlibopen(L1); break; + case 'i': lua_iolibopen(L1); break; + case 'd': lua_dblibopen(L1); break; + case 'b': lua_baselibopen(L1); break; + default: luaL_argerror(L, 2, "invalid option"); + } + return 0; +} + +static int closestate (lua_State *L) { + luaL_checktype(L, 1, LUA_TUSERDATA); + lua_close((lua_State *)lua_touserdata(L, 1)); + return 0; +} + +static int doremote (lua_State *L) { + lua_State *L1; + const char *code = luaL_check_string(L, 2); + int status; + luaL_checktype(L, 1, LUA_TUSERDATA); + L1 = (lua_State *)lua_touserdata(L, 1); + status = lua_dostring(L1, code); + if (status != 0) { + lua_pushnil(L); + lua_pushnumber(L, status); + return 2; + } + else { + int i = 0; + while (!lua_isnull(L1, ++i)) + lua_pushstring(L, lua_tostring(L1, i)); + return i-1; + } +} + +static int settagmethod (lua_State *L) { + int tag = luaL_check_int(L, 1); + const char *event = luaL_check_string(L, 2); + luaL_checkany(L, 3); + lua_gettagmethod(L, tag, event); + lua_pushvalue(L, 3); + lua_settagmethod(L, tag, event); + return 1; +} + +static int pushbool (lua_State *L, int b) { + if (b) lua_pushnumber(L, 1); + else lua_pushnil(L); + return 1; +} + +static int equal (lua_State *L) { + return pushbool(L, lua_equal(L, 1, 2)); +} + + + +/* +** {====================================================== +** function to test the API with C. It interprets a kind of "assembler" +** language with calls to the API, so the test can be driven by Lua code +** ======================================================= +*/ + +static const char *const delimits = " \t\n,;"; + +static void skip (const char **pc) { + while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++; +} + +static int getnum (lua_State *L, const char **pc) { + int res = 0; + int sig = 1; + skip(pc); + if (**pc == '.') { + res = (int)lua_tonumber(L, -1); + lua_pop(L, 1); + (*pc)++; + return res; + } + else if (**pc == '-') { + sig = -1; + (*pc)++; + } + while (isdigit(**pc)) res = res*10 + (*(*pc)++) - '0'; + return sig*res; +} + +static const char *getname (char *buff, const char **pc) { + int i = 0; + skip(pc); + while (**pc != '\0' && !strchr(delimits, **pc)) + buff[i++] = *(*pc)++; + buff[i] = '\0'; + return buff; +} + + +#define EQ(s1) (strcmp(s1, inst) == 0) + +#define getnum ((getnum)(L, &pc)) +#define getname ((getname)(buff, &pc)) + + +static int testC (lua_State *L) { + char buff[30]; + const char *pc = luaL_check_string(L, 1); + for (;;) { + const char *inst = getname; + if EQ("") return 0; + else if EQ("isnumber") { + lua_pushnumber(L, lua_isnumber(L, getnum)); + } + else if EQ("isstring") { + lua_pushnumber(L, lua_isstring(L, getnum)); + } + else if EQ("istable") { + lua_pushnumber(L, lua_istable(L, getnum)); + } + else if EQ("iscfunction") { + lua_pushnumber(L, lua_iscfunction(L, getnum)); + } + else if EQ("isfunction") { + lua_pushnumber(L, lua_isfunction(L, getnum)); + } + else if EQ("isuserdata") { + lua_pushnumber(L, lua_isuserdata(L, getnum)); + } + else if EQ("isnil") { + lua_pushnumber(L, lua_isnil(L, getnum)); + } + else if EQ("isnull") { + lua_pushnumber(L, lua_isnull(L, getnum)); + } + else if EQ("tonumber") { + lua_pushnumber(L, lua_tonumber(L, getnum)); + } + else if EQ("tostring") { + lua_pushstring(L, lua_tostring(L, getnum)); + } + else if EQ("tonumber") { + lua_pushnumber(L, lua_tonumber(L, getnum)); + } + else if EQ("strlen") { + lua_pushnumber(L, lua_strlen(L, getnum)); + } + else if EQ("tocfunction") { + lua_pushcfunction(L, lua_tocfunction(L, getnum)); + } + else if EQ("return") { + return getnum; + } + else if EQ("gettop") { + lua_pushnumber(L, lua_gettop(L)); + } + else if EQ("settop") { + lua_settop(L, getnum); + } + else if EQ("pop") { + lua_pop(L, getnum); + } + else if EQ("pushnum") { + lua_pushnumber(L, getnum); + } + else if EQ("pushvalue") { + lua_pushvalue(L, getnum); + } + else if EQ("remove") { + lua_remove(L, getnum); + } + else if EQ("insert") { + lua_insert(L, getnum); + } + else if EQ("gettable") { + lua_gettable(L, getnum); + } + else if EQ("settable") { + lua_settable(L, getnum); + } + else if EQ("next") { + lua_next(L, -2); + } + else if EQ("concat") { + lua_concat(L, getnum); + } + else if EQ("rawcall") { + int narg = getnum; + int nres = getnum; + lua_rawcall(L, narg, nres); + } + else if EQ("call") { + int narg = getnum; + int nres = getnum; + lua_call(L, narg, nres); + } + else if EQ("dostring") { + lua_dostring(L, luaL_check_string(L, getnum)); + } + else if EQ("settagmethod") { + int tag = getnum; + const char *event = getname; + lua_settagmethod(L, tag, event); + } + else if EQ("gettagmethod") { + int tag = getnum; + const char *event = getname; + lua_gettagmethod(L, tag, event); + } + else if EQ("type") { + lua_pushstring(L, lua_typename(L, lua_type(L, getnum))); + } + else luaL_verror(L, "unknown instruction %.30s", buff); + } + return 0; +} + +/* }====================================================== */ + + + +static const struct luaL_reg tests_funcs[] = { + {"hash", hash_query}, + {"limits", get_limits}, + {"listcode", listcode}, + {"liststrings", liststrings}, + {"listlocals", listlocals}, + {"loadlib", loadlib}, + {"querystr", string_query}, + {"querytab", table_query}, + {"testC", testC}, + {"ref", tref}, + {"getref", getref}, + {"unref", unref}, + {"newuserdata", newuserdata}, + {"udataval", udataval}, + {"newstate", newstate}, + {"closestate", closestate}, + {"doremote", doremote}, + {"settagmethod", settagmethod}, + {"equal", equal}, + {"totalmem", mem_query} +}; + + +void luaB_opentests (lua_State *L) { + lua_newtable(L); + lua_getglobals(L); + lua_pushvalue(L, -2); + lua_setglobals(L); + luaL_openl(L, tests_funcs); /* open functions inside new table */ + lua_setglobals(L); /* restore old table of globals */ + lua_setglobal(L, "T"); /* set new table as global T */ +} + +#endif diff --git a/src/lua/ltm.c b/src/lua/ltm.c new file mode 100644 index 00000000..3f69a6ca --- /dev/null +++ b/src/lua/ltm.c @@ -0,0 +1,163 @@ +/* +** $Id: ltm.c,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Tag methods +** See Copyright Notice in lua.h +*/ + + +#include <stdio.h> +#include <string.h> + +#include "lua.h" + +#include "ldo.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "ltm.h" + + +const char *const luaT_eventname[] = { /* ORDER TM */ + "gettable", "settable", "index", "getglobal", "setglobal", "add", "sub", + "mul", "div", "pow", "unm", "lt", "concat", "gc", "function", + "le", "gt", "ge", /* deprecated options!! */ + NULL +}; + + +static int findevent (const char *name) { + int i; + for (i=0; luaT_eventname[i]; i++) + if (strcmp(luaT_eventname[i], name) == 0) + return i; + return -1; /* name not found */ +} + + +static int luaI_checkevent (lua_State *L, const char *name, int t) { + int e = findevent(name); + if (e >= TM_N) + luaO_verror(L, "event `%.50s' is deprecated", name); + if (e == TM_GC && t == LUA_TTABLE) + luaO_verror(L, "event `gc' for tables is deprecated"); + if (e < 0) + luaO_verror(L, "`%.50s' is not a valid event name", name); + return e; +} + + + +/* events in LUA_TNIL are all allowed, since this is used as a +* 'placeholder' for "default" fallbacks +*/ +/* ORDER LUA_T, ORDER TM */ +static const char luaT_validevents[NUM_TAGS][TM_N] = { + {1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}, /* LUA_TUSERDATA */ + {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* LUA_TNIL */ + {1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}, /* LUA_TNUMBER */ + {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, /* LUA_TSTRING */ + {0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}, /* LUA_TTABLE */ + {1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0} /* LUA_TFUNCTION */ +}; + +int luaT_validevent (int t, int e) { /* ORDER LUA_T */ + return (t >= NUM_TAGS) ? 1 : luaT_validevents[t][e]; +} + + +static void init_entry (lua_State *L, int tag) { + int i; + for (i=0; i<TM_N; i++) + luaT_gettm(L, tag, i) = NULL; + L->TMtable[tag].collected = NULL; +} + + +void luaT_init (lua_State *L) { + int t; + luaM_growvector(L, L->TMtable, 0, NUM_TAGS, struct TM, "", MAX_INT); + L->nblocks += NUM_TAGS*sizeof(struct TM); + L->last_tag = NUM_TAGS-1; + for (t=0; t<=L->last_tag; t++) + init_entry(L, t); +} + + +LUA_API int lua_newtag (lua_State *L) { + luaM_growvector(L, L->TMtable, L->last_tag, 1, struct TM, + "tag table overflow", MAX_INT); + L->nblocks += sizeof(struct TM); + L->last_tag++; + init_entry(L, L->last_tag); + return L->last_tag; +} + + +static void checktag (lua_State *L, int tag) { + if (!(0 <= tag && tag <= L->last_tag)) + luaO_verror(L, "%d is not a valid tag", tag); +} + +void luaT_realtag (lua_State *L, int tag) { + if (!validtag(tag)) + luaO_verror(L, "tag %d was not created by `newtag'", tag); +} + + +LUA_API int lua_copytagmethods (lua_State *L, int tagto, int tagfrom) { + int e; + checktag(L, tagto); + checktag(L, tagfrom); + for (e=0; e<TM_N; e++) { + if (luaT_validevent(tagto, e)) + luaT_gettm(L, tagto, e) = luaT_gettm(L, tagfrom, e); + } + return tagto; +} + + +int luaT_tag (const TObject *o) { + int t = ttype(o); + switch (t) { + case LUA_TUSERDATA: return tsvalue(o)->u.d.tag; + case LUA_TTABLE: return hvalue(o)->htag; + default: return t; + } +} + + +LUA_API void lua_gettagmethod (lua_State *L, int t, const char *event) { + int e; + e = luaI_checkevent(L, event, t); + checktag(L, t); + if (luaT_validevent(t, e) && luaT_gettm(L, t, e)) { + clvalue(L->top) = luaT_gettm(L, t, e); + ttype(L->top) = LUA_TFUNCTION; + } + else + ttype(L->top) = LUA_TNIL; + incr_top; +} + + +LUA_API void lua_settagmethod (lua_State *L, int t, const char *event) { + int e = luaI_checkevent(L, event, t); + checktag(L, t); + if (!luaT_validevent(t, e)) + luaO_verror(L, "cannot change `%.20s' tag method for type `%.20s'%.20s", + luaT_eventname[e], luaO_typenames[t], + (t == LUA_TTABLE || t == LUA_TUSERDATA) ? + " with default tag" : ""); + switch (ttype(L->top - 1)) { + case LUA_TNIL: + luaT_gettm(L, t, e) = NULL; + break; + case LUA_TFUNCTION: + luaT_gettm(L, t, e) = clvalue(L->top - 1); + break; + default: + lua_error(L, "tag method must be a function (or nil)"); + } + L->top--; +} + diff --git a/src/lua/ltm.h b/src/lua/ltm.h new file mode 100644 index 00000000..f6be13ed --- /dev/null +++ b/src/lua/ltm.h @@ -0,0 +1,59 @@ +/* +** $Id: ltm.h,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Tag methods +** See Copyright Notice in lua.h +*/ + +#ifndef ltm_h +#define ltm_h + + +#include "lobject.h" +#include "lstate.h" + +/* +* WARNING: if you change the order of this enumeration, +* grep "ORDER TM" +*/ +typedef enum { + TM_GETTABLE = 0, + TM_SETTABLE, + TM_INDEX, + TM_GETGLOBAL, + TM_SETGLOBAL, + TM_ADD, + TM_SUB, + TM_MUL, + TM_DIV, + TM_POW, + TM_UNM, + TM_LT, + TM_CONCAT, + TM_GC, + TM_FUNCTION, + TM_N /* number of elements in the enum */ +} TMS; + + +struct TM { + Closure *method[TM_N]; + TString *collected; /* list of garbage-collected udata with this tag */ +}; + + +#define luaT_gettm(L,tag,event) (L->TMtable[tag].method[event]) +#define luaT_gettmbyObj(L,o,e) (luaT_gettm((L),luaT_tag(o),(e))) + + +#define validtag(t) (NUM_TAGS <= (t) && (t) <= L->last_tag) + +extern const char *const luaT_eventname[]; + + +void luaT_init (lua_State *L); +void luaT_realtag (lua_State *L, int tag); +int luaT_tag (const TObject *o); +int luaT_validevent (int t, int e); /* used by compatibility module */ + + +#endif diff --git a/src/lua/lua.h b/src/lua/lua.h new file mode 100644 index 00000000..87d64e71 --- /dev/null +++ b/src/lua/lua.h @@ -0,0 +1,248 @@ +/* +** $Id: lua.h,v 1.2 2001/11/26 23:00:26 darkgod Exp $ +** Lua - An Extensible Extension Language +** TeCGraf: Grupo de Tecnologia em Computacao Grafica, PUC-Rio, Brazil +** e-mail: lua@tecgraf.puc-rio.br +** www: http://www.tecgraf.puc-rio.br/lua/ +** See Copyright Notice at the end of this file +*/ + + +#ifndef lua_h +#define lua_h + + +/* definition of `size_t' */ +#include <stddef.h> + + +/* mark for all API functions */ +#ifndef LUA_API +#define LUA_API extern +#endif + + +#define LUA_VERSION "Lua 4.0" +#define LUA_COPYRIGHT "Copyright (C) 1994-2000 TeCGraf, PUC-Rio" +#define LUA_AUTHORS "W. Celes, R. Ierusalimschy & L. H. de Figueiredo" + + +/* name of global variable with error handler */ +#define LUA_ERRORMESSAGE "_ERRORMESSAGE" + + +/* pre-defined references */ +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) +#define LUA_REFREGISTRY 0 + +/* pre-defined tags */ +#define LUA_ANYTAG (-1) +#define LUA_NOTAG (-2) + + +/* option for multiple returns in lua_call */ +#define LUA_MULTRET (-1) + + +/* minimum stack available for a C function */ +#define LUA_MINSTACK 20 + + +/* error codes for lua_do* */ +#define LUA_ERRRUN 1 +#define LUA_ERRFILE 2 +#define LUA_ERRSYNTAX 3 +#define LUA_ERRMEM 4 +#define LUA_ERRERR 5 + + +typedef struct lua_State lua_State; + +typedef int (*lua_CFunction) (lua_State *L); + +/* +** types returned by `lua_type' +*/ +#define LUA_TNONE (-1) + +#define LUA_TUSERDATA 0 +#define LUA_TNIL 1 +#define LUA_TNUMBER 2 +#define LUA_TSTRING 3 +#define LUA_TTABLE 4 +#define LUA_TFUNCTION 5 + + + +/* +** state manipulation +*/ +LUA_API lua_State *lua_open (int stacksize); +LUA_API void lua_close (lua_State *L); + + +/* +** basic stack manipulation +*/ +LUA_API int lua_gettop (lua_State *L); +LUA_API void lua_settop (lua_State *L, int index); +LUA_API void lua_pushvalue (lua_State *L, int index); +LUA_API void lua_remove (lua_State *L, int index); +LUA_API void lua_insert (lua_State *L, int index); +LUA_API int lua_stackspace (lua_State *L); + + +/* +** access functions (stack -> C) +*/ + +LUA_API int lua_type (lua_State *L, int index); +LUA_API const char *lua_typename (lua_State *L, int t); +LUA_API int lua_isnumber (lua_State *L, int index); +LUA_API int lua_isstring (lua_State *L, int index); +LUA_API int lua_iscfunction (lua_State *L, int index); +LUA_API int lua_tag (lua_State *L, int index); + +LUA_API int lua_equal (lua_State *L, int index1, int index2); +LUA_API int lua_lessthan (lua_State *L, int index1, int index2); + +LUA_API long lua_tonumber (lua_State *L, int index); +LUA_API const char *lua_tostring (lua_State *L, int index); +LUA_API size_t lua_strlen (lua_State *L, int index); +LUA_API lua_CFunction lua_tocfunction (lua_State *L, int index); +LUA_API void *lua_touserdata (lua_State *L, int index); +LUA_API const void *lua_topointer (lua_State *L, int index); + + +/* +** push functions (C -> stack) +*/ +LUA_API void lua_pushnil (lua_State *L); +LUA_API void lua_pushnumber (lua_State *L, long n); +LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len); +LUA_API void lua_pushstring (lua_State *L, const char *s); +LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n); +LUA_API void lua_pushusertag (lua_State *L, void *u, int tag); + + +/* +** get functions (Lua -> stack) +*/ +LUA_API void lua_getglobal (lua_State *L, const char *name); +LUA_API void lua_gettable (lua_State *L, int index); +LUA_API void lua_rawget (lua_State *L, int index); +LUA_API void lua_rawgeti (lua_State *L, int index, int n); +LUA_API void lua_getglobals (lua_State *L); +LUA_API void lua_gettagmethod (lua_State *L, int tag, const char *event); +LUA_API int lua_getref (lua_State *L, int ref); +LUA_API void lua_newtable (lua_State *L); + + +/* +** set functions (stack -> Lua) +*/ +LUA_API void lua_setglobal (lua_State *L, const char *name); +LUA_API void lua_settable (lua_State *L, int index); +LUA_API void lua_rawset (lua_State *L, int index); +LUA_API void lua_rawseti (lua_State *L, int index, int n); +LUA_API void lua_setglobals (lua_State *L); +LUA_API void lua_settagmethod (lua_State *L, int tag, const char *event); +LUA_API int lua_ref (lua_State *L, int lock); + + +/* +** "do" functions (run Lua code) +*/ +LUA_API int lua_call (lua_State *L, int nargs, int nresults); +LUA_API void lua_rawcall (lua_State *L, int nargs, int nresults); +LUA_API int lua_dofile (lua_State *L, const char *filename); +LUA_API int lua_dostring (lua_State *L, const char *str); +LUA_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, const char *name); + +/* +** Garbage-collection functions +*/ +LUA_API int lua_getgcthreshold (lua_State *L); +LUA_API int lua_getgccount (lua_State *L); +LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold); + +/* +** miscellaneous functions +*/ +LUA_API int lua_newtag (lua_State *L); +LUA_API int lua_copytagmethods (lua_State *L, int tagto, int tagfrom); +LUA_API void lua_settag (lua_State *L, int tag); + +LUA_API void lua_error (lua_State *L, const char *s); + +LUA_API void lua_unref (lua_State *L, int ref); + +LUA_API int lua_next (lua_State *L, int index); +LUA_API int lua_getn (lua_State *L, int index); + +LUA_API void lua_concat (lua_State *L, int n); + +LUA_API void *lua_newuserdata (lua_State *L, size_t size); + + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + +#define lua_pop(L,n) lua_settop(L, -(n)-1) + +#define lua_register(L,n,f) (lua_pushcfunction(L, f), lua_setglobal(L, n)) +#define lua_pushuserdata(L,u) lua_pushusertag(L, u, 0) +#define lua_pushcfunction(L,f) lua_pushcclosure(L, f, 0) +#define lua_clonetag(L,t) lua_copytagmethods(L, lua_newtag(L), (t)) + +#define lua_isfunction(L,n) (lua_type(L,n) == LUA_TFUNCTION) +#define lua_istable(L,n) (lua_type(L,n) == LUA_TTABLE) +#define lua_isuserdata(L,n) (lua_type(L,n) == LUA_TUSERDATA) +#define lua_isnil(L,n) (lua_type(L,n) == LUA_TNIL) +#define lua_isnull(L,n) (lua_type(L,n) == LUA_TNONE) + +#define lua_getregistry(L) lua_getref(L, LUA_REFREGISTRY) + +#endif + + + +/****************************************************************************** +* Copyright (C) 1994-2000 TeCGraf, PUC-Rio. All rights reserved. +* +* Permission is hereby granted, without written agreement and without license +* or royalty fees, to use, copy, modify, and distribute this software and its +* documentation for any purpose, including commercial applications, subject to +* the following conditions: +* +* - The above copyright notice and this permission notice shall appear in all +* copies or substantial portions of this software. +* +* - The origin of this software must not be misrepresented; you must not +* claim that you wrote the original software. If you use this software in a +* product, an acknowledgment in the product documentation would be greatly +* appreciated (but it is not required). +* +* - Altered source versions must be plainly marked as such, and must not be +* misrepresented as being the original software. +* +* The authors specifically disclaim any warranties, including, but not limited +* to, the implied warranties of merchantability and fitness for a particular +* purpose. The software provided hereunder is on an "as is" basis, and the +* authors have no obligation to provide maintenance, support, updates, +* enhancements, or modifications. In no event shall TeCGraf, PUC-Rio, or the +* authors be held liable to any party for direct, indirect, special, +* incidental, or consequential damages arising out of the use of this software +* and its documentation. +* +* The Lua language and this implementation have been entirely designed and +* written by Waldemar Celes Filho, Roberto Ierusalimschy and +* Luiz Henrique de Figueiredo at TeCGraf, PUC-Rio. +* +* This implementation contains no third-party code. +******************************************************************************/ + diff --git a/src/lua/lua2c.lua b/src/lua/lua2c.lua new file mode 100644 index 00000000..3f8d1716 --- /dev/null +++ b/src/lua/lua2c.lua @@ -0,0 +1,29 @@ +-- lua2c.lua +-- embed lua code into C source +-- celetecgraf.puc-rio.br +-- dez 2000 + +function embed (code) + + -- clean Lua code + local s = clean(code) + if not s then + error("parser error in embedded code") + end + + -- convert to C + output('\n { /* begin embedded lua code */\n') + output(' static unsigned char B[] = {\n ') + local t={n=0} + local b = gsub(s,'(.)',function (c) + local e = '' + %t.n=%t.n+1 if %t.n==15 then %t.n=0 e='\n ' end + return format('%3u,%s',strbyte(c),e) + end + ) + output(b..strbyte(" ")) + output('\n };\n') + output(' lua_dobuffer(tolua_S,(char*)B,sizeof(B),"'..fn..': embedded Lua code");') + output(' } /* end of embedded lua code */\n\n') +end + diff --git a/src/lua/luadebug.h b/src/lua/luadebug.h new file mode 100644 index 00000000..21522445 --- /dev/null +++ b/src/lua/luadebug.h @@ -0,0 +1,46 @@ +/* +** $Id: luadebug.h,v 1.2 2001/11/26 23:00:26 darkgod Exp $ +** Debugging API +** See Copyright Notice in lua.h +*/ + + +#ifndef luadebug_h +#define luadebug_h + + +#include "lua.h" + +typedef struct lua_Debug lua_Debug; /* activation record */ +typedef struct lua_Localvar lua_Localvar; + +typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); + + +LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar); +LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar); +LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n); + +LUA_API lua_Hook lua_setcallhook (lua_State *L, lua_Hook func); +LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func); + + +#define LUA_IDSIZE 60 + +struct lua_Debug { + const char *event; /* `call', `return' */ + int currentline; /* (l) */ + const char *name; /* (n) */ + const char *namewhat; /* (n) `global', `tag method', `local', `field' */ + int nups; /* (u) number of upvalues */ + int linedefined; /* (S) */ + const char *what; /* (S) `Lua' function, `C' function, Lua `main' */ + const char *source; /* (S) */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + struct lua_TObject *_func; /* active function */ +}; + + +#endif diff --git a/src/lua/lualib.h b/src/lua/lualib.h new file mode 100644 index 00000000..89f5519f --- /dev/null +++ b/src/lua/lualib.h @@ -0,0 +1,34 @@ +/* +** $Id: lualib.h,v 1.2 2001/11/26 23:00:26 darkgod Exp $ +** Lua standard libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lualib_h +#define lualib_h + +#include "lua.h" + + +#ifndef LUALIB_API +#define LUALIB_API extern +#endif + + +#define LUA_ALERT "_ALERT" + +LUALIB_API void lua_baselibopen (lua_State *L); +LUALIB_API void lua_iolibopen (lua_State *L); +LUALIB_API void lua_strlibopen (lua_State *L); +LUALIB_API void lua_mathlibopen (lua_State *L); +LUALIB_API void lua_dblibopen (lua_State *L); + + + +/* Auxiliary functions (private) */ + +const char *luaI_classend (lua_State *L, const char *p); +int luaI_singlematch (int c, const char *p, const char *ep); + +#endif diff --git a/src/lua/lundump.c b/src/lua/lundump.c new file mode 100644 index 00000000..7f69573e --- /dev/null +++ b/src/lua/lundump.c @@ -0,0 +1,244 @@ +/* +** $Id: lundump.c,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** load bytecodes from files +** See Copyright Notice in lua.h +*/ + +#include <stdio.h> +#include <string.h> + +#include "lfunc.h" +#include "lmem.h" +#include "lopcodes.h" +#include "lstring.h" +#include "lundump.h" + +#define LoadByte ezgetc + +static const char* ZNAME (ZIO* Z) +{ + const char* s=zname(Z); + return (*s=='@') ? s+1 : s; +} + +static void unexpectedEOZ (lua_State* L, ZIO* Z) +{ + luaO_verror(L,"unexpected end of file in `%.99s'",ZNAME(Z)); +} + +static int ezgetc (lua_State* L, ZIO* Z) +{ + int c=zgetc(Z); + if (c==EOZ) unexpectedEOZ(L,Z); + return c; +} + +static void ezread (lua_State* L, ZIO* Z, void* b, int n) +{ + int r=zread(Z,b,n); + if (r!=0) unexpectedEOZ(L,Z); +} + +static void LoadBlock (lua_State* L, void* b, size_t size, ZIO* Z, int swap) +{ + if (swap) + { + char *p=(char *) b+size-1; + int n=size; + while (n--) *p--=(char)ezgetc(L,Z); + } + else + ezread(L,Z,b,size); +} + +static void LoadVector (lua_State* L, void* b, int m, size_t size, ZIO* Z, int swap) +{ + if (swap) + { + char *q=(char *) b; + while (m--) + { + char *p=q+size-1; + int n=size; + while (n--) *p--=(char)ezgetc(L,Z); + q+=size; + } + } + else + ezread(L,Z,b,m*size); +} + +static int LoadInt (lua_State* L, ZIO* Z, int swap) +{ + int x; + LoadBlock(L,&x,sizeof(x),Z,swap); + return x; +} + +static size_t LoadSize (lua_State* L, ZIO* Z, int swap) +{ + size_t x; + LoadBlock(L,&x,sizeof(x),Z,swap); + return x; +} + +static Number LoadNumber (lua_State* L, ZIO* Z, int swap) +{ + Number x; + LoadBlock(L,&x,sizeof(x),Z,swap); + return x; +} + +static TString* LoadString (lua_State* L, ZIO* Z, int swap) +{ + size_t size=LoadSize(L,Z,swap); + if (size==0) + return NULL; + else + { + char* s=luaO_openspace(L,size); + LoadBlock(L,s,size,Z,0); + return luaS_newlstr(L,s,size-1); /* remove trailing '\0' */ + } +} + +static void LoadCode (lua_State* L, Proto* tf, ZIO* Z, int swap) +{ + int size=LoadInt(L,Z,swap); + tf->code=luaM_newvector(L,size,Instruction); + LoadVector(L,tf->code,size,sizeof(*tf->code),Z,swap); + if (tf->code[size-1]!=OP_END) luaO_verror(L,"bad code in `%.99s'",ZNAME(Z)); + luaF_protook(L,tf,size); +} + +static void LoadLocals (lua_State* L, Proto* tf, ZIO* Z, int swap) +{ + int i,n; + tf->nlocvars=n=LoadInt(L,Z,swap); + tf->locvars=luaM_newvector(L,n,LocVar); + for (i=0; i<n; i++) + { + tf->locvars[i].varname=LoadString(L,Z,swap); + tf->locvars[i].startpc=LoadInt(L,Z,swap); + tf->locvars[i].endpc=LoadInt(L,Z,swap); + } +} + +static void LoadLines (lua_State* L, Proto* tf, ZIO* Z, int swap) +{ + int n; + tf->nlineinfo=n=LoadInt(L,Z,swap); + tf->lineinfo=luaM_newvector(L,n,int); + LoadVector(L,tf->lineinfo,n,sizeof(*tf->lineinfo),Z,swap); +} + +static Proto* LoadFunction (lua_State* L, ZIO* Z, int swap); + +static void LoadConstants (lua_State* L, Proto* tf, ZIO* Z, int swap) +{ + int i,n; + tf->nkstr=n=LoadInt(L,Z,swap); + tf->kstr=luaM_newvector(L,n,TString*); + for (i=0; i<n; i++) + tf->kstr[i]=LoadString(L,Z,swap); + tf->nknum=n=LoadInt(L,Z,swap); + tf->knum=luaM_newvector(L,n,Number); + LoadVector(L,tf->knum,n,sizeof(*tf->knum),Z,swap); + tf->nkproto=n=LoadInt(L,Z,swap); + tf->kproto=luaM_newvector(L,n,Proto*); + for (i=0; i<n; i++) + tf->kproto[i]=LoadFunction(L,Z,swap); +} + +static Proto* LoadFunction (lua_State* L, ZIO* Z, int swap) +{ + Proto* tf=luaF_newproto(L); + tf->source=LoadString(L,Z,swap); + tf->lineDefined=LoadInt(L,Z,swap); + tf->numparams=LoadInt(L,Z,swap); + tf->is_vararg=LoadByte(L,Z); + tf->maxstacksize=LoadInt(L,Z,swap); + LoadLocals(L,tf,Z,swap); + LoadLines(L,tf,Z,swap); + LoadConstants(L,tf,Z,swap); + LoadCode(L,tf,Z,swap); + return tf; +} + +static void LoadSignature (lua_State* L, ZIO* Z) +{ + const char* s=SIGNATURE; + while (*s!=0 && ezgetc(L,Z)==*s) + ++s; + if (*s!=0) luaO_verror(L,"bad signature in `%.99s'",ZNAME(Z)); +} + +static void TestSize (lua_State* L, int s, const char* what, ZIO* Z) +{ + int r=ezgetc(L,Z); + if (r!=s) + luaO_verror(L,"virtual machine mismatch in `%.99s':\n" + " %.20s is %d but read %d",ZNAME(Z),what,s,r); +} + +#define TESTSIZE(s) TestSize(L,s,#s,Z) +#define V(v) v/16,v%16 + +static int LoadHeader (lua_State* L, ZIO* Z) +{ + int version,swap; + Number f=0,tf=TEST_NUMBER; + LoadSignature(L,Z); + version=ezgetc(L,Z); + if (version>VERSION) + luaO_verror(L,"`%.99s' too new:\n" + " read version %d.%d; expected at most %d.%d", + ZNAME(Z),V(version),V(VERSION)); + if (version<VERSION0) /* check last major change */ + luaO_verror(L,"`%.99s' too old:\n" + " read version %d.%d; expected at least %d.%d", + ZNAME(Z),V(version),V(VERSION)); + swap=(luaU_endianess()!=ezgetc(L,Z)); /* need to swap bytes? */ + TESTSIZE(sizeof(int)); + TESTSIZE(sizeof(size_t)); + TESTSIZE(sizeof(Instruction)); + TESTSIZE(SIZE_INSTRUCTION); + TESTSIZE(SIZE_OP); + TESTSIZE(SIZE_B); + TESTSIZE(sizeof(Number)); + f=LoadNumber(L,Z,swap); + if ((long)f!=(long)tf) /* disregard errors in last bit of fraction */ + luaO_verror(L,"unknown number format in `%.99s':\n" + " read " NUMBER_FMT "; expected " NUMBER_FMT, ZNAME(Z),f,tf); + return swap; +} + +static Proto* LoadChunk (lua_State* L, ZIO* Z) +{ + return LoadFunction(L,Z,LoadHeader(L,Z)); +} + +/* +** load one chunk from a file or buffer +** return main if ok and NULL at EOF +*/ +Proto* luaU_undump (lua_State* L, ZIO* Z) +{ + Proto* tf=NULL; + int c=zgetc(Z); + if (c==ID_CHUNK) + tf=LoadChunk(L,Z); + c=zgetc(Z); + if (c!=EOZ) + luaO_verror(L,"`%.99s' apparently contains more than one chunk",ZNAME(Z)); + return tf; +} + +/* +** find byte order +*/ +int luaU_endianess (void) +{ + int x=1; + return *(char*)&x; +} diff --git a/src/lua/lundump.h b/src/lua/lundump.h new file mode 100644 index 00000000..ec394f46 --- /dev/null +++ b/src/lua/lundump.h @@ -0,0 +1,35 @@ +/* +** $Id: lundump.h,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** load pre-compiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#ifndef lundump_h +#define lundump_h + +#include "lobject.h" +#include "lzio.h" + +/* load one chunk */ +Proto* luaU_undump (lua_State* L, ZIO* Z); + +/* find byte order */ +int luaU_endianess (void); + +/* definitions for headers of binary files */ +#define VERSION 0x40 /* last format change was in 4.0 */ +#define VERSION0 0x40 /* last major change was in 4.0 */ +#define ID_CHUNK 27 /* binary files start with ESC... */ +#define SIGNATURE "Lua" /* ...followed by this signature */ + +/* formats for error messages */ +#define SOURCE_FMT "<%d:%.99s>" +#define SOURCE tf->lineDefined,tf->source->str +#define IN_FMT " in %p " SOURCE_FMT +#define IN tf,SOURCE + +/* a multiple of PI for testing native format */ +/* multiplying by 1E8 gives non-trivial integer values */ +#define TEST_NUMBER 3 + +#endif diff --git a/src/lua/lvm.c b/src/lua/lvm.c new file mode 100644 index 00000000..e304e11e --- /dev/null +++ b/src/lua/lvm.c @@ -0,0 +1,710 @@ +/* +** $Id: lvm.c,v 1.5 2004/06/04 13:42:10 neil Exp $ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + +#ifdef OLD_ANSI +#define strcoll(a,b) strcmp(a,b) +#endif + + + +/* +** Extra stack size to run a function: +** TAG_LINE(1), NAME(1), TM calls(3) (plus some extra...) +*/ +#define EXTRA_STACK 8 + + + +int luaV_tonumber (TObject *obj) { + if (ttype(obj) != LUA_TSTRING) + return 1; + else { + if (!luaO_str2d(svalue(obj), &nvalue(obj))) + return 2; + ttype(obj) = LUA_TNUMBER; + return 0; + } +} + + +int luaV_tostring (lua_State *L, TObject *obj) { /* LUA_NUMBER */ + if (ttype(obj) != LUA_TNUMBER) + return 1; + else { + char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */ + lua_number2str(s, nvalue(obj)); /* convert `s' to number */ + tsvalue(obj) = luaS_new(L, s); + ttype(obj) = LUA_TSTRING; + return 0; + } +} + + +static void traceexec (lua_State *L, StkId base, StkId top, lua_Hook linehook) { + CallInfo *ci = infovalue(base-1); + int *lineinfo = ci->func->f.l->lineinfo; + int pc = (*ci->pc - ci->func->f.l->code) - 1; + int newline; + if (pc == 0) { /* may be first time? */ + ci->line = 1; + ci->refi = 0; + ci->lastpc = pc+1; /* make sure it will call linehook */ + } + newline = luaG_getline(lineinfo, pc, ci->line, &ci->refi); + /* calls linehook when enters a new line or jumps back (loop) */ + if (newline != ci->line || pc <= ci->lastpc) { + ci->line = newline; + L->top = top; + luaD_lineHook(L, base-2, newline, linehook); + } + ci->lastpc = pc; +} + + +static Closure *luaV_closure (lua_State *L, int nelems) { + Closure *c = luaF_newclosure(L, nelems); + L->top -= nelems; + while (nelems--) + c->upvalue[nelems] = *(L->top+nelems); + clvalue(L->top) = c; + ttype(L->top) = LUA_TFUNCTION; + incr_top; + return c; +} + + +void luaV_Cclosure (lua_State *L, lua_CFunction c, int nelems) { + Closure *cl = luaV_closure(L, nelems); + cl->f.c = c; + cl->isC = 1; +} + + +void luaV_Lclosure (lua_State *L, Proto *l, int nelems) { + Closure *cl = luaV_closure(L, nelems); + cl->f.l = l; + cl->isC = 0; +} + + +/* +** Function to index a table. +** Receives the table at `t' and the key at top. +*/ +const TObject *luaV_gettable (lua_State *L, StkId t) { + Closure *tm; + int tg; + if (ttype(t) == LUA_TTABLE && /* `t' is a table? */ + ((tg = hvalue(t)->htag) == LUA_TTABLE || /* with default tag? */ + luaT_gettm(L, tg, TM_GETTABLE) == NULL)) { /* or no TM? */ + /* do a primitive get */ + const TObject *h = luaH_get(L, hvalue(t), L->top-1); + /* result is no nil or there is no `index' tag method? */ + if (ttype(h) != LUA_TNIL || ((tm=luaT_gettm(L, tg, TM_INDEX)) == NULL)) + return h; /* return result */ + /* else call `index' tag method */ + } + else { /* try a `gettable' tag method */ + tm = luaT_gettmbyObj(L, t, TM_GETTABLE); + } + if (tm != NULL) { /* is there a tag method? */ + luaD_checkstack(L, 2); + *(L->top+1) = *(L->top-1); /* key */ + *L->top = *t; /* table */ + clvalue(L->top-1) = tm; /* tag method */ + ttype(L->top-1) = LUA_TFUNCTION; + L->top += 2; + luaD_call(L, L->top - 3, 1); + return L->top - 1; /* call result */ + } + else { /* no tag method */ + luaG_typeerror(L, t, "index"); + return NULL; /* to avoid warnings */ + } +} + + +/* +** Receives table at `t', key at `key' and value at top. +*/ +void luaV_settable (lua_State *L, StkId t, StkId key) { + int tg; + if (ttype(t) == LUA_TTABLE && /* `t' is a table? */ + ((tg = hvalue(t)->htag) == LUA_TTABLE || /* with default tag? */ + luaT_gettm(L, tg, TM_SETTABLE) == NULL)) /* or no TM? */ + *luaH_set(L, hvalue(t), key) = *(L->top-1); /* do a primitive set */ + else { /* try a `settable' tag method */ + Closure *tm = luaT_gettmbyObj(L, t, TM_SETTABLE); + if (tm != NULL) { + luaD_checkstack(L, 3); + *(L->top+2) = *(L->top-1); + *(L->top+1) = *key; + *(L->top) = *t; + clvalue(L->top-1) = tm; + ttype(L->top-1) = LUA_TFUNCTION; + L->top += 3; + luaD_call(L, L->top - 4, 0); /* call `settable' tag method */ + } + else /* no tag method... */ + luaG_typeerror(L, t, "index"); + } +} + + +const TObject *luaV_getglobal (lua_State *L, TString *s) { + const TObject *value = luaH_getstr(L->gt, s); + Closure *tm = luaT_gettmbyObj(L, value, TM_GETGLOBAL); + if (tm == NULL) /* is there a tag method? */ + return value; /* default behavior */ + else { /* tag method */ + luaD_checkstack(L, 3); + clvalue(L->top) = tm; + ttype(L->top) = LUA_TFUNCTION; + tsvalue(L->top+1) = s; /* global name */ + ttype(L->top+1) = LUA_TSTRING; + *(L->top+2) = *value; + L->top += 3; + luaD_call(L, L->top - 3, 1); + return L->top - 1; + } +} + + +void luaV_setglobal (lua_State *L, TString *s) { + const TObject *oldvalue = luaH_getstr(L->gt, s); + Closure *tm = luaT_gettmbyObj(L, oldvalue, TM_SETGLOBAL); + if (tm == NULL) { /* is there a tag method? */ + if (oldvalue != &luaO_nilobject) { + /* cast to remove `const' is OK, because `oldvalue' != luaO_nilobject */ + *(TObject *)oldvalue = *(L->top - 1); + } + else { + TObject key; + ttype(&key) = LUA_TSTRING; + tsvalue(&key) = s; + *luaH_set(L, L->gt, &key) = *(L->top - 1); + } + } + else { + luaD_checkstack(L, 3); + *(L->top+2) = *(L->top-1); /* new value */ + *(L->top+1) = *oldvalue; + ttype(L->top) = LUA_TSTRING; + tsvalue(L->top) = s; + clvalue(L->top-1) = tm; + ttype(L->top-1) = LUA_TFUNCTION; + L->top += 3; + luaD_call(L, L->top - 4, 0); + } +} + + +static int call_binTM (lua_State *L, StkId top, TMS event) { + /* try first operand */ + Closure *tm = luaT_gettmbyObj(L, top-2, event); + L->top = top; + if (tm == NULL) { + tm = luaT_gettmbyObj(L, top-1, event); /* try second operand */ + if (tm == NULL) { + tm = luaT_gettm(L, 0, event); /* try a `global' method */ + if (tm == NULL) + return 0; /* error */ + } + } + lua_pushstring(L, luaT_eventname[event]); + luaD_callTM(L, tm, 3, 1); + return 1; +} + + +static void call_arith (lua_State *L, StkId top, TMS event) { + if (!call_binTM(L, top, event)) + luaG_binerror(L, top-2, LUA_TNUMBER, "perform arithmetic on"); +} + + +static int luaV_strcomp (const TString *ls, const TString *rs) { + const char *l = ls->str; + size_t ll = ls->len; + const char *r = rs->str; + size_t lr = rs->len; + for (;;) { + int temp = strcoll(l, r); + if (temp != 0) return temp; + else { /* strings are equal up to a '\0' */ + size_t len = strlen(l); /* index of first '\0' in both strings */ + if (len == ll) /* l is finished? */ + return (len == lr) ? 0 : -1; /* l is equal or smaller than r */ + else if (len == lr) /* r is finished? */ + return 1; /* l is greater than r (because l is not finished) */ + /* both strings longer than `len'; go on comparing (after the '\0') */ + len++; + l += len; ll -= len; r += len; lr -= len; + } + } +} + + +int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r, StkId top) { + if (ttype(l) == LUA_TNUMBER && ttype(r) == LUA_TNUMBER) + return (nvalue(l) < nvalue(r)); + else if (ttype(l) == LUA_TSTRING && ttype(r) == LUA_TSTRING) + return (luaV_strcomp(tsvalue(l), tsvalue(r)) < 0); + else { /* call TM */ + luaD_checkstack(L, 2); + *top++ = *l; + *top++ = *r; + if (!call_binTM(L, top, TM_LT)) + luaG_ordererror(L, top-2); + L->top--; + return (ttype(L->top) != LUA_TNIL); + } +} + + +void luaV_strconc (lua_State *L, int total, StkId top) { + do { + int n = 2; /* number of elements handled in this pass (at least 2) */ + if (tostring(L, top-2) || tostring(L, top-1)) { + if (!call_binTM(L, top, TM_CONCAT)) + luaG_binerror(L, top-2, LUA_TSTRING, "concat"); + } + else if (tsvalue(top-1)->len > 0) { /* if len=0, do nothing */ + /* at least two string values; get as many as possible */ + lint32 tl = (lint32)tsvalue(top-1)->len + + (lint32)tsvalue(top-2)->len; + char *buffer; + int i; + while (n < total && !tostring(L, top-n-1)) { /* collect total length */ + tl += tsvalue(top-n-1)->len; + n++; + } + if (tl > MAX_SIZET) lua_error(L, "string size overflow"); + buffer = luaO_openspace(L, tl); + tl = 0; + for (i=n; i>0; i--) { /* concat all strings */ + size_t l = tsvalue(top-i)->len; + memcpy(buffer+tl, tsvalue(top-i)->str, l); + tl += l; + } + tsvalue(top-n) = luaS_newlstr(L, buffer, tl); + } + total -= n-1; /* got `n' strings to create 1 new */ + top -= n-1; + } while (total > 1); /* repeat until only 1 result left */ +} + + +static void luaV_pack (lua_State *L, StkId firstelem) { + int i; + Hash *htab = luaH_new(L, 0); + for (i=0; firstelem+i<L->top; i++) + *luaH_setint(L, htab, i+1) = *(firstelem+i); + /* store counter in field `n' */ + luaH_setstrnum(L, htab, luaS_new(L, "n"), i); + L->top = firstelem; /* remove elements from the stack */ + ttype(L->top) = LUA_TTABLE; + hvalue(L->top) = htab; + incr_top; +} + + +static void adjust_varargs (lua_State *L, StkId base, int nfixargs) { + int nvararg = (L->top-base) - nfixargs; + if (nvararg < 0) + luaD_adjusttop(L, base, nfixargs); + luaV_pack(L, base+nfixargs); +} + + + +#define dojump(pc, i) { int d = GETARG_S(i); pc += d; } + +/* +** Executes the given Lua function. Parameters are between [base,top). +** Returns n such that the the results are between [n,top). +*/ +StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) { + const Proto *const tf = cl->f.l; + StkId top; /* keep top local, for performance */ + const Instruction *pc = tf->code; + TString **const kstr = tf->kstr; + const lua_Hook linehook = L->linehook; + infovalue(base-1)->pc = &pc; + luaD_checkstack(L, tf->maxstacksize+EXTRA_STACK); + if (tf->is_vararg) /* varargs? */ + adjust_varargs(L, base, tf->numparams); + else + luaD_adjusttop(L, base, tf->numparams); + top = L->top; + /* main loop of interpreter */ + for (;;) { + const Instruction i = *pc++; + if (linehook) + traceexec(L, base, top, linehook); + switch (GET_OPCODE(i)) { + case OP_END: { + L->top = top; + return top; + } + case OP_RETURN: { + L->top = top; + return base+GETARG_U(i); + } + case OP_CALL: { + int nres = GETARG_B(i); + if (nres == MULT_RET) nres = LUA_MULTRET; + L->top = top; + luaD_call(L, base+GETARG_A(i), nres); + top = L->top; + break; + } + case OP_TAILCALL: { + L->top = top; + luaD_call(L, base+GETARG_A(i), LUA_MULTRET); + return base+GETARG_B(i); + } + case OP_PUSHNIL: { + int n = GETARG_U(i); + LUA_ASSERT(n>0, "invalid argument"); + do { + ttype(top++) = LUA_TNIL; + } while (--n > 0); + break; + } + case OP_POP: { + top -= GETARG_U(i); + break; + } + case OP_PUSHINT: { + ttype(top) = LUA_TNUMBER; + nvalue(top) = (Number)GETARG_S(i); + top++; + break; + } + case OP_PUSHSTRING: { + ttype(top) = LUA_TSTRING; + tsvalue(top) = kstr[GETARG_U(i)]; + top++; + break; + } + case OP_PUSHNUM: { + ttype(top) = LUA_TNUMBER; + nvalue(top) = tf->knum[GETARG_U(i)]; + top++; + break; + } + case OP_PUSHNEGNUM: { + ttype(top) = LUA_TNUMBER; + nvalue(top) = -tf->knum[GETARG_U(i)]; + top++; + break; + } + case OP_PUSHUPVALUE: { + *top++ = cl->upvalue[GETARG_U(i)]; + break; + } + case OP_GETLOCAL: { + *top++ = *(base+GETARG_U(i)); + break; + } + case OP_GETGLOBAL: { + L->top = top; + *top = *luaV_getglobal(L, kstr[GETARG_U(i)]); + top++; + break; + } + case OP_GETTABLE: { + L->top = top; + top--; + *(top-1) = *luaV_gettable(L, top-1); + break; + } + case OP_GETDOTTED: { + ttype(top) = LUA_TSTRING; + tsvalue(top) = kstr[GETARG_U(i)]; + L->top = top+1; + *(top-1) = *luaV_gettable(L, top-1); + break; + } + case OP_GETINDEXED: { + *top = *(base+GETARG_U(i)); + L->top = top+1; + *(top-1) = *luaV_gettable(L, top-1); + break; + } + case OP_PUSHSELF: { + TObject receiver; + receiver = *(top-1); + ttype(top) = LUA_TSTRING; + tsvalue(top++) = kstr[GETARG_U(i)]; + L->top = top; + *(top-2) = *luaV_gettable(L, top-2); + *(top-1) = receiver; + break; + } + case OP_CREATETABLE: { + L->top = top; + luaC_checkGC(L); + hvalue(top) = luaH_new(L, GETARG_U(i)); + ttype(top) = LUA_TTABLE; + top++; + break; + } + case OP_SETLOCAL: { + *(base+GETARG_U(i)) = *(--top); + break; + } + case OP_SETGLOBAL: { + L->top = top; + luaV_setglobal(L, kstr[GETARG_U(i)]); + top--; + break; + } + case OP_SETTABLE: { + StkId t = top-GETARG_A(i); + L->top = top; + luaV_settable(L, t, t+1); + top -= GETARG_B(i); /* pop values */ + break; + } + case OP_SETLIST: { + int aux = GETARG_A(i) * LFIELDS_PER_FLUSH; + int n = GETARG_B(i); + Hash *arr = hvalue(top-n-1); + L->top = top-n; /* final value of `top' (in case of errors) */ + for (; n; n--) + *luaH_setint(L, arr, n+aux) = *(--top); + break; + } + case OP_SETMAP: { + int n = GETARG_U(i); + StkId finaltop = top-2*n; + Hash *arr = hvalue(finaltop-1); + L->top = finaltop; /* final value of `top' (in case of errors) */ + for (; n; n--) { + top-=2; + *luaH_set(L, arr, top) = *(top+1); + } + break; + } + case OP_ADD: { + if (tonumber(top-2) || tonumber(top-1)) + call_arith(L, top, TM_ADD); + else + nvalue(top-2) += nvalue(top-1); + top--; + break; + } + case OP_ADDI: { + if (tonumber(top-1)) { + ttype(top) = LUA_TNUMBER; + nvalue(top) = (Number)GETARG_S(i); + call_arith(L, top+1, TM_ADD); + } + else + nvalue(top-1) += (Number)GETARG_S(i); + break; + } + case OP_SUB: { + if (tonumber(top-2) || tonumber(top-1)) + call_arith(L, top, TM_SUB); + else + nvalue(top-2) -= nvalue(top-1); + top--; + break; + } + case OP_MULT: { + if (tonumber(top-2) || tonumber(top-1)) + call_arith(L, top, TM_MUL); + else + nvalue(top-2) *= nvalue(top-1); + top--; + break; + } + case OP_DIV: { + if (tonumber(top-2) || tonumber(top-1)) + call_arith(L, top, TM_DIV); + else + nvalue(top-2) /= nvalue(top-1); + top--; + break; + } + case OP_POW: { + if (!call_binTM(L, top, TM_POW)) + lua_error(L, "undefined operation"); + top--; + break; + } + case OP_CONCAT: { + int n = GETARG_U(i); + luaV_strconc(L, n, top); + top -= n-1; + L->top = top; + luaC_checkGC(L); + break; + } + case OP_MINUS: { + if (tonumber(top-1)) { + ttype(top) = LUA_TNIL; + call_arith(L, top+1, TM_UNM); + } + else + nvalue(top-1) = -nvalue(top-1); + break; + } + case OP_NOT: { + ttype(top-1) = + (ttype(top-1) == LUA_TNIL) ? LUA_TNUMBER : LUA_TNIL; + nvalue(top-1) = 1; + break; + } + case OP_JMPNE: { + top -= 2; + if (!luaO_equalObj(top, top+1)) dojump(pc, i); + break; + } + case OP_JMPEQ: { + top -= 2; + if (luaO_equalObj(top, top+1)) dojump(pc, i); + break; + } + case OP_JMPLT: { + top -= 2; + if (luaV_lessthan(L, top, top+1, top+2)) dojump(pc, i); + break; + } + case OP_JMPLE: { /* a <= b === !(b<a) */ + top -= 2; + if (!luaV_lessthan(L, top+1, top, top+2)) dojump(pc, i); + break; + } + case OP_JMPGT: { /* a > b === (b<a) */ + top -= 2; + if (luaV_lessthan(L, top+1, top, top+2)) dojump(pc, i); + break; + } + case OP_JMPGE: { /* a >= b === !(a<b) */ + top -= 2; + if (!luaV_lessthan(L, top, top+1, top+2)) dojump(pc, i); + break; + } + case OP_JMPT: { + if (ttype(--top) != LUA_TNIL) dojump(pc, i); + break; + } + case OP_JMPF: { + if (ttype(--top) == LUA_TNIL) dojump(pc, i); + break; + } + case OP_JMPONT: { + if (ttype(top-1) == LUA_TNIL) top--; + else dojump(pc, i); + break; + } + case OP_JMPONF: { + if (ttype(top-1) != LUA_TNIL) top--; + else dojump(pc, i); + break; + } + case OP_JMP: { + dojump(pc, i); + break; + } + case OP_PUSHNILJMP: { + ttype(top++) = LUA_TNIL; + pc++; + break; + } + case OP_FORPREP: { + if (tonumber(top-1)) + lua_error(L, "`for' step must be a number"); + if (tonumber(top-2)) + lua_error(L, "`for' limit must be a number"); + if (tonumber(top-3)) + lua_error(L, "`for' initial value must be a number"); + if (nvalue(top-1) > 0 ? + nvalue(top-3) > nvalue(top-2) : + nvalue(top-3) < nvalue(top-2)) { /* `empty' loop? */ + top -= 3; /* remove control variables */ + dojump(pc, i); /* jump to loop end */ + } + break; + } + case OP_FORLOOP: { + LUA_ASSERT(ttype(top-1) == LUA_TNUMBER, "invalid step"); + LUA_ASSERT(ttype(top-2) == LUA_TNUMBER, "invalid limit"); + if (ttype(top-3) != LUA_TNUMBER) + lua_error(L, "`for' index must be a number"); + nvalue(top-3) += nvalue(top-1); /* increment index */ + if (nvalue(top-1) > 0 ? + nvalue(top-3) > nvalue(top-2) : + nvalue(top-3) < nvalue(top-2)) + top -= 3; /* end loop: remove control variables */ + else + dojump(pc, i); /* repeat loop */ + break; + } + case OP_LFORPREP: { + Node *node; + if (ttype(top-1) != LUA_TTABLE) + lua_error(L, "`for' table must be a table"); + node = luaH_next(L, hvalue(top-1), &luaO_nilobject); + if (node == NULL) { /* `empty' loop? */ + top--; /* remove table */ + dojump(pc, i); /* jump to loop end */ + } + else { + top += 2; /* index,value */ + *(top-2) = *key(node); + *(top-1) = *val(node); + } + break; + } + case OP_LFORLOOP: { + Node *node; + LUA_ASSERT(ttype(top-3) == LUA_TTABLE, "invalid table"); + node = luaH_next(L, hvalue(top-3), top-2); + if (node == NULL) /* end loop? */ + top -= 3; /* remove table, key, and value */ + else { + *(top-2) = *key(node); + *(top-1) = *val(node); + dojump(pc, i); /* repeat loop */ + } + break; + } + case OP_CLOSURE: { + L->top = top; + luaV_Lclosure(L, tf->kproto[GETARG_A(i)], GETARG_B(i)); + top = L->top; + luaC_checkGC(L); + break; + } + } + } +} diff --git a/src/lua/lvm.h b/src/lua/lvm.h new file mode 100644 index 00000000..ac95ae41 --- /dev/null +++ b/src/lua/lvm.h @@ -0,0 +1,32 @@ +/* +** $Id: lvm.h,v 1.3 2001/11/26 23:00:26 darkgod Exp $ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#ifndef lvm_h +#define lvm_h + + +#include "ldo.h" +#include "lobject.h" +#include "ltm.h" + + +#define tonumber(o) ((ttype(o) != LUA_TNUMBER) && (luaV_tonumber(o) != 0)) +#define tostring(L,o) ((ttype(o) != LUA_TSTRING) && (luaV_tostring(L, o) != 0)) + + +int luaV_tonumber (TObject *obj); +int luaV_tostring (lua_State *L, TObject *obj); +const TObject *luaV_gettable (lua_State *L, StkId t); +void luaV_settable (lua_State *L, StkId t, StkId key); +const TObject *luaV_getglobal (lua_State *L, TString *s); +void luaV_setglobal (lua_State *L, TString *s); +StkId luaV_execute (lua_State *L, const Closure *cl, StkId base); +void luaV_Cclosure (lua_State *L, lua_CFunction c, int nelems); +void luaV_Lclosure (lua_State *L, Proto *l, int nelems); +int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r, StkId top); +void luaV_strconc (lua_State *L, int total, StkId top); + +#endif diff --git a/src/lua/lzio.c b/src/lua/lzio.c new file mode 100644 index 00000000..84d4a35c --- /dev/null +++ b/src/lua/lzio.c @@ -0,0 +1,84 @@ +/* +** $Id: lzio.c,v 1.5 2004/06/04 13:42:10 neil Exp $ +** a generic input stream interface +** See Copyright Notice in lua.h +*/ + + + +#include <stdio.h> +#include <string.h> + +#include "lua.h" + +#include "lzio.h" + + + +/* ----------------------------------------------------- memory buffers --- */ + +static int zmfilbuf (ZIO* z) { + (void)z; /* to avoid warnings */ + return EOZ; +} + + +ZIO* zmopen (ZIO* z, const char* b, size_t size, const char *name) { + if (b==NULL) return NULL; + z->n = size; + z->p = (const unsigned char *)b; + z->filbuf = zmfilbuf; + z->u = NULL; + z->name = name; + return z; +} + +/* ------------------------------------------------------------ strings --- */ + +ZIO* zsopen (ZIO* z, const char* s, const char *name) { + if (s==NULL) return NULL; + return zmopen(z, s, strlen(s), name); +} + +/* -------------------------------------------------------------- FILEs --- */ + +static int zffilbuf (ZIO* z) { + size_t n; + if (feof((FILE *)z->u)) return EOZ; + n = fread(z->buffer, 1, ZBSIZE, (FILE *)z->u); + if (n==0) return EOZ; + z->n = n-1; + z->p = z->buffer; + return *(z->p++); +} + + +ZIO* zFopen (ZIO* z, FILE* f, const char *name) { + if (f==NULL) return NULL; + z->n = 0; + z->p = z->buffer; + z->filbuf = zffilbuf; + z->u = f; + z->name = name; + return z; +} + + +/* --------------------------------------------------------------- read --- */ +size_t zread (ZIO *z, void *b, size_t n) { + while (n) { + size_t m; + if (z->n == 0) { + if (z->filbuf(z) == EOZ) + return n; /* return number of missing bytes */ + zungetc(z); /* put result from `filbuf' in the buffer */ + } + m = (n <= z->n) ? n : z->n; /* min. between n and z->n */ + memcpy(b, z->p, m); + z->n -= m; + z->p += m; + b = (char *)b + m; + n -= m; + } + return 0; +} diff --git a/src/lua/lzio.h b/src/lua/lzio.h new file mode 100644 index 00000000..45feeee3 --- /dev/null +++ b/src/lua/lzio.h @@ -0,0 +1,53 @@ +/* +** $Id: lzio.h,v 1.5 2004/06/04 13:42:10 neil Exp $ +** Buffered streams +** See Copyright Notice in lua.h +*/ + + +#ifndef lzio_h +#define lzio_h + +#include <stdio.h> + + + +/* For Lua only */ +#define zFopen luaZ_Fopen +#define zsopen luaZ_sopen +#define zmopen luaZ_mopen +#define zread luaZ_read + +#define EOZ (-1) /* end of stream */ + +typedef struct zio ZIO; + +ZIO* zFopen (ZIO* z, FILE* f, const char *name); /* open FILEs */ +ZIO* zsopen (ZIO* z, const char* s, const char *name); /* string */ +ZIO* zmopen (ZIO* z, const char* b, size_t size, const char *name); /* memory */ + +size_t zread (ZIO* z, void* b, size_t n); /* read next n bytes */ + +#define zgetc(z) (((z)->n--)>0 ? ((int)*(z)->p++): (z)->filbuf(z)) +#define zungetc(z) (++(z)->n,--(z)->p) +#define zname(z) ((z)->name) + + + +/* --------- Private Part ------------------ */ + +#ifndef ZBSIZE +#define ZBSIZE 256 /* buffer size */ +#endif + +struct zio { + size_t n; /* bytes still unread */ + const unsigned char* p; /* current position in buffer */ + int (*filbuf)(ZIO* z); + void* u; /* additional data */ + const char *name; + unsigned char buffer[ZBSIZE]; /* buffer */ +}; + + +#endif diff --git a/src/lua/module.lua b/src/lua/module.lua new file mode 100644 index 00000000..98dffe6e --- /dev/null +++ b/src/lua/module.lua @@ -0,0 +1,69 @@ +-- tolua: module class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: module.lua,v 1.2 2001/11/26 23:00:26 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + + +-- Module class +-- Represents module. +-- The following fields are stored: +-- {i} = list of objects in the module. +classModule = { + _base = classContainer, + type = 'module' +} +settag(classModule,tolua_tag) + +-- register module +function classModule:register () + output(' tolua_module(tolua_S,"'..self.name..'");') + local i=1 + while self[i] do + self[i]:register() + i = i+1 + end +end + +-- unregister module +function classModule:unregister () + output(' lua_pushnil(tolua_S); lua_setglobal(tolua_S,"'..self.name..'");') +end + +-- Print method +function classModule:print (ident,close) + print(ident.."Module{") + print(ident.." name = '"..self.name.."';") + local i=1 + while self[i] do + self[i]:print(ident.." ",",") + i = i+1 + end + print(ident.."}"..close) +end + +-- Internal constructor +function _Module (t) + t._base = classModule + settag(t,tolua_tag) + append(t) + return t +end + +-- Constructor +-- Expects two string representing the module name and body. +function Module (n,b) + local t = _Module(_Container{name=n}) + push(t) + t:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces + pop() + return t +end + + diff --git a/src/lua/operator.lua b/src/lua/operator.lua new file mode 100644 index 00000000..7a42cf1b --- /dev/null +++ b/src/lua/operator.lua @@ -0,0 +1,111 @@ +-- tolua: operator class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: operator.lua,v 1.2 2001/11/26 23:00:27 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Operator class +-- Represents an operator function or a class operator method. +-- It stores the same fields as functions do plus: +-- kind = set of character representing the operator (as it appers in C++ code) +classOperator = { + kind = '', + _base = classFunction, +} +settag(classOperator,tolua_tag) + +-- table to transform operator kind into the appropriate tag method name +_TM = {['+'] = 'operator_add', + ['-'] = 'operator_sub', + ['*'] = 'operator_mul', + ['/'] = 'operator_div', + ['<'] = 'operator_lt', + ['[]'] = 'operator_get', + ['&[]'] = 'operator_set', + } + + +-- Print method +function classOperator:print (ident,close) + print(ident.."Operator{") + print(ident.." kind = '"..self.kind.."',") + print(ident.." mod = '"..self.mod.."',") + print(ident.." type = '"..self.type.."',") + print(ident.." ptr = '"..self.ptr.."',") + print(ident.." name = '"..self.name.."',") + print(ident.." const = '"..self.const.."',") + print(ident.." cname = '"..self.cname.."',") + print(ident.." lname = '"..self.lname.."',") + print(ident.." args = {") + local i=1 + while self.args[i] do + self.args[i]:print(ident.." ",",") + i = i+1 + end + print(ident.." }") + print(ident.."}"..close) +end + +-- Internal constructor +function _Operator (t) + t._base = classOperator + settag(t,tolua_tag) + + if t.const ~= 'const' and t.const ~= '' then + error("#invalid 'const' specification") + end + + append(t) + if not t:inclass() then + error("#operator can only be defined as class member") + end + + t.cname = t:cfuncname("toluaI")..t:overload(t) + t.name = t.name..t.kind + return t +end + +-- Constructor +-- Expects three strings: one representing the function declaration, +-- another representing the argument list, and the third representing +-- the "const" or empty string. +function Operator (d,k,a,c) + local t = split(strsub(a,2,strlen(a)-1),',') -- eliminate braces + local i=1 + local l = {n=0} + while t[i] do + l.n = l.n+1 + l[l.n] = Declaration(t[i],'var') + i = i+1 + end + if k == '[]' then + d = gsub(d,'&','') + elseif k=='&[]' then + l.n = l.n+1 + l[l.n] = Declaration(d,'var') + l[l.n].name = 'toluaI_value' + end + local f = Declaration(d,'func') + if k == '[]' and (l[1]==nil or isbasic(l[1].type)~='number') then + error('operator[] can only be defined for numeric index.') + end + f.args = l + f.const = c + f.kind = gsub(k,"%s","") + f.lname = _TM[f.kind] + if not f.lname then + error("tolua: no support for operator" .. f.kind) + end + if f.kind == '[]' and not strfind(f.mod,'const') then + Operator(d,'&'..k,a,c) -- create correspoding set operator + end + return _Operator(f) +end + + diff --git a/src/lua/package.lua b/src/lua/package.lua new file mode 100644 index 00000000..42dbfaac --- /dev/null +++ b/src/lua/package.lua @@ -0,0 +1,222 @@ +-- tolua: package class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: package.lua,v 1.4 2002/01/03 13:45:08 takkaria Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + + +-- Package class +-- Represents the whole package being bound. +-- The following fields are stored: +-- {i} = list of objects in the package. +classPackage = { + _base = classContainer, + type = 'package' +} +settag(classPackage,tolua_tag) + +-- Print method +function classPackage:print () + print("Package: "..self.name) + local i=1 + while self[i] do + self[i]:print("","") + i = i+1 + end +end + +function classPackage:preprocess () + self.code = "\n"..self.code -- add a blank sentinel line + -- avoid preprocessing verbatim lines + local V = {} + self.code = gsub(self.code,"\n(%s*%$[^%[%]][^\n]*)",function (v) + tinsert(%V,v) + return "\n$"..getn(%V).."$" + end) + -- avoid preprocessing embedded lua code + local C = {} + self.code = gsub(self.code,"\n%s*%$%[","\1") -- deal with embedded Lua code + self.code = gsub(self.code,"\n%s*%$%]","\2") + self.code = gsub(self.code,"(%b\1\2)", function (c) + tinsert(%C,c) + return "\n$["..getn(%C).."]$" + end) + -- perform global substitution + + self.code = gsub(self.code,"(//[^\n]*)","") -- eliminate C++ comments + self.code = gsub(self.code,"/%*","\1") + self.code = gsub(self.code,"%*/","\2") + self.code = gsub(self.code,"%b\1\2","") + self.code = gsub(self.code,"\1","/%*") + self.code = gsub(self.code,"\2","%*/") + self.code = gsub(self.code,"%s*@%s*","@") -- eliminate spaces beside @ + self.code = gsub(self.code,"%s?inline(%s)","%1") -- eliminate 'inline' keyword + self.code = gsub(self.code,"%s?extern(%s)","%1") -- eliminate 'extern' keyword + self.code = gsub(self.code,"%s?virtual(%s)","%1") -- eliminate 'virtual' keyword + self.code = gsub(self.code,"public:","") -- eliminate 'public:' keyword + self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*' + self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*' + self.code = gsub(self.code,"([^%w_])char%s*%*","%1_cstring ") -- substitute 'char*' + + -- restore embedded code + self.code = gsub(self.code,"%$%[(%d+)%]%$",function (n) + return %C[tonumber(n)] + end) + -- restore verbatim lines + self.code = gsub(self.code,"%$(%d+)%$",function (n) + return %V[tonumber(n)] + end) +end + +-- translate verbatim +function classPackage:preamble () + output('/*\n') + output('** Lua binding: '..self.name..'\n') + output('** Generated automatically by '..TOLUA_VERSION..'\n') + output('*/\n\n') + + output('#include "lua/tolua.h"\n\n') + + if not flags.h then + output('/* Exported function */') + output('int tolua_'..self.name..'_open (lua_State* tolua_S);') + output('void tolua_'..self.name..'_close (lua_State* tolua_S);') + output('\n') + end + + local i=1 + while self[i] do + self[i]:preamble() + i = i+1 + end + output('\n') + output('/* function to register type */') + output('static void toluaI_reg_types (lua_State* tolua_S)') + output('{') + foreach(_usertype,function(n,v) output(' tolua_usertype(tolua_S,"',v,'");') end) + output('}') + output('\n') + + output('/* error messages */') + output('#define TOLUA_ERR_SELF tolua_error(tolua_S,\"invalid \'self\'\")') + output('#define TOLUA_ERR_ASSIGN tolua_error(tolua_S,\"#vinvalid type in variable assignment.\")') + output('\n') +end + +-- register package +-- write package open function +function classPackage:register () + output("/* Open function */") + output("int tolua_"..self.name.."_open (lua_State* tolua_S)") + output("{") + output(" tolua_open(tolua_S);") + output(" toluaI_reg_types(tolua_S);") + local i=1 + while self[i] do + self[i]:register() + i = i+1 + end + output(" return 1;") + output("}") +end + +-- unregister package +-- write package close function +function classPackage:unregister () + output("/* Close function */") + output("void tolua_"..self.name.."_close (lua_State* tolua_S)") + output("{") + local i=1 + while self[i] do + self[i]:unregister() + i = i+1 + end + output("}") +end + +-- write header file +function classPackage:header () + output('/*\n') output('** Lua binding: '..self.name..'\n') + output('** Generated automatically by '..TOLUA_VERSION..'.\n') + output('*/\n\n') + + if not flags.h then + output('/* Exported function */') + output('int tolua_'..self.name..'_open (lua_State* tolua_S);') + output('void tolua_'..self.name..'_close (lua_State* tolua_S);') + output('\n') + end +end + +-- Internal constructor +function _Package (t) + t._base = classPackage + settag(t,tolua_tag) + return t +end + +-- Constructor +-- Expects the base file name. +-- It assumes the file has extension ".pkg". +function Package (name) + -- read file + local code = read("*a") + code = "\n" .. code -- add sentinel + -- deal with include directive + local nsubst + repeat + code,nsubst = gsub(code,"\n%s*%$<(.-)>%s*\n",function (fn) + local fp,msg = openfile(fn,'r') + if not fp then + error('#'..msg..': '..fn) + end + local s = read(fp,'*a') + closefile(fp) + return "\n" .. s + end) + until nsubst==0 + + -- deal with include directive for C/C++ header files + local nsubst + repeat + code,nsubst = + gsub(code,"\n%s*%${(.-)}%s*\n", + function (fn) + local fp,msg = openfile(fn,'r') + if not fp then + error('#'..msg..': '..fn) + end + local s = read(fp,'*a') + closefile(fp) + -- extract marked code + local T = {code="\n"} + s= "\n" .. s .. "\n" -- add blank lines as sentinels + -- extract one-line statments + gsub(s,"\n(.-)[Tt][Oo][Ll][Uu][Aa]_[Ee][Xx][Pp][Oo][Rr][Tt][^\n]*\n", + function (c) %T.code = %T.code .. c .. "\n" end + ) + -- extract multiline statments + gsub(s,"\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Bb][Ee][Gg][Ii][Nn][^\n]*".. + "(.-)" .. + "\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n", + function (c) %T.code = %T.code .. c .. "\n" end + ) + return T.code + end) + until nsubst==0 + + local t = _Package(_Container{name=name, code=code}) + push(t) + t:preprocess() + t:parse(t.code) + pop() + return t +end + + diff --git a/src/lua/print.h b/src/lua/print.h new file mode 100644 index 00000000..49f4c4cb --- /dev/null +++ b/src/lua/print.h @@ -0,0 +1,55 @@ +/* +** $Id: print.h,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +** extracted automatically from lopcodes.h by mkprint.lua -- DO NOT EDIT +** See Copyright Notice in lua.h +*/ + + case OP_END: P_OP("END"); P_NONE; break; + case OP_RETURN: P_OP("RETURN"); P_U; break; + case OP_CALL: P_OP("CALL"); P_AB; break; + case OP_TAILCALL: P_OP("TAILCALL"); P_AB; break; + case OP_PUSHNIL: P_OP("PUSHNIL"); P_U; break; + case OP_POP: P_OP("POP"); P_U; break; + case OP_PUSHINT: P_OP("PUSHINT"); P_S; break; + case OP_PUSHSTRING: P_OP("PUSHSTRING"); P_Q; break; + case OP_PUSHNUM: P_OP("PUSHNUM"); P_N; break; + case OP_PUSHNEGNUM: P_OP("PUSHNEGNUM"); P_N; break; + case OP_PUSHUPVALUE: P_OP("PUSHUPVALUE"); P_U; break; + case OP_GETLOCAL: P_OP("GETLOCAL"); P_L; break; + case OP_GETGLOBAL: P_OP("GETGLOBAL"); P_K; break; + case OP_GETTABLE: P_OP("GETTABLE"); P_NONE; break; + case OP_GETDOTTED: P_OP("GETDOTTED"); P_K; break; + case OP_GETINDEXED: P_OP("GETINDEXED"); P_L; break; + case OP_PUSHSELF: P_OP("PUSHSELF"); P_K; break; + case OP_CREATETABLE: P_OP("CREATETABLE"); P_U; break; + case OP_SETLOCAL: P_OP("SETLOCAL"); P_L; break; + case OP_SETGLOBAL: P_OP("SETGLOBAL"); P_K; break; + case OP_SETTABLE: P_OP("SETTABLE"); P_AB; break; + case OP_SETLIST: P_OP("SETLIST"); P_AB; break; + case OP_SETMAP: P_OP("SETMAP"); P_U; break; + case OP_ADD: P_OP("ADD"); P_NONE; break; + case OP_ADDI: P_OP("ADDI"); P_S; break; + case OP_SUB: P_OP("SUB"); P_NONE; break; + case OP_MULT: P_OP("MULT"); P_NONE; break; + case OP_DIV: P_OP("DIV"); P_NONE; break; + case OP_POW: P_OP("POW"); P_NONE; break; + case OP_CONCAT: P_OP("CONCAT"); P_U; break; + case OP_MINUS: P_OP("MINUS"); P_NONE; break; + case OP_NOT: P_OP("NOT"); P_NONE; break; + case OP_JMPNE: P_OP("JMPNE"); P_J; break; + case OP_JMPEQ: P_OP("JMPEQ"); P_J; break; + case OP_JMPLT: P_OP("JMPLT"); P_J; break; + case OP_JMPLE: P_OP("JMPLE"); P_J; break; + case OP_JMPGT: P_OP("JMPGT"); P_J; break; + case OP_JMPGE: P_OP("JMPGE"); P_J; break; + case OP_JMPT: P_OP("JMPT"); P_J; break; + case OP_JMPF: P_OP("JMPF"); P_J; break; + case OP_JMPONT: P_OP("JMPONT"); P_J; break; + case OP_JMPONF: P_OP("JMPONF"); P_J; break; + case OP_JMP: P_OP("JMP"); P_J; break; + case OP_PUSHNILJMP: P_OP("PUSHNILJMP"); P_NONE; break; + case OP_FORPREP: P_OP("FORPREP"); P_J; break; + case OP_FORLOOP: P_OP("FORLOOP"); P_J; break; + case OP_LFORPREP: P_OP("LFORPREP"); P_J; break; + case OP_LFORLOOP: P_OP("LFORLOOP"); P_J; break; + case OP_CLOSURE: P_OP("CLOSURE"); P_F; break; diff --git a/src/lua/tolua.c b/src/lua/tolua.c new file mode 100644 index 00000000..3cb09291 --- /dev/null +++ b/src/lua/tolua.c @@ -0,0 +1,149 @@ +/* tolua +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua.c,v 1.4 2004/06/04 13:42:10 neil Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + +#include "tolua.h" +#include "lua.h" +#include "lualib.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +static void help (void) +{ + fprintf(stderr,"\n" + "usage: tolua [options] input_file\n" + "\n" + "Command line options are:\n" + " -v : print version information.\n" + " -o file : set output file; default is stdout.\n" + " -H file : create include file.\n" + " -n name : set package name; default is input file root name.\n" + " -p : parse only.\n" + " -P : parse and print structure information (for debug).\n" + " -h : print this message.\n" + "Should the input file be omitted, stdin is assumed;\n" + "in that case, the package name must be explicitly set.\n\n" + ); +} + +static void version (void) +{ + fprintf(stderr, "%s (written by W. Celes)\n",TOLUA_VERSION); +} + +static void setfield (lua_State* L, int table, char* f, char* v) +{ + lua_pushstring(L,f); + lua_pushstring(L,v); + lua_settable(L,table); +} + +static void error (char* o) +{ + fprintf(stderr,"tolua: unknown option '%s'\n",o); + help(); + exit(1); +} + +int main (int argc, char* argv[]) +{ + lua_State* L = lua_open(0); + lua_baselibopen(L); + lua_iolibopen(L); + lua_strlibopen(L); + lua_pushstring(L,TOLUA_VERSION); lua_setglobal(L,"TOLUA_VERSION"); + + if (argc==1) + { + help(); + return 0; + } + else + { + int i, t; + lua_newtable(L); + lua_pushvalue(L,-1); + lua_setglobal(L,"flags"); + t = lua_gettop(L); + for (i=1; i<argc; ++i) + { + if (*argv[i] == '-') + { + switch (argv[i][1]) + { + case 'v': version(); return 0; + case 'h': help(); return 0; + case 'p': setfield(L,t,"p",""); break; + case 'P': setfield(L,t,"P",""); break; + case 'o': setfield(L,t,"o",argv[++i]); break; + case 'n': setfield(L,t,"n",argv[++i]); break; + case 'H': setfield(L,t,"H",argv[++i]); break; + default: error(argv[i]); break; + } + } + else + { + setfield(L,t,"f",argv[i]); + break; + } + } + lua_pop(L,1); + } + +#if 1 + { + int tolua_tolualua_open(lua_State* L); + tolua_tolualua_open(L); + } +#else + { + int i; + char* p; + char path[BUFSIZ]; + char* files[] = { + "basic.lua", + "feature.lua", + "verbatim.lua", + "code.lua", + "typedef.lua", + "container.lua", + "package.lua", + "module.lua", + "define.lua", + "enumerate.lua", + "declaration.lua", + "variable.lua", + "array.lua", + "function.lua", + "operator.lua", + "class.lua", + "clean.lua", + "doit.lua", + NULL + }; + strcpy(path,argv[0]); + p = strrchr(path,'/'); + p = (p==NULL) ? path : p+1; + for (i=0; files[i]; ++i) + { + sprintf(p,"%s",files[i]); + lua_dofile(L,path); + } + } + +#endif + return 0; +} diff --git a/src/lua/tolua.h b/src/lua/tolua.h new file mode 100644 index 00000000..ab86976c --- /dev/null +++ b/src/lua/tolua.h @@ -0,0 +1,127 @@ +/* tolua - Support code for Lua bindings. +** Written by Waldemar Celes (celes@tecgraf.puc-rio.br) +** TeCGraf/PUC-Rio +** http://www.tecgraf.puc-rio.br/~celes/tolua +** Jul 1998 +** $Id: tolua.h,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + + +#ifndef tolua_h +#define tolua_h + +#define TOLUA_VERSION "tolua 4.0a - angband" + + +#include <stdlib.h> /* NULL, malloc, free */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "lua.h" + +/* Evil hack for C++ bool_ vs. C bool. */ +#ifndef __cplusplus +typedef unsigned char bool; +#endif + +/*************************************** Exported functions */ + +int tolua_open (lua_State* L); +void tolua_using (lua_State* L, int module); +void tolua_class (lua_State* L, int derived, int base); +void tolua_instance (lua_State* L, int instance, int classobj); +void tolua_foreach (lua_State* L, int lo, int f); +int tolua_tag (lua_State* L, char* type); +const char* tolua_type (lua_State* L, int lo); +int tolua_base (lua_State* L, int lo); +int tolua_cast (lua_State* L, int lo, char* type); +void tolua_takeownership (lua_State* L, int lo); + + + +/*************************************** Support functions for binding code */ + +#define LUA_VALUE int +#define LUA_NIL 0 /* TODO */ +/*#define TOLUA_NIL (lua_pushnil(),lua_pop())*/ + +/* Register functions */ +void tolua_globalvar (lua_State* L, char* name, lua_CFunction get, lua_CFunction set); +void tolua_globalarray (lua_State* L, char* name, lua_CFunction get, lua_CFunction set); +void tolua_module (lua_State* L, char* name); +void tolua_cclass (lua_State* L, char* name, char* base); +void tolua_function (lua_State* L, char* parent, char* name, lua_CFunction func); +void tolua_constant (lua_State* L, char* parent, char* name, long value); +void tolua_tablevar +(lua_State* L, char* table, char* name, lua_CFunction get, lua_CFunction set); +void tolua_tablearray +(lua_State* L, char* table, char* name, lua_CFunction get, lua_CFunction set); + + +/* Get and push functions */ +long tolua_getnumber (lua_State* L, int narg, long def); +const char* tolua_getstring (lua_State* L, int narg, const char* def); +void* tolua_getuserdata (lua_State* L, int narg, void* def); +void* tolua_getusertype (lua_State* L, int narg, void* def); +int tolua_getvalue (lua_State* L, int narg, int def); +int tolua_getbool (lua_State* L, int narg, int def); +long tolua_getfieldnumber (lua_State* L, int lo, int index, long def); +const char* tolua_getfieldstring (lua_State* L, int lo, int index, const char* def); +void* tolua_getfielduserdata (lua_State* L, int lo, int index, void* def); +void* tolua_getfieldusertype (lua_State* L, int lo, int index, void* def); +int tolua_getfieldvalue (lua_State* L, int lo, int index, int def); +int tolua_getfieldbool (lua_State* L, int lo, int index, int def); + +void tolua_pushnumber (lua_State* L, long value); +void tolua_pushstring (lua_State* L, const char* value); +void tolua_pushuserdata (lua_State* L, void* value); +void tolua_pushusertype (lua_State* L, void* value, int tag); +void tolua_pushvalue (lua_State* L, int lo); +void tolua_pushbool (lua_State* L, int value); +void tolua_pushfieldnumber (lua_State* L, int lo, int index, long v); +void tolua_pushfieldstring (lua_State* L, int lo, int index, char* v); +void tolua_pushfielduserdata (lua_State* L, int lo, int index, void* v); +void tolua_pushfieldusertype (lua_State* L, int lo, int index, void* v, int tag); +void tolua_pushfieldvalue (lua_State* L, int lo, int index, int v); +void tolua_pushfieldbool (lua_State* L, int lo, int index, int v); + + +/* Type & tag manipulation */ +void tolua_usertype (lua_State* L, char* type); +#if 0 +void tolua_settag (lua_State* L, char* type, int* tag); +#endif +int tolua_istype (lua_State* L, int narg, int tag, int dim); +int tolua_arrayistype (lua_State* L, int narg, int tag, int dim, int def); + +int tolua_isnoobj (lua_State* L, int narg); + +/* Tag method manipulation */ +void* tolua_doclone (lua_State* L, void* value, int tag); +void* tolua_copy (lua_State* L, void* value, unsigned int size); + +/* Error handling */ +void tolua_error (lua_State* L, char* msg); + +/* Exported variables */ +extern int tolua_tag_nil; +extern int tolua_tag_number; +extern int tolua_tag_string; +extern int tolua_tag_userdata; +extern int tolua_tag_table; +extern int tolua_tag_function; + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/src/lua/tolua_bd.c b/src/lua/tolua_bd.c new file mode 100644 index 00000000..d36a5ce9 --- /dev/null +++ b/src/lua/tolua_bd.c @@ -0,0 +1,214 @@ +/* +** Lua binding: tolua +** Generated automatically by tolua 4.0b on Tue Nov 14 14:18:50 2000. +*/ + +#include "tolua.h" + +/* Exported function */ +int tolua_tolua_open (lua_State* tolua_S); +void tolua_tolua_close (lua_State* tolua_S); + +#define tolua_using(module) (tolua_using)(tolua_S,module) +#define tolua_type(lo) (tolua_type)(tolua_S,lo) +#define tolua_foreach(lo,f) (tolua_foreach)(tolua_S,lo,f) +#define tolua_class(derived,base) (tolua_class)(tolua_S,derived,base) +#define tolua_instance(inst,cobj) (tolua_instance)(tolua_S,inst,cobj) +#define tolua_base(lo) (tolua_base)(tolua_S,lo) +#define tolua_cast(lo,type) (tolua_cast)(tolua_S,lo,type) +#define tolua_takeownership(lo) (tolua_takeownership)(tolua_S,lo) + +/* function to register type */ +static void toluaI_reg_types (lua_State* tolua_S) +{ +} + +/* function: tolua_using */ +static int toluaI_tolua_tolua_using00(lua_State* tolua_S) +{ + if ( + !tolua_isnoobj(tolua_S,2) + ) + goto tolua_lerror; + else + { + LUA_VALUE module = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + { + tolua_using(module); + } + } + return 0; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'using'."); + return 0; +} + +/* function: tolua_type */ +static int toluaI_tolua_tolua_type00(lua_State* tolua_S) +{ + if ( + !tolua_isnoobj(tolua_S,2) + ) + goto tolua_lerror; + else + { + LUA_VALUE lo = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + { + char* toluaI_ret = (char*) tolua_type(lo); + tolua_pushstring(tolua_S,toluaI_ret); + } + } + return 1; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'type'."); + return 0; +} + +/* function: tolua_foreach */ +static int toluaI_tolua_tolua_foreach00(lua_State* tolua_S) +{ + if ( + !tolua_isnoobj(tolua_S,3) + ) + goto tolua_lerror; + else + { + LUA_VALUE lo = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + LUA_VALUE f = ((LUA_VALUE) tolua_getvalue(tolua_S,2,0)); + { + tolua_foreach(lo,f); + } + } + return 0; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'foreach'."); + return 0; +} + +/* function: tolua_class */ +static int toluaI_tolua_tolua_class00(lua_State* tolua_S) +{ + if ( + !tolua_isnoobj(tolua_S,3) + ) + goto tolua_lerror; + else + { + LUA_VALUE derived = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + LUA_VALUE base = ((LUA_VALUE) tolua_getvalue(tolua_S,2,0)); + { + tolua_class(derived,base); + } + } + return 0; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'class'."); + return 0; +} + +/* function: tolua_instance */ +static int toluaI_tolua_tolua_instance00(lua_State* tolua_S) +{ + if ( + !tolua_isnoobj(tolua_S,3) + ) + goto tolua_lerror; + else + { + LUA_VALUE instance = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + LUA_VALUE classobj = ((LUA_VALUE) tolua_getvalue(tolua_S,2,0)); + { + tolua_instance(instance,classobj); + } + } + return 0; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'instance'."); + return 0; +} + +/* function: tolua_base */ +static int toluaI_tolua_tolua_base00(lua_State* tolua_S) +{ + if ( + !tolua_isnoobj(tolua_S,2) + ) + goto tolua_lerror; + else + { + LUA_VALUE lo = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + { + LUA_VALUE toluaI_ret = (LUA_VALUE) tolua_base(lo); + tolua_pushvalue(tolua_S,toluaI_ret); + } + } + return 1; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'base'."); + return 0; +} + +/* function: tolua_cast */ +static int toluaI_tolua_tolua_cast00(lua_State* tolua_S) +{ + if ( + !tolua_istype(tolua_S,2,LUA_TSTRING,0) || + !tolua_isnoobj(tolua_S,3) + ) + goto tolua_lerror; + else + { + LUA_VALUE lo = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + char* type = ((char*) tolua_getstring(tolua_S,2,0)); + { + LUA_VALUE toluaI_ret = (LUA_VALUE) tolua_cast(lo,type); + tolua_pushvalue(tolua_S,toluaI_ret); + } + } + return 1; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'cast'."); + return 0; +} + +/* function: tolua_takeownership */ +static int toluaI_tolua_tolua_takeownership00(lua_State* tolua_S) +{ + if ( + !tolua_isnoobj(tolua_S,2) + ) + goto tolua_lerror; + else + { + LUA_VALUE lo = ((LUA_VALUE) tolua_getvalue(tolua_S,1,0)); + { + tolua_takeownership(lo); + } + } + return 0; +tolua_lerror: + tolua_error(tolua_S,"#ferror in function 'takeownership'."); + return 0; +} + +/* Open function */ +int tolua_tolua_open (lua_State* tolua_S) +{ + tolua_open(tolua_S); + toluaI_reg_types(tolua_S); + tolua_module(tolua_S,"tolua"); + tolua_function(tolua_S,"tolua","using",toluaI_tolua_tolua_using00); + tolua_function(tolua_S,"tolua","type",toluaI_tolua_tolua_type00); + tolua_function(tolua_S,"tolua","foreach",toluaI_tolua_tolua_foreach00); + tolua_function(tolua_S,"tolua","class",toluaI_tolua_tolua_class00); + tolua_function(tolua_S,"tolua","instance",toluaI_tolua_tolua_instance00); + tolua_function(tolua_S,"tolua","base",toluaI_tolua_tolua_base00); + tolua_function(tolua_S,"tolua","cast",toluaI_tolua_tolua_cast00); + tolua_function(tolua_S,"tolua","takeownership",toluaI_tolua_tolua_takeownership00); + return 1; +} +/* Close function */ +void tolua_tolua_close (lua_State* tolua_S) +{ + lua_pushnil(tolua_S); lua_setglobal(tolua_S,"tolua"); +} diff --git a/src/lua/tolua_eh.c b/src/lua/tolua_eh.c new file mode 100644 index 00000000..0709cb4c --- /dev/null +++ b/src/lua/tolua_eh.c @@ -0,0 +1,66 @@ +/* tolua: error handling +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_eh.c,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + +#include "tolua.h" +#include "tolua_eh.h" +#include "tolua_rg.h" + +#include <stdio.h> + +/* registry fiels used to hold current error info + - tolua_err_narg: number of wrong argument + - tolua_err_provided: provided type + - tolua_err_expected: expected type +*/ + +void toluaI_eh_set +(lua_State* L, int narg, const char* provided, const char* expected) +{ + lua_pushnumber(L,narg); + toluaI_setregistry(L,"tolua_err_narg"); + lua_pushstring(L,provided); + toluaI_setregistry(L,"tolua_err_provided"); + lua_pushstring(L,expected); + toluaI_setregistry(L,"tolua_err_expected"); +} + +void tolua_error (lua_State* L, char* msg) +{ + if (msg[0]=='#') + { + static char buffer[BUFSIZ]; + const char* err_provided; + const char* err_expected; + toluaI_getregistry(L,"tolua_err_provided"); + err_provided = lua_tostring(L,-1); + toluaI_getregistry(L,"tolua_err_expected"); + err_expected = lua_tostring(L,-1); + lua_pop(L,2); + if (msg[1]=='f') + { + int err_narg; + toluaI_getregistry(L,"tolua_err_narg"); + err_narg = (int)lua_tonumber(L,-1); + lua_pop(L,1); + sprintf(buffer,"%s\n argument #%d is '%s'; '%s' expected.\n", + msg+2,err_narg,err_provided,err_expected); + } + else if (msg[1]=='v') + sprintf(buffer,"%s\n value is '%s'; '%s' expected.\n", + msg+2,err_provided,err_expected); + lua_error(L,buffer); + } + else + lua_error(L,msg); +} diff --git a/src/lua/tolua_eh.h b/src/lua/tolua_eh.h new file mode 100644 index 00000000..168ba122 --- /dev/null +++ b/src/lua/tolua_eh.h @@ -0,0 +1,24 @@ +/* tolua: error handling +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_eh.h,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + + + +#ifndef tolua_eh_h +#define tolua_eh_h + +void toluaI_eh_set +(lua_State* L, int narg, const char* provided, const char* expected); + + +#endif diff --git a/src/lua/tolua_gp.c b/src/lua/tolua_gp.c new file mode 100644 index 00000000..77ff0c26 --- /dev/null +++ b/src/lua/tolua_gp.c @@ -0,0 +1,197 @@ +/* tolua: get & push functions. +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_gp.c,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + +#include "tolua.h" +#include "tolua_tm.h" + +#include <string.h> +#include <stdlib.h> + +long tolua_getnumber (lua_State* L, int narg, long def) +{ + return lua_gettop(L)<abs(narg) ? def : lua_tonumber(L,narg); +} + +const char* tolua_getstring (lua_State* L, int narg, const char* def) +{ + return lua_gettop(L)<abs(narg) ? def : lua_tostring(L,narg); +} + +void* tolua_getuserdata (lua_State* L, int narg, void* def) +{ + return lua_gettop(L)<abs(narg) ? def : lua_touserdata(L,narg); +} + +void* tolua_getusertype (lua_State* L, int narg, void* def) +{ + return lua_gettop(L)<abs(narg) ? def : lua_touserdata(L,narg); +} + +int tolua_getvalue (lua_State* L, int narg, int def) +{ + return lua_gettop(L)<abs(narg) ? def : narg; +} + +int tolua_getbool (lua_State* L, int narg, int def) +{ + return lua_gettop(L)<abs(narg) ? + def : + lua_isnil(L,narg) ? 0 : lua_tonumber(L,narg)!=0; +} + +long tolua_getfieldnumber (lua_State* L, int lo, int index, long def) +{ + long v; + lua_pushnumber(L,index); + lua_gettable(L,lo); + v = lua_isnil(L,-1) ? def : lua_tonumber(L,-1); + lua_pop(L,1); + return v; +} + +const char* tolua_getfieldstring +(lua_State* L, int lo, int index, const char* def) +{ + const char* v; + lua_pushnumber(L,index); + lua_gettable(L,lo); + v = lua_isnil(L,-1) ? def : lua_tostring(L,-1); + lua_pop(L,1); + return v; +} + +void* tolua_getfielduserdata (lua_State* L, int lo, int index, void* def) +{ + void* v; + lua_pushnumber(L,index); + lua_gettable(L,lo); + v = lua_isnil(L,-1) ? def : lua_touserdata(L,-1); + lua_pop(L,1); + return v; +} + +void* tolua_getfieldusertype (lua_State* L, int lo, int index, void* def) +{ + void* v; + lua_pushnumber(L,index); + lua_gettable(L,lo); + v = lua_isnil(L,-1) ? def : lua_touserdata(L,-1); + lua_pop(L,1); + return v; +} + +int tolua_getfieldvalue (lua_State* L, int lo, int index, int def) +{ + int v; + lua_pushnumber(L,index); + lua_gettable(L,lo); + v = lua_isnil(L,-1) ? def : lo; + lua_pop(L,1); + return v; +} + +int tolua_getfieldbool (lua_State* L, int lo, int index, int def) +{ + int v; + lua_pushnumber(L,index); + lua_gettable(L,lo); + v = lua_isnil(L,-1) ? 0 : lua_tonumber(L,-1)!=0; + lua_pop(L,1); + return v; +} + +void tolua_pushnumber (lua_State* L, long value) +{ + lua_pushnumber(L,value); +} + +void tolua_pushstring (lua_State* L, const char* value) +{ + if (value == NULL) + lua_pushnil(L); + else + lua_pushstring(L,value); +} + +void tolua_pushuserdata (lua_State* L, void* value) +{ + if (value == NULL) + lua_pushnil(L); + else + lua_pushuserdata(L,value); +} + +void tolua_pushusertype (lua_State* L, void* value, int tag) +{ + if (value == NULL) + lua_pushnil(L); + else + lua_pushusertag(L,value,tag); +} + +void tolua_pushvalue (lua_State* L, int lo) +{ + lua_pushvalue(L,lo); +} + +void tolua_pushbool (lua_State* L, int value) +{ + if (value) + lua_pushnumber(L,(long)value); + else + lua_pushnil(L); +} + +void tolua_pushfieldnumber (lua_State* L, int lo, int index, long v) +{ + lua_pushnumber(L,index); + tolua_pushnumber(L,v); + lua_settable(L,lo); +} + +void tolua_pushfieldstring (lua_State* L, int lo, int index, char* v) +{ + lua_pushnumber(L,index); + tolua_pushstring(L,v); + lua_settable(L,lo); +} + +void tolua_pushfielduserdata (lua_State* L, int lo, int index, void* v) +{ + lua_pushnumber(L,index); + tolua_pushuserdata(L,v); + lua_settable(L,lo); +} + +void tolua_pushfieldusertype (lua_State* L, int lo, int index, void* v, int tag) +{ + lua_pushnumber(L,index); + tolua_pushusertype(L,v,tag); + lua_settable(L,lo); +} + +void tolua_pushfieldvalue (lua_State* L, int lo, int index, int v) +{ + lua_pushnumber(L,index); + lua_pushvalue(L,v); + lua_settable(L,lo); +} + +void tolua_pushfieldbool (lua_State* L, int lo, int index, int v) +{ + lua_pushnumber(L,index); + tolua_pushbool(L,v); + lua_settable(L,lo); +} + diff --git a/src/lua/tolua_lb.c b/src/lua/tolua_lb.c new file mode 100644 index 00000000..5fd4c337 --- /dev/null +++ b/src/lua/tolua_lb.c @@ -0,0 +1,160 @@ +/* tolua +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_lb.c,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + +#include "tolua.h" +#include "tolua_rg.h" +#include "tolua_tm.h" +#include "tolua_tt.h" + + +int tolua_open (lua_State* L) +{ + int tolua_tolua_open (lua_State* L); + /* check if alread opened */ + toluaI_getregistry(L,"TOLUA"); + if (lua_isnil(L,-1)) + { + lua_pushnumber(L,1); + toluaI_setregistry(L,"TOLUA"); + toluaI_tt_init(L); + toluaI_tm_init(L); + lua_getglobal(L,"foreach"); + toluaI_setregistry(L,"tolua_orig_foreach"); + tolua_tolua_open(L); /* opens tolua own binding */ + } + lua_pop(L,1); + return 1; +} + +void tolua_using (lua_State* L, int module) +{ + toluaI_tm_using(L,module); +} + +void tolua_class (lua_State* L, int derived, int base) +{ + int tag = lua_newtag(L); /* new tag of instances of that class */ + toluaI_tm_setclass(L,derived); + toluaI_tm_linstance(L,tag,derived); + lua_pushvalue(L,derived); + lua_pushstring(L,".base"); + lua_pushvalue(L,base); + lua_rawset(L,-3); + lua_pushstring(L,".itag"); + lua_pushnumber(L,tag); + lua_rawset(L,-3); + lua_pop(L,1); +} + +void tolua_instance (lua_State* L, int instance, int classobj) +{ + int tag; + lua_pushvalue(L,classobj); + lua_pushstring(L,".itag"); + lua_gettable(L,-2); + tag = (int) lua_tonumber(L,-1); + lua_pop(L,2); /* number and table */ + if (tag==0) + tolua_error(L,"unregistered 'classobj' in function 'tolua_instance'."); + lua_pushvalue(L,instance); + lua_settag(L,tag); + lua_pop(L,1); +} + +static int filter (lua_State* L) +{ + int n = 1; /* name */ + int v = 2; /* value */ + int f = lua_gettop(L); /* function */ + /* do not pass string fields starting with a dot */ + if (!lua_isstring(L,n) || *lua_tostring(L,n)!='.') + { + lua_pushvalue(L,f); + lua_pushvalue(L,n); + lua_pushvalue(L,v); + lua_call(L,2,1); + } + else + lua_pushnil(L); + return 1; +} + +void tolua_foreach (lua_State* L, int lo, int f) +{ + if (toluaI_tt_isusertype(L,lo)) + { + toluaI_tm_pushmate(L,lo); + if (lua_isnil(L,-1)) + return; /* no field in mate table */ + else + lo = lua_gettop(L); + } + toluaI_getregistry(L,"tolua_orig_foreach"); + lua_pushvalue(L,lo); + lua_pushvalue(L,f); + lua_pushcclosure(L,filter,1); + lua_call(L,2,1); +} + +const char* tolua_type (lua_State* L, int lo) +{ + return toluaI_tt_getobjtype(L,lo); +} + +int tolua_tag (lua_State* L, char* type) +{ + return toluaI_tt_gettag(L,type); +} + +int tolua_base (lua_State* L, int lo) +{ + if (toluaI_tt_isusertype(L,lo)) + { + toluaI_tm_pushclass(L,lo); + return lua_gettop(L); + } + else if (lua_istable(L,lo)) + { + lua_pushvalue(L,lo); + lua_pushstring(L,".base"); + lua_rawget(L,-2); + return -1; + } + else + return 0; +} + +int tolua_cast (lua_State* L, int lo, char* type) +{ + if (lua_isuserdata(L,lo)) + { + tolua_pushusertype(L,lua_touserdata(L,lo),toluaI_tt_gettag(L,type)); + return -1; + } + else + return 0; +} + +void tolua_takeownership (lua_State* L, int lo) +{ + if (toluaI_tt_isusertype(L,lo)) + { + /* force garbage collection to avoid C to reuse a to-be-collected address */ + lua_setgcthreshold(L,0); + tolua_doclone(L,lua_touserdata(L,lo),lua_tag(L,lo)); + } + else + tolua_error(L,"cannot take ownership of specified obejct."); +} + diff --git a/src/lua/tolua_rg.c b/src/lua/tolua_rg.c new file mode 100644 index 00000000..4337e9f9 --- /dev/null +++ b/src/lua/tolua_rg.c @@ -0,0 +1,243 @@ +/* tolua: register functions +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_rg.c,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + +#include <stdio.h> + +#include "tolua.h" +#include "tolua_rg.h" +#include "tolua_tm.h" +#include "tolua_tt.h" + +void tolua_globalvar (lua_State* L, char* name, lua_CFunction get, lua_CFunction set) +{ + lua_newtable(L); + lua_pushstring(L,".get"); + lua_pushcfunction(L,get); + lua_settable(L,-3); + if (set) + { + lua_pushstring(L,".set"); + lua_pushcfunction(L,set); + lua_settable(L,-3); + } + lua_pushvalue(L,-1); /* duplicate top */ + lua_setglobal(L,name); + toluaI_tm_global(L,lua_gettop(L)); + lua_pop(L,1); +} + +static int toluaI_const_global_array (lua_State* L) +{ + lua_error(L,"value of const array cannot be changed"); + return 0; +} + + +void tolua_globalarray (lua_State* L,char* name, lua_CFunction get, lua_CFunction set) +{ + int tag = lua_newtag(L); + lua_newtable(L); + lua_settag(L,tag); + lua_setglobal(L,name); + + lua_pushcfunction(L,get); + lua_settagmethod(L,tag,"gettable"); + if (set) + lua_pushcfunction(L,set); + else + lua_pushcfunction(L,toluaI_const_global_array); + lua_settagmethod(L,tag,"settable"); +} + +void tolua_tablevar +(lua_State* L, char* table, char* name, lua_CFunction get, lua_CFunction set) +{ + lua_getglobal(L,table); + + lua_pushstring(L,".get"); + lua_gettable(L,-2); + lua_pushstring(L,name); + lua_pushcfunction(L,get); + lua_settable(L,-3); + lua_pop(L,1); + if (set) + { + lua_pushstring(L,".set"); + lua_gettable(L,-2); + lua_pushstring(L,name); + lua_pushcfunction(L,set); + lua_settable(L,-3); + lua_pop(L,1); + } + + lua_pop(L,1); +} + +static int toluaI_get_array (lua_State* L) +{ + void* self = tolua_getuserdata(L,1,0); + const char* field = tolua_getstring(L,2,0); + + if (!field) + tolua_error(L,"invalid 'field' in accessing array"); + if (!self) + { + static char msg[BUFSIZ]; + sprintf(msg,"invalid 'self' in accessing array '%s'",field); + tolua_error(L,msg); + } + toluaI_getregistry(L,"tolua_tbl_itype"); + lua_pushnumber(L,lua_tag(L,1)); + lua_gettable(L,-2); + lua_getglobal(L,lua_tostring(L,-1)); + lua_pushstring(L,".array"); + lua_gettable(L,-2); + lua_pushvalue(L,2); /* field */ + lua_gettable(L,-2); + lua_pushstring(L,".self"); + lua_pushvalue(L,1); /* self */ + lua_rawset(L,-3); + return 1; +} + +static int toluaI_const_array (lua_State* L) +{ + lua_error(L,"value of const field cannot be changed"); + return 0; +} + +void tolua_tablearray +(lua_State* L, char* table, char* name, lua_CFunction get, lua_CFunction set) +{ + int tag = lua_newtag(L); + lua_getglobal(L,table); + lua_pushstring(L,".array"); + lua_rawget(L,-2); + lua_pushstring(L,name); + lua_newtable(L); + lua_settag(L,tag); + lua_settable(L,-3); + lua_pop(L,2); + + lua_pushcfunction(L,get); + lua_settagmethod(L,tag,"gettable"); + if (set) + lua_pushcfunction(L,set); + else + lua_pushcfunction(L,toluaI_const_array); + lua_settagmethod(L,tag,"settable"); + + tolua_tablevar(L,table,name,toluaI_get_array,NULL); +} + +void tolua_module (lua_State* L, char* name) +{ + lua_getglobal(L,name); + if (!lua_istable(L,-1)) + { + lua_newtable(L); + lua_pushstring(L,".get"); + lua_newtable(L); + lua_settable(L,-3); + lua_pushstring(L,".set"); + lua_newtable(L); + lua_settable(L,-3); + lua_pushvalue(L,-1); /* duplicate top */ + lua_setglobal(L,name); + toluaI_tm_module(L,lua_gettop(L)); + lua_pop(L,1); + } + lua_pop(L,1); +} + +void tolua_cclass (lua_State* L, char* name, char* base) +{ + int t; + lua_newtable(L); + lua_pushstring(L,".get"); + lua_newtable(L); + lua_settable(L,-3); + lua_pushstring(L,".set"); + lua_newtable(L); + lua_settable(L,-3); + lua_pushstring(L,".array"); + lua_newtable(L); + lua_settable(L,-3); + if (*base != 0) + { + lua_pushstring(L,".base"); + lua_getglobal(L,base); + lua_rawset(L,-3); + } + lua_pushvalue(L,-1); /* duplicate top */ + lua_setglobal(L,name); + t = lua_gettop(L); + toluaI_tm_class(L,t,name); + toluaI_tt_class(L,t,name,base); + lua_pop(L,1); +} + + +void tolua_function (lua_State* L, char* parent, char* name, lua_CFunction func) +{ + if (parent==NULL) + { + lua_pushcfunction(L,func); + lua_setglobal(L,name); + } + else + { + lua_getglobal(L,parent); + lua_pushstring(L,name); + lua_pushcfunction(L,func); + lua_settable(L,-3); + lua_pop(L,1); + } +} + +void tolua_constant (lua_State* L, char* parent, char* name, long value) +{ + if (parent==NULL) + { + lua_pushnumber(L,value); + lua_setglobal(L,name); + } + else + { + lua_getglobal(L,parent); + lua_pushstring(L,name); + lua_pushnumber(L,value); + lua_settable(L,-3); + lua_pop(L,1); + } +} + +void toluaI_setregistry (lua_State* L, char* field) +{ + lua_getregistry(L); + lua_insert(L,-2); + lua_pushstring(L,field); + lua_insert(L,-2); + lua_settable(L,-3); + lua_pop(L,1); +} + +void toluaI_getregistry (lua_State* L, char* field) +{ + lua_getregistry(L); + lua_pushstring(L,field); + lua_gettable(L,-2); + lua_insert(L,-2); + lua_pop(L,1); +} diff --git a/src/lua/tolua_rg.h b/src/lua/tolua_rg.h new file mode 100644 index 00000000..0feb6078 --- /dev/null +++ b/src/lua/tolua_rg.h @@ -0,0 +1,22 @@ +/* tolua: register functions +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Nov 200 +** $Id: tolua_rg.h,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + + +#ifndef tolua_rg_h +#define tolua_rg_h + +void toluaI_setregistry (lua_State* L, char* field); +void toluaI_getregistry (lua_State* L, char* field); + +#endif diff --git a/src/lua/tolua_tm.c b/src/lua/tolua_tm.c new file mode 100644 index 00000000..8fd7b28d --- /dev/null +++ b/src/lua/tolua_tm.c @@ -0,0 +1,585 @@ +/* tolua: tag methods +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_tm.c,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + +#include "tolua.h" +#include "tolua_tm.h" +#include "tolua_tt.h" +#include "tolua_rg.h" + +#include <string.h> + + + +/* Global tables created in Lua registry: + tolua_tbl_class: indexed by instance tags, stores the class tables. + tolua_tbl_clone: indexed by memory address, stores the tag indicanting + it is a clone. + tolua_tbl_mate: indexed by memory address, stores the associate instance + table. + + General tags stored in Lua registry: + tolua_tag_global; + tolua_tag_module; + tolua_tag_class; + tolua_tag_instance; + tolua_tag_linstance; + tolua_tag_indirect; +*/ + +/* internal function prototype */ +static void setmethods (lua_State* L); + +static void settag (lua_State* L, int lo, char* tag_registry_field) +{ + toluaI_getregistry(L,tag_registry_field); + lua_pushvalue(L,lo); + lua_settag(L,(int)lua_tonumber(L,-2)); + lua_pop(L,2); +} + +void toluaI_tm_global (lua_State* L, int lo) +{ + settag(L,lo,"tolua_tag_global"); +} + +void toluaI_tm_module (lua_State* L, int lo) +{ + settag(L,lo,"tolua_tag_module"); +} + +void toluaI_tm_setclass (lua_State* L, int lo) +{ + settag(L,lo,"tolua_tag_class"); +} + +void toluaI_tm_class (lua_State* L, int lo, char* name) +{ + int tag_class; + int tag = lua_newtag(L); + char* type = toluaI_tt_concat("class ",name); + toluaI_getregistry(L,"tolua_tag_class"); + tag_class = (int)lua_tonumber(L,-1); + lua_copytagmethods(L,tag,tag_class); + toluaI_tt_register(L,tag,type); + toluaI_tt_sethierarchy(L,tag,tag_class); + lua_pushvalue(L,lo); + lua_settag(L,tag); + lua_pop(L,2); /* tag_class and lo */ +} + +void toluaI_tm_instance (lua_State* L, int tag, int lo) +{ + toluaI_getregistry(L,"tolua_tbl_class"); + lua_pushnumber(L,tag); + lua_pushvalue(L,lo); + lua_settable(L,-3); + toluaI_getregistry(L,"tolua_tag_instance"); + lua_copytagmethods(L,tag,(int)lua_tonumber(L,-1)); + lua_pop(L,2); /* tbl_class and tag_instance */ +} + +void toluaI_tm_linstance (lua_State* L, int tag, int lo) +{ + toluaI_getregistry(L,"tolua_tbl_class"); + lua_pushnumber(L,tag); + lua_pushvalue(L,lo); + lua_settable(L,-3); + toluaI_getregistry(L,"tolua_tag_linstance"); + lua_copytagmethods(L,tag,(int)lua_tonumber(L,-1)); + lua_pop(L,2); /* tbl_class and tag_linstance */ +} + +void* tolua_doclone (lua_State* L, void* value, int tag) +{ + toluaI_getregistry(L,"tolua_tbl_clone"); + lua_pushuserdata(L,value); + lua_pushnumber(L,tag); + lua_settable(L,-3); + lua_pop(L,1); + return value; +} + +void* tolua_copy (lua_State* L, void* value, unsigned int size) +{ + void* clone = (void*)malloc(size); + if (clone) + memcpy(clone,value,size); + else + tolua_error(L,"insuficient memory"); + return clone; +} + +static void toluaI_tm_undoclone (lua_State* L, int tag, void* clone) +{ + toluaI_getregistry(L,"tolua_tbl_clone"); + lua_pushuserdata(L,clone); + lua_gettable(L,-2); + if (lua_isnumber(L,-1) && lua_tonumber(L,-1)==tag) + { + lua_pushuserdata(L,clone); + lua_pushnil(L); + lua_settable(L,-4); + + /* get base class */ + toluaI_getregistry(L,"tolua_tbl_class"); + lua_pushnumber(L,tag); + lua_rawget(L,-2); + + /* look for destructor */ + lua_pushstring(L,"delete"); + lua_gettable(L,-2); + if (lua_iscfunction(L,-1)) + { + lua_pushusertag(L,clone,tag); + lua_call(L,1,0); + } + else + { + free(clone); /* no destructor: use raw free */ + lua_pop(L,1); /* the nil function value */ + } + lua_pop(L,2); /* tbl_class and class method table */ + } + lua_pop(L,2); /* table and value */ +} + +void toluaI_tm_pushmate (lua_State* L, int lo) +{ + toluaI_getregistry(L,"tolua_tbl_mate"); + lua_pushvalue(L,lo); + lua_rawget(L,-2); + lua_insert(L,-2); + lua_pop(L,1); +} + +void toluaI_tm_pushclass (lua_State* L, int lo) +{ + toluaI_getregistry(L,"tolua_tbl_class"); + lua_pushnumber(L,lua_tag(L,lo)); + lua_rawget(L,-2); + lua_insert(L,-2); + lua_pop(L,1); +} + +int toluaI_gettag (lua_State* L, char* tagname) +{ + int tag; + toluaI_getregistry(L,tagname); + tag = (int)lua_tonumber(L,-1); + lua_pop(L,1); + return tag; +} + +void toluaI_tm_init (lua_State* L) +{ + lua_newtable(L); toluaI_setregistry(L,"tolua_tbl_class"); + lua_newtable(L); toluaI_setregistry(L,"tolua_tbl_clone"); + lua_newtable(L); toluaI_setregistry(L,"tolua_tbl_mate"); + + lua_pushnumber(L,lua_newtag(L)); toluaI_setregistry(L,"tolua_tag_global"); + lua_pushnumber(L,lua_newtag(L)); toluaI_setregistry(L,"tolua_tag_module"); + lua_pushnumber(L,lua_newtag(L)); toluaI_setregistry(L,"tolua_tag_class"); + lua_pushnumber(L,lua_newtag(L)); toluaI_setregistry(L,"tolua_tag_instance"); + lua_pushnumber(L,lua_newtag(L)); toluaI_setregistry(L,"tolua_tag_linstance"); + lua_pushnumber(L,lua_newtag(L)); toluaI_setregistry(L,"tolua_tag_indirect"); + + toluaI_tt_register(L,toluaI_gettag(L,"tolua_tag_global"),"generic variable"); + toluaI_tt_register(L,toluaI_gettag(L,"tolua_tag_module"),"generic module"); + toluaI_tt_register(L,toluaI_gettag(L,"tolua_tag_class"),"generic class"); + toluaI_tt_register(L,toluaI_gettag(L,"tolua_tag_indirect"),"generic indirect"); + toluaI_tt_register(L,toluaI_gettag(L,"tolua_tag_instance"),"generic instance"); + toluaI_tt_register(L,toluaI_gettag(L,"tolua_tag_linstance"),"generic lua instance"); + + /* allows modules and classes to be used as ordinary tables */ + toluaI_tt_sethierarchy(L,toluaI_gettag(L,"tolua_tag_module"),tolua_tag_table); + toluaI_tt_sethierarchy(L,toluaI_gettag(L,"tolua_tag_class"),tolua_tag_table); + + setmethods(L); +} + +static int map (lua_State* L) +{ + int m = lua_gettop(L); + /* do not pass string fields starting with a dot */ + if (!lua_isstring(L,1) || *lua_tostring(L,1)!='.') + { + lua_getglobals(L); + lua_pushvalue(L,1); + lua_pushvalue(L,m); + lua_rawset(L,-3); + lua_pop(L,1); + } + return 0; +} + +void toluaI_tm_using (lua_State* L, int module) +{ + lua_newtable(L); + lua_settag(L,toluaI_gettag(L,"tolua_tag_indirect")); + lua_pushstring(L,".module"); + lua_pushvalue(L,module); + lua_settable(L,-3); + + lua_getglobal(L,"foreach"); + lua_pushvalue(L,module); + lua_pushvalue(L,-3); + lua_pushcclosure(L,map,1); + lua_call(L,2,0); + + lua_getglobal(L,"foreach"); + lua_pushvalue(L,module); + lua_pushstring(L,".get"); + lua_gettable(L,-2); + lua_insert(L,-2); + lua_pop(L,1); /* module table */ + lua_pushvalue(L,-3); + lua_pushcclosure(L,map,1); + lua_call(L,2,0); + lua_pop(L,1); /* indirect table */ +} + +/********************************************************** tag methods */ + +/* tag methods coded in C */ + +/* generic gettable */ +static void oo_gettable (lua_State* L, int table, int base, int index) +{ + while (lua_istable(L,base)) + { + lua_pushvalue(L,index); + lua_rawget(L,base); + if (!lua_isnil(L,-1)) + return; /* returned value already on the top */ + else if (lua_isnumber(L,index)) + { + lua_pushstring(L,"operator_get"); + lua_rawget(L,base); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,table); + lua_pushvalue(L,index); + lua_call(L,2,1); + return; + } + } + else + { + lua_pushstring(L,".get"); + lua_rawget(L,base); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,index); + lua_rawget(L,-2); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,table); + lua_pushvalue(L,index); /* need to access array field (?) */ + lua_call(L,2,1); + return; + } + } + } + lua_pushstring(L,".base"); lua_rawget(L,base); + base = lua_gettop(L); + } + lua_pushnil(L); +} + +/* generic settable */ +static int oo_settable (lua_State* L, int table, int base, int index, int value) +{ + while (lua_istable(L,base)) + { + lua_pushstring(L,".set"); + lua_rawget(L,base); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,index); + lua_rawget(L,-2); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,table); + lua_pushvalue(L,value); + lua_call(L,2,0); + return 1; + } + } + lua_pushstring(L,".base"); lua_rawget(L,base); + base = lua_gettop(L); + } + return 0; +} + +/* class tag methods */ +static int class_index (lua_State* L) +{ + int table = 1; + int index = 2; + oo_gettable(L,table,table,index); + return 1; +} +static int class_settable (lua_State* L) +{ + int table = 1; + int index = 2; + int value = 3; + if (oo_settable(L,table,table,index,value) == 0) + { + lua_pushvalue(L,table); + lua_pushvalue(L,index); + lua_pushvalue(L,value); + lua_rawset(L,-3); + } + return 0; +} + +/* instance tags */ +static int instance_gettable (lua_State* L) +{ + int table = 1; + int index = 2; + toluaI_tm_pushmate(L,table); /* pushes mate */ + if (!lua_isnil(L,-1)) /* if there's a mate table */ + { + lua_pushvalue(L,index); + lua_rawget(L,-2); + if (!lua_isnil(L,-1)) /* if field in mate table exists */ + return 1; + } + toluaI_tm_pushclass(L,table); /* pushes base */ + oo_gettable(L,table,lua_gettop(L),index); + return 1; +} +static int instance_settable (lua_State* L) +{ + int table = 1; + int index = 2; + int value = 3; + toluaI_tm_pushclass(L,table); /* pushes base */ + if (lua_isnumber(L,index)) + { + lua_pushstring(L,"operator_set"); + lua_rawget(L,-2); + if (!lua_isnil(L,-1)) + {/* the stack here is: table,index,value,base,operator */ + /* call operator passing table, index, and value */ + lua_insert(L,1); + lua_pop(L,1); /* base */ + lua_call(L,3,0); + return 0; + } + } + if (oo_settable(L,table,4,index,value) == 0) + { + toluaI_tm_pushmate(L,table); /* pushes mate */ + if (lua_isnil(L,-1)) + { + /* creates mate table */ + lua_newtable(L); + toluaI_getregistry(L,"tolua_tbl_mate"); + lua_pushvalue(L,table); /* that is the userdata */ + lua_pushvalue(L,-3); + lua_rawset(L,-3); + lua_pop(L,1); /* tbl_mate */ + } + /* the mate table is on the top */ + lua_pushvalue(L,index); + lua_pushvalue(L,value); + lua_rawset(L,-3); + } + return 0; +} +static int instance_gc (lua_State* L) +{ + toluaI_tm_undoclone(L,lua_tag(L,1),lua_touserdata(L,1)); + return 0; +} +static int gen_operator (lua_State* L) +{ + int op1 = 1; + int op2 = 2; + int event = 3; + char* name = toluaI_tt_concat("operator_",lua_tostring(L,event)); + lua_pushstring(L,name); + lua_gettable(L,op1); + lua_pushvalue(L,op1); + lua_pushvalue(L,op2); + lua_call(L,2,1); + return 1; +} +static int instance_operator (lua_State* L) +{ + return gen_operator(L); +} +static int instance_relational (lua_State* L) +{ + gen_operator(L); + if ((int)lua_tonumber(L,-1)==0) lua_pushnil(L); + return 1; +} + +/* lua instance tags */ +static int linstance_index (lua_State* L) +{ + toluaI_tm_pushclass(L,1); + oo_gettable(L,1,3,2); /* table,base,index */ + return 1; +} + + +/* module tag methods */ +static int module_index (lua_State* L) +{ + int table = 1; + int index = 2; + lua_pushstring(L,".get"); + lua_rawget(L,table); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,index); + lua_rawget(L,-2); + if (!lua_isnil(L,-1)) + { + lua_call(L,0,1); + return 1; + } + } + lua_pushnil(L); + return 1; +} +static int module_settable (lua_State* L) +{ + int table = 1; + int index = 2; + int value = 3; + lua_pushstring(L,".set"); + lua_rawget(L,table); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,index); + lua_rawget(L,-2); + if (!lua_isnil(L,-1)) + { + lua_pushvalue(L,value); + lua_call(L,1,0); + return 0; + } + } + lua_pushvalue(L,index); + lua_pushvalue(L,value); + lua_rawset(L,table); + return 0; +} + +/* global variable tag methods */ +static int global_getglobal (lua_State* L) +{ + int value = 2; + lua_pushstring(L,".get"); + lua_rawget(L,value); + lua_call(L,0,1); + return 1; +} +static int global_setglobal (lua_State* L) +{ + int value = 2; + int newvalue = 3; + lua_pushstring(L,".set"); + lua_rawget(L,value); + if (lua_isnil(L,-1)) + lua_error(L,"value of const variable cannot be changed"); + else + { + lua_pushvalue(L,newvalue); + lua_call(L,1,0); + } + return 0; +} + +/* indirect tag methods */ +static int indirect_getglobal (lua_State* L) +{ + int varname = 1; + int value = 2; + lua_pushstring(L,".module"); + lua_gettable(L,value); + lua_pushvalue(L,varname); + lua_gettable(L,-2); + return 1; +} +static int indirect_setglobal (lua_State* L) +{ + int varname = 1; + int value = 2; + int newvalue = 3; + lua_pushstring(L,".module"); + lua_gettable(L,value); + lua_pushvalue(L,varname); + lua_pushvalue(L,newvalue); + lua_settable(L,-3); + return 0; +} + +static void setmethods (lua_State* L) +{ + /* global variable */ + lua_pushcfunction(L,global_getglobal); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_global"),"getglobal"); + lua_pushcfunction(L,global_setglobal); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_global"),"setglobal"); + + /* module */ + lua_pushcfunction(L,module_index); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_module"),"index"); + lua_pushcfunction(L,module_settable); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_module"),"settable"); + + /* class */ + lua_pushcfunction(L,class_index); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_class"),"index"); + lua_pushcfunction(L,class_settable); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_class"),"settable"); + + /* instance */ + lua_pushcfunction(L,instance_gettable); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"gettable"); + lua_pushcfunction(L,instance_settable); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"settable"); + lua_pushcfunction(L,instance_operator); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"add"); + lua_pushcfunction(L,instance_operator); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"sub"); + lua_pushcfunction(L,instance_operator); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"mul"); + lua_pushcfunction(L,instance_operator); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"div"); + lua_pushcfunction(L,instance_relational); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"lt"); + lua_pushcfunction(L,instance_gc); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_instance"),"gc"); + + /* lua instance */ + lua_pushcfunction(L,linstance_index); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_linstance"),"index"); + + /* indirect */ + lua_pushcfunction(L,indirect_getglobal); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_indirect"),"getglobal"); + lua_pushcfunction(L,indirect_setglobal); + lua_settagmethod(L,toluaI_gettag(L,"tolua_tag_indirect"),"setglobal"); +} + + + diff --git a/src/lua/tolua_tm.h b/src/lua/tolua_tm.h new file mode 100644 index 00000000..c1bf06dc --- /dev/null +++ b/src/lua/tolua_tm.h @@ -0,0 +1,32 @@ +/* tolua: tag methods +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_tm.h,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + + + +#ifndef tolua_tm_h +#define tolua_tm_h + +void toluaI_tm_init (lua_State* L); +void toluaI_tm_global (lua_State* L, int lo); +void toluaI_tm_module (lua_State* L, int lo); +void toluaI_tm_class (lua_State* L, int lo, char* name); +void toluaI_tm_instance (lua_State* L, int tag, int lo); +void toluaI_tm_linstance (lua_State* L, int tag, int lo); +void toluaI_tm_using (lua_State* L, int module); +void toluaI_tm_setclass (lua_State* L, int lo); +void toluaI_tm_pushmate (lua_State* L, int lo); +void toluaI_tm_pushclass (lua_State* L, int lo); + + +#endif diff --git a/src/lua/tolua_tt.c b/src/lua/tolua_tt.c new file mode 100644 index 00000000..33c384c6 --- /dev/null +++ b/src/lua/tolua_tt.c @@ -0,0 +1,316 @@ +/* tolua: type & tag manipulation. +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_tt.c,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + +#include "tolua.h" +#include "tolua_tt.h" +#include "tolua_tm.h" +#include "tolua_eh.h" +#include "tolua_rg.h" + +#include <stdio.h> +#include <string.h> +#include <assert.h> + +/* Global tables created in Lua registry: + tolua_tbl_itype: indexed by instance tags, stores the instance types. + tolua_tbl_itag: indexed by instance types, stores the instance tags. + tolua_tbl_const: indexed by constant tags, stores the tags. + tolua_tbl_hierarchy: indexed by instance tags, stores the base tags. +*/ + +/* exported basic type tags */ +int tolua_tag_nil; +int tolua_tag_number; +int tolua_tag_string; +int tolua_tag_userdata; +int tolua_tag_table; +int tolua_tag_function; + + +static const char* gettype (lua_State* L, int tag) +{ + const char* type; + toluaI_getregistry(L,"tolua_tbl_itype"); + lua_pushnumber(L,tag); + lua_gettable(L,-2); + type = lua_tostring(L,-1); + if (type==NULL) type = "[undefined]"; + lua_pop(L,2); + return type; +} + +const char* toluaI_tt_getobjtype (lua_State* L, int lo) +{ + if (lua_gettop(L)<abs(lo)) + return "[no object]"; + else + return gettype(L,lua_tag(L,lo)); +} + +int toluaI_tt_gettag (lua_State* L, char* type) +{ + int tag; + toluaI_getregistry(L,"tolua_tbl_itag"); + lua_pushstring(L,type); + lua_gettable(L,-2); + tag = (int)lua_tonumber(L,-1); + lua_pop(L,2); + return tag; +} + +static int basetag (lua_State* L, int hierarchy, int tag) +{ + int btag; + lua_pushnumber(L,tag); + lua_gettable(L,hierarchy); + btag = (int)lua_tonumber(L,-1); + lua_pop(L,1); + return btag; +} + +static int istype (lua_State* L, int lo, int tag) +{ + int otag = lua_tag(L,lo); + if (tag==otag) /* check simplest case */ + return 1; + else if (lua_isnil(L,lo) && + tag!=LUA_TNUMBER && + tag!=LUA_TTABLE && + tag!=LUA_TFUNCTION + ) + return 1; + else if ((tag==LUA_TSTRING && lua_isstring(L,lo)) || /* check convertions */ + (tag==LUA_TNUMBER && lua_isnumber(L,lo)) + ) + return 1; + else if (tag==LUA_TUSERDATA && lua_isuserdata(L,lo)) /* pointer to void* */ + return 1; + else if (tag==toluaI_tt_gettag(L,"bool") && otag==LUA_TNUMBER) + return 1; + else + { + /* if requested type is const, the non-const is an alternative type */ + int tag2; + int tbl_hierarchy; + toluaI_getregistry(L,"tolua_tbl_const"); + lua_pushnumber(L,tag); + lua_gettable(L,-2); + tag2 = (int)lua_tonumber(L,-1); + lua_pop(L,2); + if (tag2 && tag2==otag) + return 1; + /* check for base classes */ + toluaI_getregistry(L,"tolua_tbl_hierarchy"); + tbl_hierarchy = lua_gettop(L); + otag = basetag(L,tbl_hierarchy,otag); + while (otag) + { + if (tag==otag || (tag2 && tag2==otag)) + break; + otag = basetag(L,tbl_hierarchy,otag); + } + lua_pop(L,1); + return otag!=0; + } +} + +void toluaI_tt_init (lua_State* L) +{ + lua_newtable(L); toluaI_setregistry(L,"tolua_tbl_itype"); + lua_newtable(L); toluaI_setregistry(L,"tolua_tbl_itag"); + lua_newtable(L); toluaI_setregistry(L,"tolua_tbl_const"); + lua_newtable(L); toluaI_setregistry(L,"tolua_tbl_hierarchy"); + + /* set and register basic Lua type tag */ +#if 0 + lua_pushnumber(L,LUA_TNIL); toluaI_setregistry(L,"tolua_tag_nil"); + lua_pushnumber(L,LUA_TNUMBER); toluaI_setregistry(L,"tolua_tag_number"); + lua_pushnumber(L,LUA_TSTRING); toluaI_setregistry(L,"tolua_tag_string"); + lua_pushnumber(L,LUA_TUSERDATA); toluaI_setregistry(L,"tolua_tag_userdata"); + lua_pushnumber(L,LUA_TTABLE); toluaI_setregistry(L,"tolua_tag_table"); + lua_pushnumber(L,LUA_TFUNCTION); toluaI_setregistry(L,"tolua_tag_function"); + + toluaI_tt_register(L,toluaI_tt_gettag(L,"tolua_tag_nil"),"nil"); + toluaI_tt_register(L,toluaI_tt_gettag(L,"tolua_tag_number"),"number"); + toluaI_tt_register(L,toluaI_tt_gettag(L,"tolua_tag_string"),"string"); + toluaI_tt_register(L,toluaI_tt_gettag(L,"tolua_tag_userdata"),"userdata"); + toluaI_tt_register(L,toluaI_tt_gettag(L,"tolua_tag_table"),"table"); + toluaI_tt_register(L,toluaI_tt_gettag(L,"tolua_tag_function"),"function"); +#else + toluaI_tt_register(L,LUA_TNIL,"nil"); + toluaI_tt_register(L,LUA_TNUMBER,"number"); + toluaI_tt_register(L,LUA_TSTRING,"string"); + toluaI_tt_register(L,LUA_TUSERDATA,"userdata"); + toluaI_tt_register(L,LUA_TTABLE,"table"); + toluaI_tt_register(L,LUA_TFUNCTION,"function"); + toluaI_tt_register(L,lua_newtag(L),"bool"); +#endif +} + + +void toluaI_tt_register (lua_State* L, int tag, char* type) +{ + toluaI_getregistry(L,"tolua_tbl_itype"); + lua_pushnumber(L,tag); + lua_pushstring(L,type); + lua_settable(L,-3); + + toluaI_getregistry(L,"tolua_tbl_itag"); + lua_pushstring(L,type); + lua_pushnumber(L,tag); + lua_settable(L,-3); + + lua_pop(L,2); +} + + +void toluaI_tt_class (lua_State* L, int lo, char* derived, char* base) +{ + char* cderived = toluaI_tt_concat("const ",derived); + int tag = toluaI_tt_gettag(L,derived); + int ctag = toluaI_tt_gettag(L,cderived); + toluaI_tm_instance(L,tag,lo); + toluaI_tm_instance(L,ctag,lo); + if (*base != 0) + { + char* cbase = toluaI_tt_concat("const ",base); + int btag = toluaI_tt_gettag(L,base); + int cbtag = toluaI_tt_gettag(L,cbase); + toluaI_tt_sethierarchy(L,tag,btag); + toluaI_tt_sethierarchy(L,ctag,cbtag); + } +} + +void toluaI_tt_sethierarchy (lua_State* L, int tag, int btag) +{ + toluaI_getregistry(L,"tolua_tbl_hierarchy"); + lua_pushnumber(L,tag); + lua_pushnumber(L,btag); + lua_settable(L,-3); + lua_pop(L,1); +} + +char* toluaI_tt_concat (const char* s1, const char* s2) +{ + static char s[BUFSIZ]; + assert(strlen(s1)+strlen(s2)<BUFSIZ); + return strcat(strcpy(s,s1),s2); +} + +void tolua_usertype (lua_State* L, char* type) +{ + /* check if type is already registered */ + toluaI_getregistry(L,"tolua_tbl_itag"); + lua_pushstring(L,type); + lua_gettable(L,-2); + if (lua_isnil(L,-1)) + { + char *ctype = toluaI_tt_concat("const ",type); + int tag = lua_newtag(L); + int ctag = lua_newtag(L); + toluaI_tt_register(L,tag,type); + toluaI_tt_register(L,ctag,ctype); + /* set const table */ + toluaI_getregistry(L,"tolua_tbl_const"); + lua_pushnumber(L,ctag); + lua_pushnumber(L,tag); + lua_settable(L,-3); + lua_pop(L,1); + } + lua_pop(L,2); +} + +int toluaI_tt_isusertype (lua_State* L, int lo) +{ + if (lua_isuserdata(L,lo) && + toluaI_tt_gettag(L,"tolua_tag_userdata")!=lua_tag(L,lo) + ) + { + int status; + toluaI_getregistry(L,"tolua_tbl_itype"); + lua_pushnumber(L,lua_tag(L,lo)); + lua_gettable(L,-2); + status = !lua_isnil(L,-1); + lua_pop(L,2); + return status; + } + return 0; +} + +#if 0 +void tolua_settag (lua_State* L, char* type, int* tag) +{ + toluaI_getregistry(L,"tolua_tbl_itag"); + lua_pushstring(L,type); + lua_gettable(L,-2); + *tag = (int) lua_tonumber(L,-1); + lua_pop(L,2); +} +#endif + +int tolua_istype (lua_State* L, int narg, int tag, int def) +{ + if (lua_gettop(L)<abs(narg)) + { + if (def==0) + { + toluaI_eh_set(L,narg,toluaI_tt_getobjtype(L,narg),gettype(L,tag)); + return 0; + } + } + else + { + if (!istype(L,narg,tag)) + { + toluaI_eh_set(L,narg,toluaI_tt_getobjtype(L,narg),gettype(L,tag)); + return 0; + } + } + return 1; +} + +int tolua_arrayistype (lua_State* L, int narg, int tag, int dim, int def) +{ + int i; + for (i=0; i<dim; ++i) + { + int tf; + lua_pushnumber(L,i+1); + lua_gettable(L,narg); + tf = lua_gettop(L); + if (!istype(L,tf,tag) && (!def || !lua_isnil(L,tf))) + { + static char t1[BUFSIZ], t2[BUFSIZ]; + sprintf(t1,"array of %s",toluaI_tt_getobjtype(L,tf)); + sprintf(t2,"array of %s (dimension=%d)",gettype(L,tag),dim); + toluaI_eh_set(L,narg,t1,t2); + return 0; + } + lua_pop(L,1); + } + return 1; +} + +int tolua_isnoobj (lua_State* L, int narg) +{ + if (lua_gettop(L)>=abs(narg)) + { + toluaI_eh_set(L,narg,toluaI_tt_getobjtype(L,narg), + toluaI_tt_getobjtype(L,lua_gettop(L)+1)); + return 0; + } + return 1; +} + + diff --git a/src/lua/tolua_tt.h b/src/lua/tolua_tt.h new file mode 100644 index 00000000..941a2b02 --- /dev/null +++ b/src/lua/tolua_tt.h @@ -0,0 +1,31 @@ +/* tolua: type & tag manipulation. +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Jul 1998 +** $Id: tolua_tt.h,v 1.2 2001/11/26 23:00:27 darkgod Exp $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + + +#ifndef tolua_tt_h +#define tolua_tt_h + +void toluaI_tt_init (lua_State* L); +void toluaI_tt_register (lua_State* L, int tag, char* type); +void toluaI_tt_class (lua_State* L, int lo, char* derived, char* base); +void toluaI_tt_sethierarchy (lua_State* L, int tag, int btag); +int toluaI_tt_isusertype (lua_State* L, int lo); +int toluaI_tt_gettag (lua_State* L, char* type); +const char* toluaI_tt_getobjtype (lua_State* L, int lo); +char* toluaI_tt_concat (const char* s1, const char* s2); + + + + +#endif diff --git a/src/lua/tolualua.c b/src/lua/tolualua.c new file mode 100644 index 00000000..adbb8635 --- /dev/null +++ b/src/lua/tolualua.c @@ -0,0 +1,2975 @@ +/* +** Lua binding: tolualua +** Generated automatically by tolua 4.0a - angband on Sun Nov 11 22:59:08 2001. +*/ + +#include "tolua.h" + +/* Exported function */ +int tolua_tolualua_open (lua_State* tolua_S); +void tolua_tolualua_close (lua_State* tolua_S); + + +/* function to register type */ +static void toluaI_reg_types (lua_State* tolua_S) +{ +} + +/* error messages */ +#define TOLUA_ERR_SELF tolua_error(tolua_S,"invalid 'self'") +#define TOLUA_ERR_ASSIGN tolua_error(tolua_S,"#vinvalid type in variable assignment.") + +/* Open function */ +int tolua_tolualua_open (lua_State* tolua_S) +{ + tolua_open(tolua_S); + toluaI_reg_types(tolua_S); + + { /* begin embedded lua code */ + static unsigned char B[] = { + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 95, 98, 97,115,105, 99, 32, 61, 32,123, 10, 91, 39,118, + 111,105,100, 39, 93, 32, 61, 32, 39, 39, 44, 10, 91, 39, 99, + 104, 97,114, 39, 93, 32, 61, 32, 39,110,117,109, 98,101,114, + 39, 44, 10, 91, 39,105,110,116, 39, 93, 32, 61, 32, 39,110, + 117,109, 98,101,114, 39, 44, 10, 91, 39,115,104,111,114,116, + 39, 93, 32, 61, 32, 39,110,117,109, 98,101,114, 39, 44, 10, + 91, 39,108,111,110,103, 39, 93, 32, 61, 32, 39,110,117,109, + 98,101,114, 39, 44, 10, 91, 39, 95, 99,115,116,114,105,110, + 103, 39, 93, 32, 61, 32, 39,115,116,114,105,110,103, 39, 44, + 10, 91, 39, 95,117,115,101,114,100, 97,116, 97, 39, 93, 32, + 61, 32, 39,117,115,101,114,100, 97,116, 97, 39, 44, 10, 91, + 39, 99,104, 97,114, 42, 39, 93, 32, 61, 32, 39,115,116,114, + 105,110,103, 39, 44, 10, 91, 39,118,111,105,100, 42, 39, 93, + 32, 61, 32, 39,117,115,101,114,100, 97,116, 97, 39, 44, 10, + 91, 39, 98,111,111,108, 39, 93, 32, 61, 32, 39, 98,111,111, + 108, 39, 44, 10, 91, 39, 76, 85, 65, 95, 86, 65, 76, 85, 69, + 39, 93, 32, 61, 32, 39,118, 97,108,117,101, 39, 44, 10, 91, + 39, 98,121,116,101, 39, 93, 32, 61, 32, 39,110,117,109, 98, + 101,114, 39, 44, 10, 91, 39,115, 49, 54, 98, 39, 93, 32, 61, + 32, 39,110,117,109, 98,101,114, 39, 44, 10, 91, 39,117, 49, + 54, 98, 39, 93, 32, 61, 32, 39,110,117,109, 98,101,114, 39, + 44, 10, 91, 39,115, 51, 50, 98, 39, 93, 32, 61, 32, 39,110, + 117,109, 98,101,114, 39, 44, 10, 91, 39,117, 51, 50, 98, 39, + 93, 32, 61, 32, 39,110,117,109, 98,101,114, 39, 44, 10,125, + 10, 10, 95, 98, 97,115,105, 99, 95,116, 97,103, 32, 61, 32, + 123, 10, 91, 39,118,111,105,100, 39, 93, 32, 61, 32, 39, 39, + 44, 10, 91, 39, 99,104, 97,114, 39, 93, 32, 61, 32, 39, 76, + 85, 65, 95, 84, 78, 85, 77, 66, 69, 82, 39, 44, 10, 91, 39, + 105,110,116, 39, 93, 32, 61, 32, 39, 76, 85, 65, 95, 84, 78, + 85, 77, 66, 69, 82, 39, 44, 10, 91, 39,115,104,111,114,116, + 39, 93, 32, 61, 32, 39, 76, 85, 65, 95, 84, 78, 85, 77, 66, + 69, 82, 39, 44, 10, 91, 39,108,111,110,103, 39, 93, 32, 61, + 32, 39, 76, 85, 65, 95, 84, 78, 85, 77, 66, 69, 82, 39, 44, + 10, 91, 39, 95, 99,115,116,114,105,110,103, 39, 93, 32, 61, + 32, 39, 76, 85, 65, 95, 84, 83, 84, 82, 73, 78, 71, 39, 44, + 10, 91, 39, 95,117,115,101,114,100, 97,116, 97, 39, 93, 32, + 61, 32, 39, 76, 85, 65, 95, 84, 85, 83, 69, 82, 68, 65, 84, + 65, 39, 44, 10, 91, 39, 99,104, 97,114, 42, 39, 93, 32, 61, + 32, 39, 76, 85, 65, 95, 84, 83, 84, 82, 73, 78, 71, 39, 44, + 10, 91, 39,118,111,105,100, 42, 39, 93, 32, 61, 32, 39, 76, + 85, 65, 95, 84, 85, 83, 69, 82, 68, 65, 84, 65, 39, 44, 10, + 91, 39, 98,111,111,108, 39, 93, 32, 61, 32, 39,116,111,108, + 117, 97, 95,116, 97,103, 40,116,111,108,117, 97, 95, 83, 44, + 34, 98,111,111,108, 34, 41, 39, 44, 10, 91, 39, 98,121,116, + 101, 39, 93, 32, 61, 32, 39, 76, 85, 65, 95, 84, 78, 85, 77, + 66, 69, 82, 39, 44, 10, 91, 39,115, 49, 54, 98, 39, 93, 32, + 61, 32, 39, 76, 85, 65, 95, 84, 78, 85, 77, 66, 69, 82, 39, + 44, 10, 91, 39,117, 49, 54, 98, 39, 93, 32, 61, 32, 39, 76, + 85, 65, 95, 84, 78, 85, 77, 66, 69, 82, 39, 44, 10, 91, 39, + 115, 51, 50, 98, 39, 93, 32, 61, 32, 39, 76, 85, 65, 95, 84, + 78, 85, 77, 66, 69, 82, 39, 44, 10, 91, 39,117, 51, 50, 98, + 39, 93, 32, 61, 32, 39, 76, 85, 65, 95, 84, 78, 85, 77, 66, + 69, 82, 39, 44, 10,125, 10, 10, 95, 98, 97,115,105, 99, 95, + 99,116,121,112,101, 32, 61, 32,123, 10,110,117,109, 98,101, + 114, 32, 61, 32, 34,108,111,110,103, 34, 44, 10,115,116,114, + 105,110,103, 32, 61, 32, 34, 99,111,110,115,116, 32, 99,104, + 97,114, 42, 34, 44, 10,117,115,101,114,100, 97,116, 97, 32, + 61, 32, 34,118,111,105,100, 42, 34, 44, 10, 98,111,111,108, + 32, 61, 32, 34,105,110,116, 34, 44, 10,125, 10, 10, 10, 10, + 95,117,115,101,114,116,121,112,101, 32, 61, 32,123,125, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32,116,111,108,117, + 97, 95,105,110,100,101,120, 32, 40,116, 44,102, 41, 10,105, + 102, 32,102, 32, 61, 61, 32, 39, 95, 98, 97,115,101, 39, 32, + 116,104,101,110, 10,114,101,116,117,114,110, 32,116,111,108, + 117, 97, 95,111,108,100, 95,105,110,100,101,120, 40,116, 44, + 102, 41, 10,101,108,115,101, 10,114,101,116,117,114,110, 32, + 116, 46, 95, 98, 97,115,101, 91,102, 93, 10,101,110,100, 10, + 101,110,100, 10, 10,116,111,108,117, 97, 95,116, 97,103, 32, + 61, 32,110,101,119,116, 97,103, 40, 41, 10,116,111,108,117, + 97, 95,111,108,100, 95,105,110,100,101,120, 32, 61, 32,115, + 101,116,116, 97,103,109,101,116,104,111,100, 40,116,111,108, + 117, 97, 95,116, 97,103, 44, 34,105,110,100,101,120, 34, 44, + 116,111,108,117, 97, 95,105,110,100,101,120, 41, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32,116,111,108,117, 97, 95, + 101,114,114,111,114, 32, 40,115, 41, 10,108,111, 99, 97,108, + 32,111,117,116, 32, 61, 32, 95, 79, 85, 84, 80, 85, 84, 10, + 95, 79, 85, 84, 80, 85, 84, 32, 61, 32, 95, 83, 84, 68, 69, + 82, 82, 10,105,102, 32,115,116,114,115,117, 98, 40,115, 44, + 49, 44, 49, 41, 32, 61, 61, 32, 39, 35, 39, 32,116,104,101, + 110, 10,119,114,105,116,101, 40, 34, 92,110, 42, 42, 32,116, + 111,108,117, 97, 58, 32, 34, 46, 46,115,116,114,115,117, 98, + 40,115, 44, 50, 41, 46, 46, 34, 46, 92,110, 92,110, 34, 41, + 10,101,108,115,101, 10,119,114,105,116,101, 40, 34, 92,110, + 42, 42, 32,116,111,108,117, 97, 32,105,110,116,101,114,110, + 97,108, 32,101,114,114,111,114, 58, 32, 34, 46, 46,115, 46, + 46, 34, 46, 92,110, 92,110, 34, 41, 10,114,101,116,117,114, + 110, 10,101,110,100, 10, 10,105,102, 32, 95, 99,117,114,114, + 95, 99,111,100,101, 32,116,104,101,110, 10,108,111, 99, 97, + 108, 32, 95, 44, 95, 44,115, 32, 61, 32,115,116,114,102,105, + 110,100, 40, 95, 99,117,114,114, 95, 99,111,100,101, 44, 34, + 94, 37,115, 42, 40, 46, 45, 92,110, 41, 34, 41, 10,105,102, + 32,115, 61, 61,110,105,108, 32,116,104,101,110, 32,115, 32, + 61, 32, 95, 99,117,114,114, 95, 99,111,100,101, 32,101,110, + 100, 10,115, 32, 61, 32,103,115,117, 98, 40,115, 44, 34, 95, + 117,115,101,114,100, 97,116, 97, 34, 44, 34,118,111,105,100, + 42, 34, 41, 10,115, 32, 61, 32,103,115,117, 98, 40,115, 44, + 34, 95, 99,115,116,114,105,110,103, 34, 44, 34, 99,104, 97, + 114, 42, 34, 41, 10,119,114,105,116,101, 40, 34, 67,111,100, + 101, 32, 98,101,105,110,103, 32,112,114,111, 99,101,115,115, + 101,100, 58, 92,110, 34, 46, 46,115, 46, 46, 34, 92,110, 34, + 41, 10,101,110,100, 10, 95, 79, 85, 84, 80, 85, 84, 32, 61, + 32,111,117,116, 10,101,110,100, 10, 10, 10, 95, 69, 82, 82, + 79, 82, 77, 69, 83, 83, 65, 71, 69, 32, 61, 32,116,111,108, + 117, 97, 95,101,114,114,111,114, 10, 10, 10,102,117,110, 99, + 116,105,111,110, 32,114,101,103,116,121,112,101, 32, 40,116, + 41, 10,105,102, 32,110,111,116, 32,105,115,116,121,112,101, + 40,116, 41, 32,116,104,101,110, 10, 95,117,115,101,114,116, + 121,112,101, 91,116, 93, 32, 61, 32,116, 10,101,110,100, 10, + 114,101,116,117,114,110, 32,116, 10,101,110,100, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32,116, 97,103,118, 97,114, + 40,116,121,112,101, 44, 99,111,110,115,116, 41, 10,105,102, + 32,116,121,112,101, 32, 61, 61, 32, 39, 39, 32,111,114, 32, + 116,121,112,101, 32, 61, 61, 32, 39,118,111,105,100, 39, 32, + 116,104,101,110, 10,114,101,116,117,114,110, 32,116,121,112, + 101, 44, 48, 10,101,108,115,101, 10,108,111, 99, 97,108, 32, + 109, 44,116, 32, 61, 32,102,105,110,100,116,121,112,101,100, + 101,102, 40,116,121,112,101, 41, 10,105,102, 32,105,115, 98, + 97,115,105, 99, 40,116, 41, 32,116,104,101,110, 10,114,101, + 116,117,114,110, 32,116, 44, 32, 95, 98, 97,115,105, 99, 95, + 116, 97,103, 91,116, 93, 10,101,110,100, 10,105,102, 32,115, + 116,114,102,105,110,100, 40,109, 44, 39, 99,111,110,115,116, + 39, 41, 32,116,104,101,110, 32, 99,111,110,115,116, 32, 61, + 32, 39, 99,111,110,115,116, 39, 32,101,110,100, 10,114,101, + 103,116,121,112,101, 40,116, 41, 10,105,102, 32, 99,111,110, + 115,116, 32, 97,110,100, 32, 99,111,110,115,116, 32,126, 61, + 32, 39, 39, 32,116,104,101,110, 10,116, 32, 61, 32, 39, 99, + 111,110,115,116, 32, 39, 46, 46,116, 10,101,110,100, 10,114, + 101,116,117,114,110, 32,116, 44, 39,116,111,108,117, 97, 95, + 116, 97,103, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, + 46,116, 46, 46, 39, 34, 41, 39, 10,101,110,100, 10,101,110, + 100, 10, 10, 10,102,117,110, 99,116,105,111,110, 32,105,115, + 98, 97,115,105, 99, 32, 40,116,121,112,101, 41, 10,108,111, + 99, 97,108, 32,109, 44,116, 32, 61, 32,102,105,110,100,116, + 121,112,101,100,101,102, 40,116,121,112,101, 41, 10,108,111, + 99, 97,108, 32, 98, 32, 61, 32, 95, 98, 97,115,105, 99, 91, + 116, 93, 10,105,102, 32, 98, 32,116,104,101,110, 10,114,101, + 116,117,114,110, 32, 98, 44, 95, 98, 97,115,105, 99, 95, 99, + 116,121,112,101, 91, 98, 93, 10,101,110,100, 10,114,101,116, + 117,114,110, 32,110,105,108, 10,101,110,100, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32,105,115,116,121,112,101, 32, + 40,116, 41, 10,114,101,116,117,114,110, 32, 95, 98, 97,115, + 105, 99, 91,116, 93, 32,111,114, 32, 95,117,115,101,114,116, + 121,112,101, 91,116, 93, 32,111,114, 32,105,115,116,121,112, + 101,100,101,102, 40,116, 41, 10,101,110,100, 10, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32,115,112,108,105,116, 32, + 40,115, 44,116, 41, 10,108,111, 99, 97,108, 32,108, 32, 61, + 32,123,110, 61, 48,125, 10,108,111, 99, 97,108, 32,102, 32, + 61, 32,102,117,110, 99,116,105,111,110, 32, 40,115, 41, 10, + 37,108, 46,110, 32, 61, 32, 37,108, 46,110, 32, 43, 32, 49, + 10, 37,108, 91, 37,108, 46,110, 93, 32, 61, 32,115, 10,101, + 110,100, 10,108,111, 99, 97,108, 32,112, 32, 61, 32, 34, 37, + 115, 42, 40, 46, 45, 41, 37,115, 42, 34, 46, 46,116, 46, 46, + 34, 37,115, 42, 34, 10,115, 32, 61, 32,103,115,117, 98, 40, + 115, 44, 34, 94, 37,115, 43, 34, 44, 34, 34, 41, 10,115, 32, + 61, 32,103,115,117, 98, 40,115, 44, 34, 37,115, 43, 36, 34, + 44, 34, 34, 41, 10,115, 32, 61, 32,103,115,117, 98, 40,115, + 44,112, 44,102, 41, 10,108, 46,110, 32, 61, 32,108, 46,110, + 32, 43, 32, 49, 10,108, 91,108, 46,110, 93, 32, 61, 32,103, + 115,117, 98, 40,115, 44, 34, 40, 37,115, 37,115, 42, 41, 36, + 34, 44, 34, 34, 41, 10,114,101,116,117,114,110, 32,108, 10, + 101,110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 99,111,110, 99, 97,116, 32, 40,116, 44,102, 44,108, 41, + 10,108,111, 99, 97,108, 32,115, 32, 61, 32, 39, 39, 10,108, + 111, 99, 97,108, 32,105, 61,102, 10,119,104,105,108,101, 32, + 105, 60, 61,108, 32,100,111, 10,115, 32, 61, 32,115, 46, 46, + 116, 91,105, 93, 10,105, 32, 61, 32,105, 43, 49, 10,105,102, + 32,105, 32, 60, 61, 32,108, 32,116,104,101,110, 32,115, 32, + 61, 32,115, 46, 46, 39, 32, 39, 32,101,110,100, 10,101,110, + 100, 10,114,101,116,117,114,110, 32,115, 10,101,110,100, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32,111,117,116,112, + 117,116, 32, 40, 46, 46, 46, 41, 10,108,111, 99, 97,108, 32, + 105, 61, 49, 10,119,104,105,108,101, 32,105, 60, 61, 97,114, + 103, 46,110, 32,100,111, 10,105,102, 32, 95, 99,111,110,116, + 32, 97,110,100, 32,110,111,116, 32,115,116,114,102,105,110, + 100, 40, 95, 99,111,110,116, 44, 39, 91, 37, 40, 44, 34, 93, + 39, 41, 32, 97,110,100, 10,115,116,114,102,105,110,100, 40, + 97,114,103, 91,105, 93, 44, 34, 94, 91, 37, 97, 95,126, 93, + 34, 41, 32,116,104,101,110, 10,119,114,105,116,101, 40, 39, + 32, 39, 41, 10,101,110,100, 10,119,114,105,116,101, 40, 97, + 114,103, 91,105, 93, 41, 10,105,102, 32, 97,114,103, 91,105, + 93, 32,126, 61, 32, 39, 39, 32,116,104,101,110, 10, 95, 99, + 111,110,116, 32, 61, 32,115,116,114,115,117, 98, 40, 97,114, + 103, 91,105, 93, 44, 45, 49, 44, 45, 49, 41, 10,101,110,100, + 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,105,102, + 32,115,116,114,102,105,110,100, 40, 97,114,103, 91, 97,114, + 103, 46,110, 93, 44, 34, 91, 37, 47, 37, 41, 37, 59, 37,123, + 37,125, 93, 36, 34, 41, 32,116,104,101,110, 10, 95, 99,111, + 110,116, 61,110,105,108, 32,119,114,105,116,101, 40, 39, 92, + 110, 39, 41, 10,101,110,100, 10,101,110,100, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115, + 115, 70,101, 97,116,117,114,101, 32, 61, 32,123, 10,125, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115, + 115, 70,101, 97,116,117,114,101, 58,115,117,112, 99,111,100, + 101, 32, 40, 41, 10,101,110,100, 10, 10, 10,102,117,110, 99, + 116,105,111,110, 32, 99,108, 97,115,115, 70,101, 97,116,117, + 114,101, 58,100,101, 99,108,116, 97,103, 32, 40, 41, 10,101, + 110,100, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99, + 108, 97,115,115, 70,101, 97,116,117,114,101, 58,114,101,103, + 105,115,116,101,114, 32, 40, 41, 10,101,110,100, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 70, + 101, 97,116,117,114,101, 58,117,110,114,101,103,105,115,116, + 101,114, 32, 40, 41, 10,101,110,100, 10, 10, 10,102,117,110, + 99,116,105,111,110, 32, 99,108, 97,115,115, 70,101, 97,116, + 117,114,101, 58,112,114,101, 97,109, 98,108,101, 32, 40, 41, + 10,101,110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111, + 110, 32, 99,108, 97,115,115, 70,101, 97,116,117,114,101, 58, + 105,110, 99,108, 97,115,115, 32, 40, 41, 10,105,102, 32,115, + 101,108,102, 46,112, 97,114,101,110,116, 32, 97,110,100, 32, + 115,101,108,102, 46,112, 97,114,101,110,116, 46,116,121,112, + 101, 32, 61, 61, 32, 39, 99,108, 97,115,115, 39, 32,116,104, + 101,110, 10,114,101,116,117,114,110, 32,115,101,108,102, 46, + 112, 97,114,101,110,116, 46,110, 97,109,101, 10,101,108,115, + 101, 10,114,101,116,117,114,110, 32,110,105,108, 10,101,110, + 100, 10,101,110,100, 10, 10, 10, 10,102,117,110, 99,116,105, + 111,110, 32, 99,108, 97,115,115, 70,101, 97,116,117,114,101, + 58,105,110,109,111,100,117,108,101, 32, 40, 41, 10,105,102, + 32,115,101,108,102, 46,112, 97,114,101,110,116, 32, 97,110, + 100, 32,115,101,108,102, 46,112, 97,114,101,110,116, 46,116, + 121,112,101, 32, 61, 61, 32, 39,109,111,100,117,108,101, 39, + 32,116,104,101,110, 10,114,101,116,117,114,110, 32,115,101, + 108,102, 46,112, 97,114,101,110,116, 46,110, 97,109,101, 10, + 101,108,115,101, 10,114,101,116,117,114,110, 32,110,105,108, + 10,101,110,100, 10,101,110,100, 10, 10, 10, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 70,101, + 97,116,117,114,101, 58, 99,102,117,110, 99,110, 97,109,101, + 32, 40,110, 41, 10,105,102, 32,115,101,108,102, 46,112, 97, + 114,101,110,116, 32,116,104,101,110, 10,110, 32, 61, 32,115, + 101,108,102, 46,112, 97,114,101,110,116, 58, 99,102,117,110, + 99,110, 97,109,101, 40,110, 41, 10,101,110,100, 10,105,102, + 32,115,101,108,102, 46,108,110, 97,109,101, 32,116,104,101, + 110, 10,114,101,116,117,114,110, 32,110, 46, 46, 39, 95, 39, + 46, 46,115,101,108,102, 46,108,110, 97,109,101, 10,101,108, + 115,101, 10,114,101,116,117,114,110, 32,110, 46, 46, 39, 95, + 39, 46, 46,115,101,108,102, 46,110, 97,109,101, 10,101,110, + 100, 10,101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115,115, 86, + 101,114, 98, 97,116,105,109, 32, 61, 32,123, 10,108,105,110, + 101, 32, 61, 32, 39, 39, 44, 10, 95, 98, 97,115,101, 32, 61, + 32, 99,108, 97,115,115, 70,101, 97,116,117,114,101, 44, 10, + 125, 10,115,101,116,116, 97,103, 40, 99,108, 97,115,115, 86, + 101,114, 98, 97,116,105,109, 44,116,111,108,117, 97, 95,116, + 97,103, 41, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, + 99,108, 97,115,115, 86,101,114, 98, 97,116,105,109, 58,112, + 114,101, 97,109, 98,108,101, 32, 40, 41, 10,105,102, 32,110, + 111,116, 32,115,101,108,102, 46, 99,111,110,100, 32,116,104, + 101,110, 10,119,114,105,116,101, 40,115,101,108,102, 46,108, + 105,110,101, 41, 10,101,110,100, 10,101,110,100, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 86, + 101,114, 98, 97,116,105,109, 58,115,117,112, 99,111,100,101, + 32, 40, 41, 10,105,102, 32,115,101,108,102, 46, 99,111,110, + 100, 32,116,104,101,110, 10,119,114,105,116,101, 40,115,101, + 108,102, 46,108,105,110,101, 41, 10,119,114,105,116,101, 40, + 39, 92,110, 39, 41, 10,101,110,100, 10,101,110,100, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, + 86,101,114, 98, 97,116,105,109, 58,114,101,103,105,115,116, + 101,114, 32, 40, 41, 10,105,102, 32,115,101,108,102, 46, 99, + 111,110,100, 32,116,104,101,110, 10,119,114,105,116,101, 40, + 115,101,108,102, 46,108,105,110,101, 41, 10,101,110,100, 10, + 101,110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 99,108, 97,115,115, 86,101,114, 98, 97,116,105,109, 58, + 112,114,105,110,116, 32, 40,105,100,101,110,116, 44, 99,108, + 111,115,101, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34, 86,101,114, 98, 97,116,105,109,123, 34, 41, + 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, + 32,108,105,110,101, 32, 61, 32, 39, 34, 46, 46,115,101,108, + 102, 46,108,105,110,101, 46, 46, 34, 39, 44, 34, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34,125, 34, + 46, 46, 99,108,111,115,101, 41, 10,101,110,100, 10, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 95, 86,101,114, 98, + 97,116,105,109, 32, 40,116, 41, 10,116, 46, 95, 98, 97,115, + 101, 32, 61, 32, 99,108, 97,115,115, 86,101,114, 98, 97,116, + 105,109, 10,115,101,116,116, 97,103, 40,116, 44,116,111,108, + 117, 97, 95,116, 97,103, 41, 10, 97,112,112,101,110,100, 40, + 116, 41, 10,114,101,116,117,114,110, 32,116, 10,101,110,100, + 10, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 86,101, + 114, 98, 97,116,105,109, 32, 40,108, 41, 10,108,111, 99, 97, + 108, 32, 99, 10,105,102, 32,115,116,114,115,117, 98, 40,108, + 44, 49, 44, 49, 41, 32, 61, 61, 32, 39, 36, 39, 32,116,104, + 101,110, 10, 99, 32, 61, 32, 49, 10,108, 32, 61, 32,115,116, + 114,115,117, 98, 40,108, 44, 50, 41, 10,101,110,100, 10,114, + 101,116,117,114,110, 32, 95, 86,101,114, 98, 97,116,105,109, + 32,123, 10,108,105,110,101, 32, 61, 32,108, 44, 10, 99,111, + 110,100, 32, 61, 32, 99, 10,125, 10,101,110,100, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 99,108, 97,115,115, 67,111,100,101, 32, 61, 32,123, 10,116, + 101,120,116, 32, 61, 32, 39, 39, 44, 10, 95, 98, 97,115,101, + 32, 61, 32, 99,108, 97,115,115, 70,101, 97,116,117,114,101, + 44, 10,125, 10,115,101,116,116, 97,103, 40, 99,108, 97,115, + 115, 67,111,100,101, 44,116,111,108,117, 97, 95,116, 97,103, + 41, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, + 97,115,115, 67,111,100,101, 58,114,101,103,105,115,116,101, + 114, 32, 40, 41, 10, 10,108,111, 99, 97,108, 32,115, 32, 61, + 32, 99,108,101, 97,110, 40,115,101,108,102, 46,116,101,120, + 116, 41, 10,105,102, 32,110,111,116, 32,115, 32,116,104,101, + 110, 10,101,114,114,111,114, 40, 34,112, 97,114,115,101,114, + 32,101,114,114,111,114, 32,105,110, 32,101,109, 98,101,100, + 100,101,100, 32, 99,111,100,101, 34, 41, 10,101,110,100, 10, + 10, 10,111,117,116,112,117,116, 40, 39, 92,110, 32,123, 32, + 47, 42, 32, 98,101,103,105,110, 32,101,109, 98,101,100,100, + 101,100, 32,108,117, 97, 32, 99,111,100,101, 32, 42, 47, 92, + 110, 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,115,116, + 97,116,105, 99, 32,117,110,115,105,103,110,101,100, 32, 99, + 104, 97,114, 32, 66, 91, 93, 32, 61, 32,123, 92,110, 32, 39, + 41, 10,108,111, 99, 97,108, 32,116, 61,123,110, 61, 48,125, + 10,108,111, 99, 97,108, 32, 98, 32, 61, 32,103,115,117, 98, + 40,115, 44, 39, 40, 46, 41, 39, 44,102,117,110, 99,116,105, + 111,110, 32, 40, 99, 41, 10,108,111, 99, 97,108, 32,101, 32, + 61, 32, 39, 39, 10, 37,116, 46,110, 61, 37,116, 46,110, 43, + 49, 32,105,102, 32, 37,116, 46,110, 61, 61, 49, 53, 32,116, + 104,101,110, 32, 37,116, 46,110, 61, 48, 32,101, 61, 39, 92, + 110, 32, 39, 32,101,110,100, 10,114,101,116,117,114,110, 32, + 102,111,114,109, 97,116, 40, 39, 37, 51,117, 44, 37,115, 39, + 44,115,116,114, 98,121,116,101, 40, 99, 41, 44,101, 41, 10, + 101,110,100, 10, 41, 10,111,117,116,112,117,116, 40, 98, 46, + 46,115,116,114, 98,121,116,101, 40, 34, 32, 34, 41, 41, 10, + 111,117,116,112,117,116, 40, 39, 92,110, 32,125, 59, 92,110, + 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,108,117, 97, + 95,100,111, 98,117,102,102,101,114, 40,116,111,108,117, 97, + 95, 83, 44, 40, 99,104, 97,114, 42, 41, 66, 44,115,105,122, + 101,111,102, 40, 66, 41, 44, 34,116,111,108,117, 97, 58, 32, + 101,109, 98,101,100,100,101,100, 32, 76,117, 97, 32, 99,111, + 100,101, 34, 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, + 39, 32,125, 32, 47, 42, 32,101,110,100, 32,111,102, 32,101, + 109, 98,101,100,100,101,100, 32,108,117, 97, 32, 99,111,100, + 101, 32, 42, 47, 92,110, 92,110, 39, 41, 10,101,110,100, 10, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97, + 115,115, 67,111,100,101, 58,112,114,105,110,116, 32, 40,105, + 100,101,110,116, 44, 99,108,111,115,101, 41, 10,112,114,105, + 110,116, 40,105,100,101,110,116, 46, 46, 34, 67,111,100,101, + 123, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, + 46, 46, 34, 32,116,101,120,116, 32, 61, 32, 91, 91, 34, 46, + 46,115,101,108,102, 46,116,101,120,116, 46, 46, 34, 93, 93, + 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, + 46, 46, 34,125, 34, 46, 46, 99,108,111,115,101, 41, 10,101, + 110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, + 95, 67,111,100,101, 32, 40,116, 41, 10,116, 46, 95, 98, 97, + 115,101, 32, 61, 32, 99,108, 97,115,115, 67,111,100,101, 10, + 115,101,116,116, 97,103, 40,116, 44,116,111,108,117, 97, 95, + 116, 97,103, 41, 10, 97,112,112,101,110,100, 40,116, 41, 10, + 114,101,116,117,114,110, 32,116, 10,101,110,100, 10, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 67,111,100,101, 32, + 40,108, 41, 10,114,101,116,117,114,110, 32, 95, 67,111,100, + 101, 32,123, 10,116,101,120,116, 32, 61, 32,108, 10,125, 10, + 101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97, + 115,115, 84,121,112,101,100,101,102, 32, 61, 32,123, 10,117, + 116,121,112,101, 32, 61, 32, 39, 39, 44, 10,109,111,100, 32, + 61, 32, 39, 39, 44, 10,116,121,112,101, 32, 61, 32, 39, 39, + 10,125, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99, + 108, 97,115,115, 84,121,112,101,100,101,102, 58,112,114,105, + 110,116, 32, 40,105,100,101,110,116, 44, 99,108,111,115,101, + 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, + 34, 84,121,112,101,100,101,102,123, 34, 41, 10,112,114,105, + 110,116, 40,105,100,101,110,116, 46, 46, 34, 32,117,116,121, + 112,101, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,117, + 116,121,112,101, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105, + 110,116, 40,105,100,101,110,116, 46, 46, 34, 32,109,111,100, + 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,109,111,100, + 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105, + 100,101,110,116, 46, 46, 34, 32,116,121,112,101, 32, 61, 32, + 39, 34, 46, 46,115,101,108,102, 46,116,121,112,101, 46, 46, + 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101, + 110,116, 46, 46, 34,125, 34, 46, 46, 99,108,111,115,101, 41, + 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 95, 84,121,112,101,100,101,102, 32, 40,116, 41, 10,116, + 46, 95, 98, 97,115,101, 32, 61, 32, 99,108, 97,115,115, 84, + 121,112,101,100,101,102, 10,115,101,116,116, 97,103, 40,116, + 44,116,111,108,117, 97, 95,116, 97,103, 41, 10, 97,112,112, + 101,110,100,116,121,112,101,100,101,102, 40,116, 41, 10,114, + 101,116,117,114,110, 32,116, 10,101,110,100, 10, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32, 84,121,112,101,100,101, + 102, 32, 40,115, 41, 10,105,102, 32,115,116,114,102,105,110, + 100, 40,115, 44, 39, 91, 37, 42, 38, 93, 39, 41, 32,116,104, + 101,110, 10,116,111,108,117, 97, 95,101,114,114,111,114, 40, + 34, 35,105,110,118, 97,108,105,100, 32,116,121,112,101,100, + 101,102, 58, 32,112,111,105,110,116,101,114,115, 32, 40, 97, + 110,100, 32,114,101,102,101,114,101,110, 99,101,115, 41, 32, + 97,114,101, 32,110,111,116, 32,115,117,112,112,111,114,116, + 101,100, 34, 41, 10,101,110,100, 10,108,111, 99, 97,108, 32, + 116, 32, 61, 32,115,112,108,105,116, 40,103,115,117, 98, 40, + 115, 44, 34, 37,115, 37,115, 42, 34, 44, 34, 32, 34, 41, 44, + 34, 32, 34, 41, 10,114,101,116,117,114,110, 32, 95, 84,121, + 112,101,100,101,102, 32,123, 10,117,116,121,112,101, 32, 61, + 32,116, 91,116, 46,110, 93, 44, 10,116,121,112,101, 32, 61, + 32,116, 91,116, 46,110, 45, 49, 93, 44, 10,109,111,100, 32, + 61, 32, 99,111,110, 99, 97,116, 40,116, 44, 49, 44,116, 46, + 110, 45, 50, 41, 10,125, 10,101,110,100, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115, + 115, 67,111,110,116, 97,105,110,101,114, 32, 61, 10,123, 10, + 99,117,114,114, 32, 61, 32,110,105,108, 44, 10, 95, 98, 97, + 115,101, 32, 61, 32, 99,108, 97,115,115, 70,101, 97,116,117, + 114,101, 44, 10,125, 10,115,101,116,116, 97,103, 40, 99,108, + 97,115,115, 67,111,110,116, 97,105,110,101,114, 44,116,111, + 108,117, 97, 95,116, 97,103, 41, 10, 10, 10,102,117,110, 99, + 116,105,111,110, 32, 99,108, 97,115,115, 67,111,110,116, 97, + 105,110,101,114, 58,100,101, 99,108,116, 97,103, 32, 40, 41, + 10,112,117,115,104, 40,115,101,108,102, 41, 10,108,111, 99, + 97,108, 32,105, 61, 49, 10,119,104,105,108,101, 32,115,101, + 108,102, 91,105, 93, 32,100,111, 10,115,101,108,102, 91,105, + 93, 58,100,101, 99,108,116, 97,103, 40, 41, 10,105, 32, 61, + 32,105, 43, 49, 10,101,110,100, 10,112,111,112, 40, 41, 10, + 101,110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, + 58,115,117,112, 99,111,100,101, 32, 40, 41, 10,112,117,115, + 104, 40,115,101,108,102, 41, 10,108,111, 99, 97,108, 32,105, + 61, 49, 10,119,104,105,108,101, 32,115,101,108,102, 91,105, + 93, 32,100,111, 10,115,101,108,102, 91,105, 93, 58,115,117, + 112, 99,111,100,101, 40, 41, 10,105, 32, 61, 32,105, 43, 49, + 10,101,110,100, 10,112,111,112, 40, 41, 10,101,110,100, 10, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 95, 67,111, + 110,116, 97,105,110,101,114, 32, 40,115,101,108,102, 41, 10, + 115,101,108,102, 46, 95, 98, 97,115,101, 32, 61, 32, 99,108, + 97,115,115, 67,111,110,116, 97,105,110,101,114, 10,115,101, + 116,116, 97,103, 40,115,101,108,102, 44,116,111,108,117, 97, + 95,116, 97,103, 41, 10,115,101,108,102, 46,110, 32, 61, 32, + 48, 10,115,101,108,102, 46,116,121,112,101,100,101,102,115, + 32, 61, 32,123,110, 61, 48,125, 10,115,101,108,102, 46,108, + 110, 97,109,101,115, 32, 61, 32,123,125, 10,114,101,116,117, + 114,110, 32,115,101,108,102, 10,101,110,100, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32,112,117,115,104, 32, 40,116, + 41, 10, 99,108, 97,115,115, 67,111,110,116, 97,105,110,101, + 114, 46, 99,117,114,114, 32, 61, 32,116, 10,101,110,100, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32,112,111,112, 32, + 40, 41, 10, 99,108, 97,115,115, 67,111,110,116, 97,105,110, + 101,114, 46, 99,117,114,114, 32, 61, 32, 99,108, 97,115,115, + 67,111,110,116, 97,105,110,101,114, 46, 99,117,114,114, 46, + 112, 97,114,101,110,116, 10,101,110,100, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 97,112,112,101,110,100, 32, 40, + 116, 41, 10,114,101,116,117,114,110, 32, 99,108, 97,115,115, + 67,111,110,116, 97,105,110,101,114, 46, 99,117,114,114, 58, + 97,112,112,101,110,100, 40,116, 41, 10,101,110,100, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 97,112,112,101,110, + 100,116,121,112,101,100,101,102, 32, 40,116, 41, 10,114,101, + 116,117,114,110, 32, 99,108, 97,115,115, 67,111,110,116, 97, + 105,110,101,114, 46, 99,117,114,114, 58, 97,112,112,101,110, + 100,116,121,112,101,100,101,102, 40,116, 41, 10,101,110,100, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32,102,105,110, + 100,116,121,112,101,100,101,102, 32, 40,116,121,112,101, 41, + 10,114,101,116,117,114,110, 32, 99,108, 97,115,115, 67,111, + 110,116, 97,105,110,101,114, 46, 99,117,114,114, 58,102,105, + 110,100,116,121,112,101,100,101,102, 40,116,121,112,101, 41, + 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32,105,115,116,121,112,101,100,101,102, 32, 40,116,121,112, + 101, 41, 10,114,101,116,117,114,110, 32, 99,108, 97,115,115, + 67,111,110,116, 97,105,110,101,114, 46, 99,117,114,114, 58, + 105,115,116,121,112,101,100,101,102, 40,116,121,112,101, 41, + 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, + 58, 97,112,112,101,110,100, 32, 40,116, 41, 10,115,101,108, + 102, 46,110, 32, 61, 32,115,101,108,102, 46,110, 32, 43, 32, + 49, 10,115,101,108,102, 91,115,101,108,102, 46,110, 93, 32, + 61, 32,116, 10,116, 46,112, 97,114,101,110,116, 32, 61, 32, + 115,101,108,102, 10,101,110,100, 10, 10, 10,102,117,110, 99, + 116,105,111,110, 32, 99,108, 97,115,115, 67,111,110,116, 97, + 105,110,101,114, 58, 97,112,112,101,110,100,116,121,112,101, + 100,101,102, 32, 40,116, 41, 10,115,101,108,102, 46,116,121, + 112,101,100,101,102,115, 46,110, 32, 61, 32,115,101,108,102, + 46,116,121,112,101,100,101,102,115, 46,110, 32, 43, 32, 49, + 10,115,101,108,102, 46,116,121,112,101,100,101,102,115, 91, + 115,101,108,102, 46,116,121,112,101,100,101,102,115, 46,110, + 93, 32, 61, 32,116, 10,101,110,100, 10, 10, 10,102,117,110, + 99,116,105,111,110, 32, 99,108, 97,115,115, 67,111,110,116, + 97,105,110,101,114, 58,111,118,101,114,108,111, 97,100, 32, + 40,108,110, 97,109,101, 41, 10,105,102, 32,110,111,116, 32, + 115,101,108,102, 46,108,110, 97,109,101,115, 91,108,110, 97, + 109,101, 93, 32,116,104,101,110, 10,115,101,108,102, 46,108, + 110, 97,109,101,115, 91,108,110, 97,109,101, 93, 32, 61, 32, + 48, 10,101,108,115,101, 10,115,101,108,102, 46,108,110, 97, + 109,101,115, 91,108,110, 97,109,101, 93, 32, 61, 32,115,101, + 108,102, 46,108,110, 97,109,101,115, 91,108,110, 97,109,101, + 93, 32, 43, 32, 49, 10,101,110,100, 10,114,101,116,117,114, + 110, 32,102,111,114,109, 97,116, 40, 34, 37, 48, 50,100, 34, + 44,115,101,108,102, 46,108,110, 97,109,101,115, 91,108,110, + 97,109,101, 93, 41, 10,101,110,100, 10, 10,102,117,110, 99, + 116,105,111,110, 32, 99,108, 97,115,115, 67,111,110,116, 97, + 105,110,101,114, 58,102,105,110,100,116,121,112,101,100,101, + 102, 32, 40,116,121,112,101, 41, 10,108,111, 99, 97,108, 32, + 101,110,118, 32, 61, 32,115,101,108,102, 10,119,104,105,108, + 101, 32,101,110,118, 32,100,111, 10,105,102, 32,101,110,118, + 46,116,121,112,101,100,101,102,115, 32,116,104,101,110, 10, + 108,111, 99, 97,108, 32,105, 61, 49, 10,119,104,105,108,101, + 32,101,110,118, 46,116,121,112,101,100,101,102,115, 91,105, + 93, 32,100,111, 10,105,102, 32,101,110,118, 46,116,121,112, + 101,100,101,102,115, 91,105, 93, 46,117,116,121,112,101, 32, + 61, 61, 32,116,121,112,101, 32,116,104,101,110, 10,108,111, + 99, 97,108, 32,109,111,100, 49, 44,116,121,112,101, 49, 32, + 61, 32,101,110,118, 46,116,121,112,101,100,101,102,115, 91, + 105, 93, 46,109,111,100, 44,101,110,118, 46,116,121,112,101, + 100,101,102,115, 91,105, 93, 46,116,121,112,101, 10,108,111, + 99, 97,108, 32,109,111,100, 50, 44,116,121,112,101, 50, 32, + 61, 32,102,105,110,100,116,121,112,101,100,101,102, 40,116, + 121,112,101, 49, 41, 10,114,101,116,117,114,110, 32,109,111, + 100, 50, 46, 46, 39, 32, 39, 46, 46,109,111,100, 49, 44,116, + 121,112,101, 50, 10,101,110,100, 10,105, 32, 61, 32,105, 43, + 49, 10,101,110,100, 10,101,110,100, 10,101,110,118, 32, 61, + 32,101,110,118, 46,112, 97,114,101,110,116, 10,101,110,100, + 10,114,101,116,117,114,110, 32, 39, 39, 44,116,121,112,101, + 10,101,110,100, 10, 10,102,117,110, 99,116,105,111,110, 32, + 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, 58, + 105,115,116,121,112,101,100,101,102, 32, 40,116,121,112,101, + 41, 10,108,111, 99, 97,108, 32,101,110,118, 32, 61, 32,115, + 101,108,102, 10,119,104,105,108,101, 32,101,110,118, 32,100, + 111, 10,105,102, 32,101,110,118, 46,116,121,112,101,100,101, + 102,115, 32,116,104,101,110, 10,108,111, 99, 97,108, 32,105, + 61, 49, 10,119,104,105,108,101, 32,101,110,118, 46,116,121, + 112,101,100,101,102,115, 91,105, 93, 32,100,111, 10,105,102, + 32,101,110,118, 46,116,121,112,101,100,101,102,115, 91,105, + 93, 46,117,116,121,112,101, 32, 61, 61, 32,116,121,112,101, + 32,116,104,101,110, 10,114,101,116,117,114,110, 32, 49, 10, + 101,110,100, 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, + 10,101,110,100, 10,101,110,118, 32, 61, 32,101,110,118, 46, + 112, 97,114,101,110,116, 10,101,110,100, 10,114,101,116,117, + 114,110, 32,110,105,108, 10,101,110,100, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 99,108, 97,115,115, 67,111,110, + 116, 97,105,110,101,114, 58,100,111,112, 97,114,115,101, 32, + 40,115, 41, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, + 98, 44,101, 44,110, 97,109,101, 44, 98,111,100,121, 32, 61, + 32,115,116,114,102,105,110,100, 40,115, 44, 34, 94, 37,115, + 42,109,111,100,117,108,101, 37,115, 37,115, 42, 40, 91, 95, + 37,119, 93, 91, 95, 37,119, 93, 42, 41, 37,115, 42, 40, 37, + 98,123,125, 41, 37,115, 42, 34, 41, 10,105,102, 32, 98, 32, + 116,104,101,110, 10, 95, 99,117,114,114, 95, 99,111,100,101, + 32, 61, 32,115,116,114,115,117, 98, 40,115, 44, 98, 44,101, + 41, 10, 77,111,100,117,108,101, 40,110, 97,109,101, 44, 98, + 111,100,121, 41, 10,114,101,116,117,114,110, 32,115,116,114, + 115,117, 98, 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10, + 101,110,100, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, + 98, 44,101, 44,110, 97,109,101, 32, 61, 32,115,116,114,102, + 105,110,100, 40,115, 44, 34, 94, 37,115, 42, 35,100,101,102, + 105,110,101, 37,115, 37,115, 42, 40, 91, 94, 37,115, 93, 42, + 41, 91, 94, 92,110, 93, 42, 92,110, 37,115, 42, 34, 41, 10, + 105,102, 32, 98, 32,116,104,101,110, 10, 95, 99,117,114,114, + 95, 99,111,100,101, 32, 61, 32,115,116,114,115,117, 98, 40, + 115, 44, 98, 44,101, 41, 10, 68,101,102,105,110,101, 40,110, + 97,109,101, 41, 10,114,101,116,117,114,110, 32,115,116,114, + 115,117, 98, 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10, + 101,110,100, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, + 98, 44,101, 44, 98,111,100,121, 32, 61, 32,115,116,114,102, + 105,110,100, 40,115, 44, 34, 94, 37,115, 42,101,110,117,109, + 91, 94,123, 93, 42, 40, 37, 98,123,125, 41, 37,115, 42, 59, + 63, 37,115, 42, 34, 41, 10,105,102, 32, 98, 32,116,104,101, + 110, 10, 95, 99,117,114,114, 95, 99,111,100,101, 32, 61, 32, + 115,116,114,115,117, 98, 40,115, 44, 98, 44,101, 41, 10, 69, + 110,117,109,101,114, 97,116,101, 40, 98,111,100,121, 41, 10, + 114,101,116,117,114,110, 32,115,116,114,115,117, 98, 40,115, + 44,101, 43, 49, 41, 10,101,110,100, 10,101,110,100, 10, 10, + 100,111, 10,108,111, 99, 97,108, 32, 98, 44,101, 44, 98,111, + 100,121, 44,110, 97,109,101, 32, 61, 32,115,116,114,102,105, + 110,100, 40,115, 44, 34, 94, 37,115, 42,116,121,112,101,100, + 101,102, 37,115, 37,115, 42,101,110,117,109, 91, 94,123, 93, + 42, 40, 37, 98,123,125, 41, 37,115, 42, 40, 91, 37,119, 95, + 93, 91, 94, 37,115, 93, 42, 41, 37,115, 42, 59, 37,115, 42, + 34, 41, 10,105,102, 32, 98, 32,116,104,101,110, 10, 95, 99, + 117,114,114, 95, 99,111,100,101, 32, 61, 32,115,116,114,115, + 117, 98, 40,115, 44, 98, 44,101, 41, 10, 69,110,117,109,101, + 114, 97,116,101, 40, 98,111,100,121, 41, 10, 84,121,112,101, + 100,101,102, 40, 34,105,110,116, 32, 34, 46, 46,110, 97,109, + 101, 41, 10,114,101,116,117,114,110, 32,115,116,114,115,117, + 98, 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10,101,110, + 100, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, 98, 44, + 101, 44,100,101, 99,108, 44,107,105,110,100, 44, 97,114,103, + 44, 99,111,110,115,116, 32, 61, 32,115,116,114,102,105,110, + 100, 40,115, 44, 34, 94, 37,115, 42, 40, 91, 95, 37,119, 93, + 91, 95, 37,119, 37,115, 37, 42, 38, 93, 42,111,112,101,114, + 97,116,111,114, 41, 37,115, 42, 40, 91, 94, 37,115, 93, 91, + 94, 37,115, 93, 42, 41, 37,115, 42, 40, 37, 98, 40, 41, 41, + 37,115, 42, 40, 99, 63,111, 63,110, 63,115, 63,116, 63, 41, + 37,115, 42, 59, 37,115, 42, 34, 41, 10,105,102, 32, 98, 32, + 116,104,101,110, 10, 95, 99,117,114,114, 95, 99,111,100,101, + 32, 61, 32,115,116,114,115,117, 98, 40,115, 44, 98, 44,101, + 41, 10, 79,112,101,114, 97,116,111,114, 40,100,101, 99,108, + 44,107,105,110,100, 44, 97,114,103, 44, 99,111,110,115,116, + 41, 10,114,101,116,117,114,110, 32,115,116,114,115,117, 98, + 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10,101,110,100, + 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, 98, 44,101, + 44,100,101, 99,108, 44, 97,114,103, 44, 99,111,110,115,116, + 32, 61, 32,115,116,114,102,105,110,100, 40,115, 44, 34, 94, + 37,115, 42, 40, 91,126, 95, 37,119, 93, 91, 95, 64, 37,119, + 37,115, 37, 42, 38, 93, 42, 91, 95, 37,119, 93, 41, 37,115, + 42, 40, 37, 98, 40, 41, 41, 37,115, 42, 40, 99, 63,111, 63, + 110, 63,115, 63,116, 63, 41, 37,115, 42, 61, 63, 37,115, 42, + 48, 63, 37,115, 42, 59, 37,115, 42, 34, 41, 10,105,102, 32, + 110,111,116, 32, 98, 32,116,104,101,110, 10, 10, 98, 44,101, + 44,100,101, 99,108, 44, 97,114,103, 44, 99,111,110,115,116, + 32, 61, 32,115,116,114,102,105,110,100, 40,115, 44, 34, 94, + 37,115, 42, 40, 91, 95, 37,119, 93, 41, 37,115, 42, 40, 37, + 98, 40, 41, 41, 37,115, 42, 40, 99, 63,111, 63,110, 63,115, + 63,116, 63, 41, 37,115, 42, 59, 37,115, 42, 34, 41, 10,101, + 110,100, 10,105,102, 32, 98, 32,116,104,101,110, 10, 95, 99, + 117,114,114, 95, 99,111,100,101, 32, 61, 32,115,116,114,115, + 117, 98, 40,115, 44, 98, 44,101, 41, 10, 70,117,110, 99,116, + 105,111,110, 40,100,101, 99,108, 44, 97,114,103, 44, 99,111, + 110,115,116, 41, 10,114,101,116,117,114,110, 32,115,116,114, + 115,117, 98, 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10, + 101,110,100, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, + 98, 44,101, 44,100,101, 99,108, 44, 97,114,103, 44, 99,111, + 110,115,116, 32, 61, 32,115,116,114,102,105,110,100, 40,115, + 44, 34, 94, 37,115, 42, 40, 91,126, 95, 37,119, 93, 91, 95, + 64, 37,119, 37,115, 37, 42, 38, 93, 42, 91, 95, 37,119, 93, + 41, 37,115, 42, 40, 37, 98, 40, 41, 41, 37,115, 42, 40, 99, + 63,111, 63,110, 63,115, 63,116, 63, 41, 37,115, 42, 37, 98, + 123,125, 37,115, 42, 34, 41, 10,105,102, 32,110,111,116, 32, + 98, 32,116,104,101,110, 10, 10, 98, 44,101, 44,100,101, 99, + 108, 44, 97,114,103, 44, 99,111,110,115,116, 32, 61, 32,115, + 116,114,102,105,110,100, 40,115, 44, 34, 94, 37,115, 42, 40, + 91, 95, 37,119, 93, 41, 37,115, 42, 40, 37, 98, 40, 41, 41, + 37,115, 42, 40, 99, 63,111, 63,110, 63,115, 63,116, 63, 41, + 37,115, 42, 37, 98,123,125, 37,115, 42, 34, 41, 10,101,110, + 100, 10,105,102, 32, 98, 32,116,104,101,110, 10, 95, 99,117, + 114,114, 95, 99,111,100,101, 32, 61, 32,115,116,114,115,117, + 98, 40,115, 44, 98, 44,101, 41, 10, 70,117,110, 99,116,105, + 111,110, 40,100,101, 99,108, 44, 97,114,103, 44, 99,111,110, + 115,116, 41, 10,114,101,116,117,114,110, 32,115,116,114,115, + 117, 98, 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10,101, + 110,100, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, 98, + 44,101, 44,110, 97,109,101, 44, 98, 97,115,101, 44, 98,111, + 100,121, 32, 61, 32,115,116,114,102,105,110,100, 40,115, 44, + 34, 94, 37,115, 42, 99,108, 97,115,115, 37,115, 42, 40, 91, + 95, 37,119, 93, 91, 95, 37,119, 93, 42, 41, 37,115, 42, 40, + 46, 45, 41, 37,115, 42, 40, 37, 98,123,125, 41, 37,115, 42, + 59, 37,115, 42, 34, 41, 10,105,102, 32,110,111,116, 32, 98, + 32,116,104,101,110, 10, 98, 44,101, 44,110, 97,109,101, 44, + 98, 97,115,101, 44, 98,111,100,121, 32, 61, 32,115,116,114, + 102,105,110,100, 40,115, 44, 34, 94, 37,115, 42,115,116,114, + 117, 99,116, 37,115, 42, 40, 91, 95, 37,119, 93, 91, 95, 37, + 119, 93, 42, 41, 37,115, 42, 40, 46, 45, 41, 37,115, 42, 40, + 37, 98,123,125, 41, 37,115, 42, 59, 37,115, 42, 34, 41, 10, + 105,102, 32,110,111,116, 32, 98, 32,116,104,101,110, 10, 98, + 97,115,101, 32, 61, 32, 39, 39, 10, 98, 44,101, 44, 98,111, + 100,121, 44,110, 97,109,101, 32, 61, 32,115,116,114,102,105, + 110,100, 40,115, 44, 34, 94, 37,115, 42,116,121,112,101,100, + 101,102, 37,115, 37,115, 42,115,116,114,117, 99,116, 37,115, + 37,115, 42, 91, 95, 37,119, 93, 42, 37,115, 42, 40, 37, 98, + 123,125, 41, 37,115, 42, 40, 91, 95, 37,119, 93, 91, 95, 37, + 119, 93, 42, 41, 37,115, 42, 59, 37,115, 42, 34, 41, 10,101, + 110,100, 10,101,110,100, 10,105,102, 32, 98, 32,116,104,101, + 110, 10,105,102, 32, 98, 97,115,101, 32,126, 61, 32, 39, 39, + 32,116,104,101,110, 10,108,111, 99, 97,108, 32, 98, 44,101, + 10, 98, 44,101, 44, 98, 97,115,101, 32, 61, 32,115,116,114, + 102,105,110,100, 40, 98, 97,115,101, 44, 34, 46, 45, 40, 91, + 95, 37,119, 93, 91, 95, 37,119, 93, 42, 41, 36, 34, 41, 10, + 101,110,100, 10, 95, 99,117,114,114, 95, 99,111,100,101, 32, + 61, 32,115,116,114,115,117, 98, 40,115, 44, 98, 44,101, 41, + 10, 67,108, 97,115,115, 40,110, 97,109,101, 44, 98, 97,115, + 101, 44, 98,111,100,121, 41, 10,114,101,116,117,114,110, 32, + 115,116,114,115,117, 98, 40,115, 44,101, 43, 49, 41, 10,101, + 110,100, 10,101,110,100, 10, 10, 10,100,111, 10,108,111, 99, + 97,108, 32, 98, 44,101, 44,116,121,112,101,115, 32, 61, 32, + 115,116,114,102,105,110,100, 40,115, 44, 34, 94, 37,115, 42, + 116,121,112,101,100,101,102, 37,115, 37,115, 42, 40, 46, 45, + 41, 37,115, 42, 59, 37,115, 42, 34, 41, 10,105,102, 32, 98, + 32,116,104,101,110, 10, 95, 99,117,114,114, 95, 99,111,100, + 101, 32, 61, 32,115,116,114,115,117, 98, 40,115, 44, 98, 44, + 101, 41, 10, 84,121,112,101,100,101,102, 40,116,121,112,101, + 115, 41, 10,114,101,116,117,114,110, 32,115,116,114,115,117, + 98, 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10,101,110, + 100, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, 98, 44, + 101, 44,100,101, 99,108, 32, 61, 32,115,116,114,102,105,110, + 100, 40,115, 44, 34, 94, 37,115, 42, 40, 91, 95, 37,119, 93, + 91, 95, 64, 37,115, 37,119, 37,100, 37, 42, 38, 93, 42, 91, + 95, 37,119, 37,100, 93, 41, 37,115, 42, 59, 37,115, 42, 34, + 41, 10,105,102, 32, 98, 32,116,104,101,110, 10, 95, 99,117, + 114,114, 95, 99,111,100,101, 32, 61, 32,115,116,114,115,117, + 98, 40,115, 44, 98, 44,101, 41, 10, 86, 97,114,105, 97, 98, + 108,101, 40,100,101, 99,108, 41, 10,114,101,116,117,114,110, + 32,115,116,114,115,117, 98, 40,115, 44,101, 43, 49, 41, 10, + 101,110,100, 10,101,110,100, 10, 10, 10,100,111, 10,108,111, + 99, 97,108, 32, 98, 44,101, 44,100,101, 99,108, 32, 61, 32, + 115,116,114,102,105,110,100, 40,115, 44, 34, 94, 37,115, 42, + 40, 91, 95, 37,119, 93, 91, 93, 91, 95, 64, 37,115, 37,119, + 37,100, 37, 42, 38, 37, 45, 37, 62, 93, 42, 91, 93, 95, 37, + 119, 37,100, 93, 41, 37,115, 42, 59, 37,115, 42, 34, 41, 10, + 105,102, 32, 98, 32,116,104,101,110, 10, 95, 99,117,114,114, + 95, 99,111,100,101, 32, 61, 32,115,116,114,115,117, 98, 40, + 115, 44, 98, 44,101, 41, 10, 65,114,114, 97,121, 40,100,101, + 99,108, 41, 10,114,101,116,117,114,110, 32,115,116,114,115, + 117, 98, 40,115, 44,101, 43, 49, 41, 10,101,110,100, 10,101, + 110,100, 10, 10, 10,100,111, 10,108,111, 99, 97,108, 32, 98, + 44,101, 44, 99,111,100,101, 32, 61, 32,115,116,114,102,105, + 110,100, 40,115, 44, 34, 94, 37,115, 42, 40, 37, 98, 92, 49, + 92, 50, 41, 34, 41, 10,105,102, 32, 98, 32,116,104,101,110, + 10, 67,111,100,101, 40,115,116,114,115,117, 98, 40, 99,111, + 100,101, 44, 50, 44, 45, 50, 41, 41, 10,114,101,116,117,114, + 110, 32,115,116,114,115,117, 98, 40,115, 44,101, 43, 49, 41, + 10,101,110,100, 10,101,110,100, 10, 10, 10,100,111, 10,108, + 111, 99, 97,108, 32, 98, 44,101, 44,108,105,110,101, 32, 61, + 32,115,116,114,102,105,110,100, 40,115, 44, 34, 94, 37,115, + 42, 37, 36, 40, 46, 45, 92,110, 41, 34, 41, 10,105,102, 32, + 98, 32,116,104,101,110, 10, 86,101,114, 98, 97,116,105,109, + 40,108,105,110,101, 41, 10,114,101,116,117,114,110, 32,115, + 116,114,115,117, 98, 40,115, 44,101, 43, 49, 41, 10,101,110, + 100, 10,101,110,100, 10, 10, 10,105,102, 32,103,115,117, 98, + 40,115, 44, 34, 37,115, 37,115, 42, 34, 44, 34, 34, 41, 32, + 126, 61, 32, 34, 34, 32,116,104,101,110, 10, 95, 99,117,114, + 114, 95, 99,111,100,101, 32, 61, 32,115, 10,101,114,114,111, + 114, 40, 34, 35,112, 97,114,115,101, 32,101,114,114,111,114, + 34, 41, 10,101,108,115,101, 10,114,101,116,117,114,110, 32, + 34, 34, 10,101,110,100, 10,101,110,100, 10, 10,102,117,110, + 99,116,105,111,110, 32, 99,108, 97,115,115, 67,111,110,116, + 97,105,110,101,114, 58,112, 97,114,115,101, 32, 40,115, 41, + 10,119,104,105,108,101, 32,115, 32,126, 61, 32, 39, 39, 32, + 100,111, 10,115, 32, 61, 32,115,101,108,102, 58,100,111,112, + 97,114,115,101, 40,115, 41, 10,101,110,100, 10,101,110,100, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 99,108, 97,115,115, 80, 97, 99,107, 97, + 103,101, 32, 61, 32,123, 10, 95, 98, 97,115,101, 32, 61, 32, + 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, 44, + 10,116,121,112,101, 32, 61, 32, 39,112, 97, 99,107, 97,103, + 101, 39, 10,125, 10,115,101,116,116, 97,103, 40, 99,108, 97, + 115,115, 80, 97, 99,107, 97,103,101, 44,116,111,108,117, 97, + 95,116, 97,103, 41, 10, 10, 10,102,117,110, 99,116,105,111, + 110, 32, 99,108, 97,115,115, 80, 97, 99,107, 97,103,101, 58, + 112,114,105,110,116, 32, 40, 41, 10,112,114,105,110,116, 40, + 34, 80, 97, 99,107, 97,103,101, 58, 32, 34, 46, 46,115,101, + 108,102, 46,110, 97,109,101, 41, 10,108,111, 99, 97,108, 32, + 105, 61, 49, 10,119,104,105,108,101, 32,115,101,108,102, 91, + 105, 93, 32,100,111, 10,115,101,108,102, 91,105, 93, 58,112, + 114,105,110,116, 40, 34, 34, 44, 34, 34, 41, 10,105, 32, 61, + 32,105, 43, 49, 10,101,110,100, 10,101,110,100, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 80, 97, + 99,107, 97,103,101, 58,112,114,101,112,114,111, 99,101,115, + 115, 32, 40, 41, 10,115,101,108,102, 46, 99,111,100,101, 32, + 61, 32, 34, 92,110, 34, 46, 46,115,101,108,102, 46, 99,111, + 100,101, 10, 10,108,111, 99, 97,108, 32, 86, 32, 61, 32,123, + 125, 10,115,101,108,102, 46, 99,111,100,101, 32, 61, 32,103, + 115,117, 98, 40,115,101,108,102, 46, 99,111,100,101, 44, 34, + 92,110, 40, 37,115, 42, 37, 36, 91, 94, 37, 91, 37, 93, 93, + 91, 94, 92,110, 93, 42, 41, 34, 44,102,117,110, 99,116,105, + 111,110, 32, 40,118, 41, 10,116,105,110,115,101,114,116, 40, + 37, 86, 44,118, 41, 10,114,101,116,117,114,110, 32, 34, 92, + 110, 36, 34, 46, 46,103,101,116,110, 40, 37, 86, 41, 46, 46, + 34, 36, 34, 10,101,110,100, 41, 10, 10,108,111, 99, 97,108, + 32, 67, 32, 61, 32,123,125, 10,115,101,108,102, 46, 99,111, + 100,101, 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, + 99,111,100,101, 44, 34, 92,110, 37,115, 42, 37, 36, 37, 91, + 34, 44, 34, 92, 49, 34, 41, 10,115,101,108,102, 46, 99,111, + 100,101, 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, + 99,111,100,101, 44, 34, 92,110, 37,115, 42, 37, 36, 37, 93, + 34, 44, 34, 92, 50, 34, 41, 10,115,101,108,102, 46, 99,111, + 100,101, 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, + 99,111,100,101, 44, 34, 40, 37, 98, 92, 49, 92, 50, 41, 34, + 44, 32,102,117,110, 99,116,105,111,110, 32, 40, 99, 41, 10, + 116,105,110,115,101,114,116, 40, 37, 67, 44, 99, 41, 10,114, + 101,116,117,114,110, 32, 34, 92,110, 36, 91, 34, 46, 46,103, + 101,116,110, 40, 37, 67, 41, 46, 46, 34, 93, 36, 34, 10,101, + 110,100, 41, 10, 10, 10,115,101,108,102, 46, 99,111,100,101, + 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, 99,111, + 100,101, 44, 34, 40, 47, 47, 91, 94, 92,110, 93, 42, 41, 34, + 44, 34, 34, 41, 10,115,101,108,102, 46, 99,111,100,101, 32, + 61, 32,103,115,117, 98, 40,115,101,108,102, 46, 99,111,100, + 101, 44, 34, 47, 37, 42, 34, 44, 34, 92, 49, 34, 41, 10,115, + 101,108,102, 46, 99,111,100,101, 32, 61, 32,103,115,117, 98, + 40,115,101,108,102, 46, 99,111,100,101, 44, 34, 37, 42, 47, + 34, 44, 34, 92, 50, 34, 41, 10,115,101,108,102, 46, 99,111, + 100,101, 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, + 99,111,100,101, 44, 34, 37, 98, 92, 49, 92, 50, 34, 44, 34, + 34, 41, 10,115,101,108,102, 46, 99,111,100,101, 32, 61, 32, + 103,115,117, 98, 40,115,101,108,102, 46, 99,111,100,101, 44, + 34, 92, 49, 34, 44, 34, 47, 37, 42, 34, 41, 10,115,101,108, + 102, 46, 99,111,100,101, 32, 61, 32,103,115,117, 98, 40,115, + 101,108,102, 46, 99,111,100,101, 44, 34, 92, 50, 34, 44, 34, + 37, 42, 47, 34, 41, 10,115,101,108,102, 46, 99,111,100,101, + 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, 99,111, + 100,101, 44, 34, 37,115, 42, 64, 37,115, 42, 34, 44, 34, 64, + 34, 41, 10,115,101,108,102, 46, 99,111,100,101, 32, 61, 32, + 103,115,117, 98, 40,115,101,108,102, 46, 99,111,100,101, 44, + 34, 37,115, 63,105,110,108,105,110,101, 40, 37,115, 41, 34, + 44, 34, 37, 49, 34, 41, 10,115,101,108,102, 46, 99,111,100, + 101, 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, 99, + 111,100,101, 44, 34, 37,115, 63,101,120,116,101,114,110, 40, + 37,115, 41, 34, 44, 34, 37, 49, 34, 41, 10,115,101,108,102, + 46, 99,111,100,101, 32, 61, 32,103,115,117, 98, 40,115,101, + 108,102, 46, 99,111,100,101, 44, 34, 37,115, 63,118,105,114, + 116,117, 97,108, 40, 37,115, 41, 34, 44, 34, 37, 49, 34, 41, + 10,115,101,108,102, 46, 99,111,100,101, 32, 61, 32,103,115, + 117, 98, 40,115,101,108,102, 46, 99,111,100,101, 44, 34,112, + 117, 98,108,105, 99, 58, 34, 44, 34, 34, 41, 10,115,101,108, + 102, 46, 99,111,100,101, 32, 61, 32,103,115,117, 98, 40,115, + 101,108,102, 46, 99,111,100,101, 44, 34, 40, 91, 94, 37,119, + 95, 93, 41,118,111,105,100, 37,115, 42, 37, 42, 34, 44, 34, + 37, 49, 95,117,115,101,114,100, 97,116, 97, 32, 34, 41, 10, + 115,101,108,102, 46, 99,111,100,101, 32, 61, 32,103,115,117, + 98, 40,115,101,108,102, 46, 99,111,100,101, 44, 34, 40, 91, + 94, 37,119, 95, 93, 41,118,111,105,100, 37,115, 42, 37, 42, + 34, 44, 34, 37, 49, 95,117,115,101,114,100, 97,116, 97, 32, + 34, 41, 10,115,101,108,102, 46, 99,111,100,101, 32, 61, 32, + 103,115,117, 98, 40,115,101,108,102, 46, 99,111,100,101, 44, + 34, 40, 91, 94, 37,119, 95, 93, 41, 99,104, 97,114, 37,115, + 42, 37, 42, 34, 44, 34, 37, 49, 95, 99,115,116,114,105,110, + 103, 32, 34, 41, 10, 10, 10,115,101,108,102, 46, 99,111,100, + 101, 32, 61, 32,103,115,117, 98, 40,115,101,108,102, 46, 99, + 111,100,101, 44, 34, 37, 36, 37, 91, 40, 37,100, 43, 41, 37, + 93, 37, 36, 34, 44,102,117,110, 99,116,105,111,110, 32, 40, + 110, 41, 10,114,101,116,117,114,110, 32, 37, 67, 91,116,111, + 110,117,109, 98,101,114, 40,110, 41, 93, 10,101,110,100, 41, + 10, 10,115,101,108,102, 46, 99,111,100,101, 32, 61, 32,103, + 115,117, 98, 40,115,101,108,102, 46, 99,111,100,101, 44, 34, + 37, 36, 40, 37,100, 43, 41, 37, 36, 34, 44,102,117,110, 99, + 116,105,111,110, 32, 40,110, 41, 10,114,101,116,117,114,110, + 32, 37, 86, 91,116,111,110,117,109, 98,101,114, 40,110, 41, + 93, 10,101,110,100, 41, 10,101,110,100, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 99,108, 97,115,115, 80, 97, 99, + 107, 97,103,101, 58,112,114,101, 97,109, 98,108,101, 32, 40, + 41, 10,111,117,116,112,117,116, 40, 39, 47, 42, 92,110, 39, + 41, 10,111,117,116,112,117,116, 40, 39, 42, 42, 32, 76,117, + 97, 32, 98,105,110,100,105,110,103, 58, 32, 39, 46, 46,115, + 101,108,102, 46,110, 97,109,101, 46, 46, 39, 92,110, 39, 41, + 10,111,117,116,112,117,116, 40, 39, 42, 42, 32, 71,101,110, + 101,114, 97,116,101,100, 32, 97,117,116,111,109, 97,116,105, + 99, 97,108,108,121, 32, 98,121, 32, 39, 46, 46, 84, 79, 76, + 85, 65, 95, 86, 69, 82, 83, 73, 79, 78, 46, 46, 39, 32,111, + 110, 32, 39, 46, 46,100, 97,116,101, 40, 41, 46, 46, 39, 46, + 92,110, 39, 41, 10,111,117,116,112,117,116, 40, 39, 42, 47, + 92,110, 92,110, 39, 41, 10, 10,111,117,116,112,117,116, 40, + 39, 35,105,110, 99,108,117,100,101, 32, 34,108,117, 97, 47, + 116,111,108,117, 97, 46,104, 34, 92,110, 92,110, 39, 41, 10, + 10,105,102, 32,110,111,116, 32,102,108, 97,103,115, 46,104, + 32,116,104,101,110, 10,111,117,116,112,117,116, 40, 39, 47, + 42, 32, 69,120,112,111,114,116,101,100, 32,102,117,110, 99, + 116,105,111,110, 32, 42, 47, 39, 41, 10,111,117,116,112,117, + 116, 40, 39,105,110,116, 32,116,111,108,117, 97, 95, 39, 46, + 46,115,101,108,102, 46,110, 97,109,101, 46, 46, 39, 95,111, + 112,101,110, 32, 40,108,117, 97, 95, 83,116, 97,116,101, 42, + 32,116,111,108,117, 97, 95, 83, 41, 59, 39, 41, 10,111,117, + 116,112,117,116, 40, 39,118,111,105,100, 32,116,111,108,117, + 97, 95, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, 46, + 46, 39, 95, 99,108,111,115,101, 32, 40,108,117, 97, 95, 83, + 116, 97,116,101, 42, 32,116,111,108,117, 97, 95, 83, 41, 59, + 39, 41, 10,111,117,116,112,117,116, 40, 39, 92,110, 39, 41, + 10,101,110,100, 10, 10,108,111, 99, 97,108, 32,105, 61, 49, + 10,119,104,105,108,101, 32,115,101,108,102, 91,105, 93, 32, + 100,111, 10,115,101,108,102, 91,105, 93, 58,112,114,101, 97, + 109, 98,108,101, 40, 41, 10,105, 32, 61, 32,105, 43, 49, 10, + 101,110,100, 10,111,117,116,112,117,116, 40, 39, 92,110, 39, + 41, 10,111,117,116,112,117,116, 40, 39, 47, 42, 32,102,117, + 110, 99,116,105,111,110, 32,116,111, 32,114,101,103,105,115, + 116,101,114, 32,116,121,112,101, 32, 42, 47, 39, 41, 10,111, + 117,116,112,117,116, 40, 39,115,116, 97,116,105, 99, 32,118, + 111,105,100, 32,116,111,108,117, 97, 73, 95,114,101,103, 95, + 116,121,112,101,115, 32, 40,108,117, 97, 95, 83,116, 97,116, + 101, 42, 32,116,111,108,117, 97, 95, 83, 41, 39, 41, 10,111, + 117,116,112,117,116, 40, 39,123, 39, 41, 10,102,111,114,101, + 97, 99,104, 40, 95,117,115,101,114,116,121,112,101, 44,102, + 117,110, 99,116,105,111,110, 40,110, 44,118, 41, 32,111,117, + 116,112,117,116, 40, 39, 32,116,111,108,117, 97, 95,117,115, + 101,114,116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, + 34, 39, 44,118, 44, 39, 34, 41, 59, 39, 41, 32,101,110,100, + 41, 10,111,117,116,112,117,116, 40, 39,125, 39, 41, 10,111, + 117,116,112,117,116, 40, 39, 92,110, 39, 41, 10, 10,111,117, + 116,112,117,116, 40, 39, 47, 42, 32,101,114,114,111,114, 32, + 109,101,115,115, 97,103,101,115, 32, 42, 47, 39, 41, 10,111, + 117,116,112,117,116, 40, 39, 35,100,101,102,105,110,101, 32, + 84, 79, 76, 85, 65, 95, 69, 82, 82, 95, 83, 69, 76, 70, 32, + 116,111,108,117, 97, 95,101,114,114,111,114, 40,116,111,108, + 117, 97, 95, 83, 44, 92, 34,105,110,118, 97,108,105,100, 32, + 92, 39,115,101,108,102, 92, 39, 92, 34, 41, 39, 41, 10,111, + 117,116,112,117,116, 40, 39, 35,100,101,102,105,110,101, 32, + 84, 79, 76, 85, 65, 95, 69, 82, 82, 95, 65, 83, 83, 73, 71, + 78, 32,116,111,108,117, 97, 95,101,114,114,111,114, 40,116, + 111,108,117, 97, 95, 83, 44, 92, 34, 35,118,105,110,118, 97, + 108,105,100, 32,116,121,112,101, 32,105,110, 32,118, 97,114, + 105, 97, 98,108,101, 32, 97,115,115,105,103,110,109,101,110, + 116, 46, 92, 34, 41, 39, 41, 10,111,117,116,112,117,116, 40, + 39, 92,110, 39, 41, 10,101,110,100, 10, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 99,108, 97,115,115, 80, 97, 99, + 107, 97,103,101, 58,114,101,103,105,115,116,101,114, 32, 40, + 41, 10,111,117,116,112,117,116, 40, 34, 47, 42, 32, 79,112, + 101,110, 32,102,117,110, 99,116,105,111,110, 32, 42, 47, 34, + 41, 10,111,117,116,112,117,116, 40, 34,105,110,116, 32,116, + 111,108,117, 97, 95, 34, 46, 46,115,101,108,102, 46,110, 97, + 109,101, 46, 46, 34, 95,111,112,101,110, 32, 40,108,117, 97, + 95, 83,116, 97,116,101, 42, 32,116,111,108,117, 97, 95, 83, + 41, 34, 41, 10,111,117,116,112,117,116, 40, 34,123, 34, 41, + 10,111,117,116,112,117,116, 40, 34, 32,116,111,108,117, 97, + 95,111,112,101,110, 40,116,111,108,117, 97, 95, 83, 41, 59, + 34, 41, 10,111,117,116,112,117,116, 40, 34, 32,116,111,108, + 117, 97, 73, 95,114,101,103, 95,116,121,112,101,115, 40,116, + 111,108,117, 97, 95, 83, 41, 59, 34, 41, 10,108,111, 99, 97, + 108, 32,105, 61, 49, 10,119,104,105,108,101, 32,115,101,108, + 102, 91,105, 93, 32,100,111, 10,115,101,108,102, 91,105, 93, + 58,114,101,103,105,115,116,101,114, 40, 41, 10,105, 32, 61, + 32,105, 43, 49, 10,101,110,100, 10,111,117,116,112,117,116, + 40, 34, 32,114,101,116,117,114,110, 32, 49, 59, 34, 41, 10, + 111,117,116,112,117,116, 40, 34,125, 34, 41, 10,101,110,100, + 10, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, + 97,115,115, 80, 97, 99,107, 97,103,101, 58,117,110,114,101, + 103,105,115,116,101,114, 32, 40, 41, 10,111,117,116,112,117, + 116, 40, 34, 47, 42, 32, 67,108,111,115,101, 32,102,117,110, + 99,116,105,111,110, 32, 42, 47, 34, 41, 10,111,117,116,112, + 117,116, 40, 34,118,111,105,100, 32,116,111,108,117, 97, 95, + 34, 46, 46,115,101,108,102, 46,110, 97,109,101, 46, 46, 34, + 95, 99,108,111,115,101, 32, 40,108,117, 97, 95, 83,116, 97, + 116,101, 42, 32,116,111,108,117, 97, 95, 83, 41, 34, 41, 10, + 111,117,116,112,117,116, 40, 34,123, 34, 41, 10,108,111, 99, + 97,108, 32,105, 61, 49, 10,119,104,105,108,101, 32,115,101, + 108,102, 91,105, 93, 32,100,111, 10,115,101,108,102, 91,105, + 93, 58,117,110,114,101,103,105,115,116,101,114, 40, 41, 10, + 105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,111,117,116, + 112,117,116, 40, 34,125, 34, 41, 10,101,110,100, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 80, + 97, 99,107, 97,103,101, 58,104,101, 97,100,101,114, 32, 40, + 41, 10,111,117,116,112,117,116, 40, 39, 47, 42, 92,110, 39, + 41, 32,111,117,116,112,117,116, 40, 39, 42, 42, 32, 76,117, + 97, 32, 98,105,110,100,105,110,103, 58, 32, 39, 46, 46,115, + 101,108,102, 46,110, 97,109,101, 46, 46, 39, 92,110, 39, 41, + 10,111,117,116,112,117,116, 40, 39, 42, 42, 32, 71,101,110, + 101,114, 97,116,101,100, 32, 97,117,116,111,109, 97,116,105, + 99, 97,108,108,121, 32, 98,121, 32, 39, 46, 46, 84, 79, 76, + 85, 65, 95, 86, 69, 82, 83, 73, 79, 78, 46, 46, 39, 32,111, + 110, 32, 39, 46, 46,100, 97,116,101, 40, 41, 46, 46, 39, 46, + 92,110, 39, 41, 10,111,117,116,112,117,116, 40, 39, 42, 47, + 92,110, 92,110, 39, 41, 10, 10,105,102, 32,110,111,116, 32, + 102,108, 97,103,115, 46,104, 32,116,104,101,110, 10,111,117, + 116,112,117,116, 40, 39, 47, 42, 32, 69,120,112,111,114,116, + 101,100, 32,102,117,110, 99,116,105,111,110, 32, 42, 47, 39, + 41, 10,111,117,116,112,117,116, 40, 39,105,110,116, 32,116, + 111,108,117, 97, 95, 39, 46, 46,115,101,108,102, 46,110, 97, + 109,101, 46, 46, 39, 95,111,112,101,110, 32, 40,108,117, 97, + 95, 83,116, 97,116,101, 42, 32,116,111,108,117, 97, 95, 83, + 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, 39,118,111, + 105,100, 32,116,111,108,117, 97, 95, 39, 46, 46,115,101,108, + 102, 46,110, 97,109,101, 46, 46, 39, 95, 99,108,111,115,101, + 32, 40,108,117, 97, 95, 83,116, 97,116,101, 42, 32,116,111, + 108,117, 97, 95, 83, 41, 59, 39, 41, 10,111,117,116,112,117, + 116, 40, 39, 92,110, 39, 41, 10,101,110,100, 10,101,110,100, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 95, 80, 97, + 99,107, 97,103,101, 32, 40,116, 41, 10,116, 46, 95, 98, 97, + 115,101, 32, 61, 32, 99,108, 97,115,115, 80, 97, 99,107, 97, + 103,101, 10,115,101,116,116, 97,103, 40,116, 44,116,111,108, + 117, 97, 95,116, 97,103, 41, 10,114,101,116,117,114,110, 32, + 116, 10,101,110,100, 10, 10, 10, 10, 10,102,117,110, 99,116, + 105,111,110, 32, 80, 97, 99,107, 97,103,101, 32, 40,110, 97, + 109,101, 41, 10, 10,108,111, 99, 97,108, 32, 99,111,100,101, + 32, 61, 32,114,101, 97,100, 40, 34, 42, 97, 34, 41, 10, 99, + 111,100,101, 32, 61, 32, 34, 92,110, 34, 32, 46, 46, 32, 99, + 111,100,101, 10, 10,108,111, 99, 97,108, 32,110,115,117, 98, + 115,116, 10,114,101,112,101, 97,116, 10, 99,111,100,101, 44, + 110,115,117, 98,115,116, 32, 61, 32,103,115,117, 98, 40, 99, + 111,100,101, 44, 34, 92,110, 37,115, 42, 37, 36, 60, 40, 46, + 45, 41, 62, 37,115, 42, 92,110, 34, 44,102,117,110, 99,116, + 105,111,110, 32, 40,102,110, 41, 10,108,111, 99, 97,108, 32, + 102,112, 44,109,115,103, 32, 61, 32,111,112,101,110,102,105, + 108,101, 40,102,110, 44, 39,114, 39, 41, 10,105,102, 32,110, + 111,116, 32,102,112, 32,116,104,101,110, 10,101,114,114,111, + 114, 40, 39, 35, 39, 46, 46,109,115,103, 46, 46, 39, 58, 32, + 39, 46, 46,102,110, 41, 10,101,110,100, 10,108,111, 99, 97, + 108, 32,115, 32, 61, 32,114,101, 97,100, 40,102,112, 44, 39, + 42, 97, 39, 41, 10, 99,108,111,115,101,102,105,108,101, 40, + 102,112, 41, 10,114,101,116,117,114,110, 32, 34, 92,110, 34, + 32, 46, 46, 32,115, 10,101,110,100, 41, 10,117,110,116,105, + 108, 32,110,115,117, 98,115,116, 61, 61, 48, 10, 10, 10,108, + 111, 99, 97,108, 32,110,115,117, 98,115,116, 10,114,101,112, + 101, 97,116, 10, 99,111,100,101, 44,110,115,117, 98,115,116, + 32, 61, 10,103,115,117, 98, 40, 99,111,100,101, 44, 34, 92, + 110, 37,115, 42, 37, 36,123, 40, 46, 45, 41,125, 37,115, 42, + 92,110, 34, 44, 10,102,117,110, 99,116,105,111,110, 32, 40, + 102,110, 41, 10,108,111, 99, 97,108, 32,102,112, 44,109,115, + 103, 32, 61, 32,111,112,101,110,102,105,108,101, 40,102,110, + 44, 39,114, 39, 41, 10,105,102, 32,110,111,116, 32,102,112, + 32,116,104,101,110, 10,101,114,114,111,114, 40, 39, 35, 39, + 46, 46,109,115,103, 46, 46, 39, 58, 32, 39, 46, 46,102,110, + 41, 10,101,110,100, 10,108,111, 99, 97,108, 32,115, 32, 61, + 32,114,101, 97,100, 40,102,112, 44, 39, 42, 97, 39, 41, 10, + 99,108,111,115,101,102,105,108,101, 40,102,112, 41, 10, 10, + 108,111, 99, 97,108, 32, 84, 32, 61, 32,123, 99,111,100,101, + 61, 34, 92,110, 34,125, 10,115, 61, 32, 34, 92,110, 34, 32, + 46, 46, 32,115, 32, 46, 46, 32, 34, 92,110, 34, 10, 10,103, + 115,117, 98, 40,115, 44, 34, 92,110, 40, 46, 45, 41, 91, 84, + 116, 93, 91, 79,111, 93, 91, 76,108, 93, 91, 85,117, 93, 91, + 65, 97, 93, 95, 91, 69,101, 93, 91, 88,120, 93, 91, 80,112, + 93, 91, 79,111, 93, 91, 82,114, 93, 91, 84,116, 93, 91, 94, + 92,110, 93, 42, 92,110, 34, 44, 10,102,117,110, 99,116,105, + 111,110, 32, 40, 99, 41, 32, 37, 84, 46, 99,111,100,101, 32, + 61, 32, 37, 84, 46, 99,111,100,101, 32, 46, 46, 32, 99, 32, + 46, 46, 32, 34, 92,110, 34, 32,101,110,100, 10, 41, 10, 10, + 103,115,117, 98, 40,115, 44, 34, 92,110, 91, 94, 92,110, 93, + 42, 91, 84,116, 93, 91, 79,111, 93, 91, 76,108, 93, 91, 85, + 117, 93, 91, 65, 97, 93, 95, 91, 66, 98, 93, 91, 69,101, 93, + 91, 71,103, 93, 91, 73,105, 93, 91, 78,110, 93, 91, 94, 92, + 110, 93, 42, 34, 46, 46, 10, 34, 40, 46, 45, 41, 34, 32, 46, + 46, 10, 34, 92,110, 91, 94, 92,110, 93, 42, 91, 84,116, 93, + 91, 79,111, 93, 91, 76,108, 93, 91, 85,117, 93, 91, 65, 97, + 93, 95, 91, 69,101, 93, 91, 78,110, 93, 91, 68,100, 93, 91, + 94, 92,110, 93, 42, 92,110, 34, 44, 10,102,117,110, 99,116, + 105,111,110, 32, 40, 99, 41, 32, 37, 84, 46, 99,111,100,101, + 32, 61, 32, 37, 84, 46, 99,111,100,101, 32, 46, 46, 32, 99, + 32, 46, 46, 32, 34, 92,110, 34, 32,101,110,100, 10, 41, 10, + 114,101,116,117,114,110, 32, 84, 46, 99,111,100,101, 10,101, + 110,100, 41, 10,117,110,116,105,108, 32,110,115,117, 98,115, + 116, 61, 61, 48, 10, 10,108,111, 99, 97,108, 32,116, 32, 61, + 32, 95, 80, 97, 99,107, 97,103,101, 40, 95, 67,111,110,116, + 97,105,110,101,114,123,110, 97,109,101, 61,110, 97,109,101, + 44, 32, 99,111,100,101, 61, 99,111,100,101,125, 41, 10,112, + 117,115,104, 40,116, 41, 10,116, 58,112,114,101,112,114,111, + 99,101,115,115, 40, 41, 10,116, 58,112, 97,114,115,101, 40, + 116, 46, 99,111,100,101, 41, 10,112,111,112, 40, 41, 10,114, + 101,116,117,114,110, 32,116, 10,101,110,100, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 99, + 108, 97,115,115, 77,111,100,117,108,101, 32, 61, 32,123, 10, + 95, 98, 97,115,101, 32, 61, 32, 99,108, 97,115,115, 67,111, + 110,116, 97,105,110,101,114, 44, 10,116,121,112,101, 32, 61, + 32, 39,109,111,100,117,108,101, 39, 10,125, 10,115,101,116, + 116, 97,103, 40, 99,108, 97,115,115, 77,111,100,117,108,101, + 44,116,111,108,117, 97, 95,116, 97,103, 41, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 77,111, + 100,117,108,101, 58,114,101,103,105,115,116,101,114, 32, 40, + 41, 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, + 97, 95,109,111,100,117,108,101, 40,116,111,108,117, 97, 95, + 83, 44, 34, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, + 46, 46, 39, 34, 41, 59, 39, 41, 10,108,111, 99, 97,108, 32, + 105, 61, 49, 10,119,104,105,108,101, 32,115,101,108,102, 91, + 105, 93, 32,100,111, 10,115,101,108,102, 91,105, 93, 58,114, + 101,103,105,115,116,101,114, 40, 41, 10,105, 32, 61, 32,105, + 43, 49, 10,101,110,100, 10,101,110,100, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 99,108, 97,115,115, 77,111,100, + 117,108,101, 58,117,110,114,101,103,105,115,116,101,114, 32, + 40, 41, 10,111,117,116,112,117,116, 40, 39, 32,108,117, 97, + 95,112,117,115,104,110,105,108, 40,116,111,108,117, 97, 95, + 83, 41, 59, 32,108,117, 97, 95,115,101,116,103,108,111, 98, + 97,108, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, 46, + 115,101,108,102, 46,110, 97,109,101, 46, 46, 39, 34, 41, 59, + 39, 41, 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105, + 111,110, 32, 99,108, 97,115,115, 77,111,100,117,108,101, 58, + 112,114,105,110,116, 32, 40,105,100,101,110,116, 44, 99,108, + 111,115,101, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34, 77,111,100,117,108,101,123, 34, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32,110, + 97,109,101, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46, + 110, 97,109,101, 46, 46, 34, 39, 59, 34, 41, 10,108,111, 99, + 97,108, 32,105, 61, 49, 10,119,104,105,108,101, 32,115,101, + 108,102, 91,105, 93, 32,100,111, 10,115,101,108,102, 91,105, + 93, 58,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, + 34, 32, 34, 44, 34, 44, 34, 41, 10,105, 32, 61, 32,105, 43, + 49, 10,101,110,100, 10,112,114,105,110,116, 40,105,100,101, + 110,116, 46, 46, 34,125, 34, 46, 46, 99,108,111,115,101, 41, + 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 95, 77,111,100,117,108,101, 32, 40,116, 41, 10,116, 46, + 95, 98, 97,115,101, 32, 61, 32, 99,108, 97,115,115, 77,111, + 100,117,108,101, 10,115,101,116,116, 97,103, 40,116, 44,116, + 111,108,117, 97, 95,116, 97,103, 41, 10, 97,112,112,101,110, + 100, 40,116, 41, 10,114,101,116,117,114,110, 32,116, 10,101, + 110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, + 77,111,100,117,108,101, 32, 40,110, 44, 98, 41, 10,108,111, + 99, 97,108, 32,116, 32, 61, 32, 95, 77,111,100,117,108,101, + 40, 95, 67,111,110,116, 97,105,110,101,114,123,110, 97,109, + 101, 61,110,125, 41, 10,112,117,115,104, 40,116, 41, 10,116, + 58,112, 97,114,115,101, 40,115,116,114,115,117, 98, 40, 98, + 44, 50, 44,115,116,114,108,101,110, 40, 98, 41, 45, 49, 41, + 41, 10,112,111,112, 40, 41, 10,114,101,116,117,114,110, 32, + 116, 10,101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115,115, 68, + 101,102,105,110,101, 32, 61, 32,123, 10,110, 97,109,101, 32, + 61, 32, 39, 39, 44, 10, 95, 98, 97,115,101, 32, 61, 32, 99, + 108, 97,115,115, 70,101, 97,116,117,114,101, 44, 10,125, 10, + 115,101,116,116, 97,103, 40, 99,108, 97,115,115, 68,101,102, + 105,110,101, 44,116,111,108,117, 97, 95,116, 97,103, 41, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115, + 115, 68,101,102,105,110,101, 58,114,101,103,105,115,116,101, + 114, 32, 40, 41, 10,108,111, 99, 97,108, 32,112, 32, 61, 32, + 115,101,108,102, 58,105,110,109,111,100,117,108,101, 40, 41, + 10,105,102, 32,112, 32,116,104,101,110, 10,111,117,116,112, + 117,116, 40, 39, 32,116,111,108,117, 97, 95, 99,111,110,115, + 116, 97,110,116, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, + 46, 46,112, 46, 46, 39, 34, 44, 34, 39, 46, 46,115,101,108, + 102, 46,108,110, 97,109,101, 46, 46, 39, 34, 44, 39, 46, 46, + 115,101,108,102, 46,110, 97,109,101, 46, 46, 39, 41, 59, 39, + 41, 10,101,108,115,101, 10,111,117,116,112,117,116, 40, 39, + 32,116,111,108,117, 97, 95, 99,111,110,115,116, 97,110,116, + 40,116,111,108,117, 97, 95, 83, 44, 78, 85, 76, 76, 44, 34, + 39, 46, 46,115,101,108,102, 46,108,110, 97,109,101, 46, 46, + 39, 34, 44, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, + 46, 46, 39, 41, 59, 39, 41, 10,101,110,100, 10,101,110,100, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97, + 115,115, 68,101,102,105,110,101, 58,117,110,114,101,103,105, + 115,116,101,114, 32, 40, 41, 10,105,102, 32,110,111,116, 32, + 115,101,108,102, 58,105,110,109,111,100,117,108,101, 40, 41, + 32,116,104,101,110, 10,111,117,116,112,117,116, 40, 39, 32, + 108,117, 97, 95,112,117,115,104,110,105,108, 40,116,111,108, + 117, 97, 95, 83, 41, 59, 32,108,117, 97, 95,115,101,116,103, + 108,111, 98, 97,108, 40,116,111,108,117, 97, 95, 83, 44, 34, + 39, 46, 46,115,101,108,102, 46,108,110, 97,109,101, 46, 46, + 39, 34, 41, 59, 39, 41, 10,101,110,100, 10,101,110,100, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115, + 115, 68,101,102,105,110,101, 58,112,114,105,110,116, 32, 40, + 105,100,101,110,116, 44, 99,108,111,115,101, 41, 10,112,114, + 105,110,116, 40,105,100,101,110,116, 46, 46, 34, 68,101,102, + 105,110,101,123, 34, 41, 10,112,114,105,110,116, 40,105,100, + 101,110,116, 46, 46, 34, 32,110, 97,109,101, 32, 61, 32, 39, + 34, 46, 46,115,101,108,102, 46,110, 97,109,101, 46, 46, 34, + 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34, 32,108,110, 97,109,101, 32, 61, 32, 39, 34, + 46, 46,115,101,108,102, 46,108,110, 97,109,101, 46, 46, 34, + 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34,125, 34, 46, 46, 99,108,111,115,101, 41, 10, + 101,110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 95, 68,101,102,105,110,101, 32, 40,116, 41, 10,116, 46, + 95, 98, 97,115,101, 32, 61, 32, 99,108, 97,115,115, 68,101, + 102,105,110,101, 10,115,101,116,116, 97,103, 40,116, 44,116, + 111,108,117, 97, 95,116, 97,103, 41, 10, 10,105,102, 32,116, + 46,110, 97,109,101, 32, 61, 61, 32, 39, 39, 32,116,104,101, + 110, 10,101,114,114,111,114, 40, 34, 35,105,110,118, 97,108, + 105,100, 32,100,101,102,105,110,101, 34, 41, 10,101,110,100, + 10, 10, 97,112,112,101,110,100, 40,116, 41, 10,114,101,116, + 117,114,110, 32,116, 10,101,110,100, 10, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 68,101,102,105,110,101, 32, 40, + 110, 41, 10,108,111, 99, 97,108, 32,116, 32, 61, 32,115,112, + 108,105,116, 40,110, 44, 39, 64, 39, 41, 10,114,101,116,117, + 114,110, 32, 95, 68,101,102,105,110,101, 32,123, 10,110, 97, + 109,101, 32, 61, 32,116, 91, 49, 93, 44, 10,108,110, 97,109, + 101, 32, 61, 32,116, 91, 50, 93, 32,111,114, 32,116, 91, 49, + 93, 10,125, 10,101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115,115, 69, + 110,117,109,101,114, 97,116,101, 32, 61, 32,123, 10, 95, 98, + 97,115,101, 32, 61, 32, 99,108, 97,115,115, 70,101, 97,116, + 117,114,101, 44, 10,125, 10,115,101,116,116, 97,103, 40, 99, + 108, 97,115,115, 69,110,117,109,101,114, 97,116,101, 44,116, + 111,108,117, 97, 95,116, 97,103, 41, 10, 10, 10,102,117,110, + 99,116,105,111,110, 32, 99,108, 97,115,115, 69,110,117,109, + 101,114, 97,116,101, 58,114,101,103,105,115,116,101,114, 32, + 40, 41, 10,108,111, 99, 97,108, 32,112, 32, 61, 32,115,101, + 108,102, 58,105,110, 99,108, 97,115,115, 40, 41, 32,111,114, + 32,115,101,108,102, 58,105,110,109,111,100,117,108,101, 40, + 41, 10,108,111, 99, 97,108, 32,105, 61, 49, 10,119,104,105, + 108,101, 32,115,101,108,102, 91,105, 93, 32,100,111, 10,105, + 102, 32,112, 32,116,104,101,110, 10,105,102, 32,115,101,108, + 102, 58,105,110, 99,108, 97,115,115, 40, 41, 32,116,104,101, + 110, 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, + 97, 95, 99,111,110,115,116, 97,110,116, 40,116,111,108,117, + 97, 95, 83, 44, 34, 39, 46, 46,112, 46, 46, 39, 34, 44, 34, + 39, 46, 46,115,101,108,102, 46,108,110, 97,109,101,115, 91, + 105, 93, 46, 46, 39, 34, 44, 39, 46, 46,112, 46, 46, 39, 58, + 58, 39, 46, 46,115,101,108,102, 91,105, 93, 46, 46, 39, 41, + 59, 39, 41, 10,101,108,115,101, 10,111,117,116,112,117,116, + 40, 39, 32,116,111,108,117, 97, 95, 99,111,110,115,116, 97, + 110,116, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, 46, + 112, 46, 46, 39, 34, 44, 34, 39, 46, 46,115,101,108,102, 46, + 108,110, 97,109,101,115, 91,105, 93, 46, 46, 39, 34, 44, 39, + 46, 46,115,101,108,102, 91,105, 93, 46, 46, 39, 41, 59, 39, + 41, 10,101,110,100, 10,101,108,115,101, 10,111,117,116,112, + 117,116, 40, 39, 32,116,111,108,117, 97, 95, 99,111,110,115, + 116, 97,110,116, 40,116,111,108,117, 97, 95, 83, 44, 78, 85, + 76, 76, 44, 34, 39, 46, 46,115,101,108,102, 46,108,110, 97, + 109,101,115, 91,105, 93, 46, 46, 39, 34, 44, 39, 46, 46,115, + 101,108,102, 91,105, 93, 46, 46, 39, 41, 59, 39, 41, 10,101, + 110,100, 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10, + 101,110,100, 10, 10,102,117,110, 99,116,105,111,110, 32, 99, + 108, 97,115,115, 69,110,117,109,101,114, 97,116,101, 58,117, + 110,114,101,103,105,115,116,101,114, 32, 40, 41, 10,105,102, + 32,115,101,108,102, 58,105,110, 99,108, 97,115,115, 40, 41, + 61, 61,110,105,108, 32, 97,110,100, 32,115,101,108,102, 58, + 105,110,109,111,100,117,108,101, 40, 41, 61, 61,110,105,108, + 32,116,104,101,110, 10,108,111, 99, 97,108, 32,105, 61, 49, + 10,119,104,105,108,101, 32,115,101,108,102, 91,105, 93, 32, + 100,111, 10,111,117,116,112,117,116, 40, 39, 32,108,117, 97, + 95,112,117,115,104,110,105,108, 40,116,111,108,117, 97, 95, + 83, 41, 59, 32,108,117, 97, 95,115,101,116,103,108,111, 98, + 97,108, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, 46, + 115,101,108,102, 46,108,110, 97,109,101,115, 91,105, 93, 46, + 46, 39, 34, 41, 59, 39, 41, 10,105, 32, 61, 32,105, 43, 49, + 10,101,110,100, 10,101,110,100, 10,101,110,100, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 69, + 110,117,109,101,114, 97,116,101, 58,112,114,105,110,116, 32, + 40,105,100,101,110,116, 44, 99,108,111,115,101, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 69,110, + 117,109,101,114, 97,116,101,123, 34, 41, 10,108,111, 99, 97, + 108, 32,105, 61, 49, 10,119,104,105,108,101, 32,115,101,108, + 102, 91,105, 93, 32,100,111, 10,112,114,105,110,116, 40,105, + 100,101,110,116, 46, 46, 34, 32, 39, 34, 46, 46,115,101,108, + 102, 91,105, 93, 46, 46, 34, 39, 40, 34, 46, 46,115,101,108, + 102, 46,108,110, 97,109,101,115, 91,105, 93, 46, 46, 34, 41, + 44, 34, 41, 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, + 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, + 125, 34, 46, 46, 99,108,111,115,101, 41, 10,101,110,100, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32, 95, 69,110,117, + 109,101,114, 97,116,101, 32, 40,116, 41, 10,116, 46, 95, 98, + 97,115,101, 32, 61, 32, 99,108, 97,115,115, 69,110,117,109, + 101,114, 97,116,101, 10,115,101,116,116, 97,103, 40,116, 44, + 116,111,108,117, 97, 95,116, 97,103, 41, 10, 97,112,112,101, + 110,100, 40,116, 41, 10,114,101,116,117,114,110, 32,116, 10, + 101,110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 69,110,117,109,101,114, 97,116,101, 32, 40, 98, 41, 10, + 108,111, 99, 97,108, 32,116, 32, 61, 32,115,112,108,105,116, + 40,115,116,114,115,117, 98, 40, 98, 44, 50, 44, 45, 50, 41, + 44, 39, 44, 39, 41, 10,108,111, 99, 97,108, 32,105, 32, 61, + 32, 49, 10,108,111, 99, 97,108, 32,101, 32, 61, 32,123,110, + 61, 48,125, 10,119,104,105,108,101, 32,116, 91,105, 93, 32, + 100,111, 10,108,111, 99, 97,108, 32,116,116, 32, 61, 32,115, + 112,108,105,116, 40,116, 91,105, 93, 44, 39, 61, 39, 41, 10, + 101, 46,110, 32, 61, 32,101, 46,110, 32, 43, 32, 49, 10,101, + 91,101, 46,110, 93, 32, 61, 32,116,116, 91, 49, 93, 10,105, + 32, 61, 32,105, 43, 49, 10,101,110,100, 10, 10,105, 32, 61, + 32, 49, 10,101, 46,108,110, 97,109,101,115, 32, 61, 32,123, + 125, 10,119,104,105,108,101, 32,101, 91,105, 93, 32,100,111, + 10,108,111, 99, 97,108, 32,116, 32, 61, 32,115,112,108,105, + 116, 40,101, 91,105, 93, 44, 39, 64, 39, 41, 10,101, 91,105, + 93, 32, 61, 32,116, 91, 49, 93, 10,101, 46,108,110, 97,109, + 101,115, 91,105, 93, 32, 61, 32,116, 91, 50, 93, 32,111,114, + 32,116, 91, 49, 93, 10,105, 32, 61, 32,105, 43, 49, 10,101, + 110,100, 10,114,101,116,117,114,110, 32, 95, 69,110,117,109, + 101,114, 97,116,101, 40,101, 41, 10,101,110,100, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115,115, 68,101, 99, + 108, 97,114, 97,116,105,111,110, 32, 61, 32,123, 10, 95, 98, + 97,115,101, 32, 61, 32, 99,108, 97,115,115, 70,101, 97,116, + 117,114,101, 44, 10,109,111,100, 32, 61, 32, 39, 39, 44, 10, + 116,121,112,101, 32, 61, 32, 39, 39, 44, 10,112,116,114, 32, + 61, 32, 39, 39, 44, 10,110, 97,109,101, 32, 61, 32, 39, 39, + 44, 10,100,105,109, 32, 61, 32, 39, 39, 44, 10,114,101,116, + 32, 61, 32, 39, 39, 44, 10,100,101,102, 32, 61, 32, 39, 39, + 10,125, 10,115,101,116,116, 97,103, 40, 99,108, 97,115,115, + 68,101, 99,108, 97,114, 97,116,105,111,110, 44,116,111,108, + 117, 97, 95,116, 97,103, 41, 10, 10, 10,102,117,110, 99,116, + 105,111,110, 32, 99,114,101, 97,116,101, 95,118, 97,114,110, + 97,109,101, 32, 40, 41, 10,105,102, 32,110,111,116, 32, 95, + 118, 97,114,110,117,109, 98,101,114, 32,116,104,101,110, 32, + 95,118, 97,114,110,117,109, 98,101,114, 32, 61, 32, 48, 32, + 101,110,100, 10, 95,118, 97,114,110,117,109, 98,101,114, 32, + 61, 32, 95,118, 97,114,110,117,109, 98,101,114, 32, 43, 32, + 49, 10,114,101,116,117,114,110, 32, 34,116,111,108,117, 97, + 95,118, 97,114, 95, 34, 46, 46, 95,118, 97,114,110,117,109, + 98,101,114, 10,101,110,100, 10, 10, 10, 10,102,117,110, 99, + 116,105,111,110, 32, 99,108, 97,115,115, 68,101, 99,108, 97, + 114, 97,116,105,111,110, 58, 99,104,101, 99,107,110, 97,109, + 101, 32, 40, 41, 10, 10,105,102, 32,115,116,114,115,117, 98, + 40,115,101,108,102, 46,110, 97,109,101, 44, 49, 44, 49, 41, + 32, 61, 61, 32, 39, 91, 39, 32, 97,110,100, 32,110,111,116, + 32,105,115,116,121,112,101, 40,115,101,108,102, 46,116,121, + 112,101, 41, 32,116,104,101,110, 10,115,101,108,102, 46,110, + 97,109,101, 32, 61, 32,115,101,108,102, 46,116,121,112,101, + 46, 46,115,101,108,102, 46,110, 97,109,101, 10,108,111, 99, + 97,108, 32,109, 32, 61, 32,115,112,108,105,116, 40,115,101, + 108,102, 46,109,111,100, 44, 39, 37,115, 37,115, 42, 39, 41, + 10,115,101,108,102, 46,116,121,112,101, 32, 61, 32,109, 91, + 109, 46,110, 93, 10,115,101,108,102, 46,109,111,100, 32, 61, + 32, 99,111,110, 99, 97,116, 40,109, 44, 49, 44,109, 46,110, + 45, 49, 41, 10,101,110,100, 10, 10,108,111, 99, 97,108, 32, + 116, 32, 61, 32,115,112,108,105,116, 40,115,101,108,102, 46, + 110, 97,109,101, 44, 39, 61, 39, 41, 10,105,102, 32,116, 46, + 110, 61, 61, 50, 32,116,104,101,110, 10,115,101,108,102, 46, + 110, 97,109,101, 32, 61, 32,116, 91, 49, 93, 10,115,101,108, + 102, 46,100,101,102, 32, 61, 32,116, 91,116, 46,110, 93, 10, + 101,110,100, 10, 10,108,111, 99, 97,108, 32, 98, 44,101, 44, + 100, 32, 61, 32,115,116,114,102,105,110,100, 40,115,101,108, + 102, 46,110, 97,109,101, 44, 34, 37, 91, 40, 46, 45, 41, 37, + 93, 34, 41, 10,105,102, 32, 98, 32,116,104,101,110, 10,115, + 101,108,102, 46,110, 97,109,101, 32, 61, 32,115,116,114,115, + 117, 98, 40,115,101,108,102, 46,110, 97,109,101, 44, 49, 44, + 98, 45, 49, 41, 10,115,101,108,102, 46,100,105,109, 32, 61, + 32,100, 10,101,110,100, 10, 10, 10,105,102, 32,115,101,108, + 102, 46,116,121,112,101, 32,126, 61, 32, 39, 39, 32, 97,110, + 100, 32,115,101,108,102, 46,116,121,112,101, 32,126, 61, 32, + 39,118,111,105,100, 39, 32, 97,110,100, 32,115,101,108,102, + 46,110, 97,109,101, 32, 61, 61, 32, 39, 39, 32,116,104,101, + 110, 10,115,101,108,102, 46,110, 97,109,101, 32, 61, 32, 99, + 114,101, 97,116,101, 95,118, 97,114,110, 97,109,101, 40, 41, + 10,101,108,115,101,105,102, 32,115,101,108,102, 46,107,105, + 110,100, 61, 61, 39,118, 97,114, 39, 32,116,104,101,110, 10, + 105,102, 32,115,101,108,102, 46,116,121,112,101, 61, 61, 39, + 39, 32, 97,110,100, 32,115,101,108,102, 46,110, 97,109,101, + 126, 61, 39, 39, 32,116,104,101,110, 10,115,101,108,102, 46, + 116,121,112,101, 32, 61, 32,115,101,108,102, 46,116,121,112, + 101, 46, 46,115,101,108,102, 46,110, 97,109,101, 10,115,101, + 108,102, 46,110, 97,109,101, 32, 61, 32, 99,114,101, 97,116, + 101, 95,118, 97,114,110, 97,109,101, 40, 41, 10,101,108,115, + 101,105,102, 32,105,115,116,121,112,101, 40,115,101,108,102, + 46,110, 97,109,101, 41, 32,116,104,101,110, 10,105,102, 32, + 115,101,108,102, 46,116,121,112,101, 61, 61, 39, 39, 32,116, + 104,101,110, 32,115,101,108,102, 46,116,121,112,101, 32, 61, + 32,115,101,108,102, 46,110, 97,109,101, 10,101,108,115,101, + 32,115,101,108,102, 46,116,121,112,101, 32, 61, 32,115,101, + 108,102, 46,116,121,112,101, 46, 46, 39, 32, 39, 46, 46,115, + 101,108,102, 46,110, 97,109,101, 32,101,110,100, 10,115,101, + 108,102, 46,110, 97,109,101, 32, 61, 32, 99,114,101, 97,116, + 101, 95,118, 97,114,110, 97,109,101, 40, 41, 10,101,110,100, + 10,101,110,100, 10, 10,101,110,100, 10, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 99,108, 97,115,115, 68,101, 99, + 108, 97,114, 97,116,105,111,110, 58, 99,104,101, 99,107,116, + 121,112,101, 32, 40, 41, 10, 10, 10,105,102, 32,105,115, 98, + 97,115,105, 99, 40,115,101,108,102, 46,116,121,112,101, 41, + 32, 97,110,100, 32,115,101,108,102, 46,112,116,114,126, 61, + 39, 39, 32,116,104,101,110, 10,115,101,108,102, 46,114,101, + 116, 32, 61, 32,115,101,108,102, 46,112,116,114, 10,115,101, + 108,102, 46,112,116,114, 32, 61, 32,110,105,108, 10,101,110, + 100, 10, 10, 10,105,102, 32,115,101,108,102, 46,100,105,109, + 126, 61, 39, 39, 32, 97,110,100, 32,115,101,108,102, 46,114, + 101,116,126, 61, 39, 39, 32,116,104,101,110, 10,101,114,114, + 111,114, 40, 39, 35,105,110,118, 97,108,105,100, 32,112, 97, + 114, 97,109,101,116,101,114, 58, 32, 99, 97,110,110,111,116, + 32,114,101,116,117,114,110, 32, 97,110, 32, 97,114,114, 97, + 121, 32,111,102, 32,118, 97,108,117,101,115, 39, 41, 10,101, + 110,100, 10, 10, 10,105,102, 32,115,101,108,102, 46,116,121, + 112,101,126, 61, 39, 39, 32,116,104,101,110, 10,114,101,103, + 116,121,112,101, 40,115,101,108,102, 46,116,121,112,101, 41, + 10,101,110,100, 10, 10, 10,105,102, 32,115,101,108,102, 46, + 116,121,112,101, 32, 61, 61, 32, 39, 95,117,115,101,114,100, + 97,116, 97, 39, 32,116,104,101,110, 32,115,101,108,102, 46, + 116,121,112,101, 32, 61, 32, 39,118,111,105,100, 42, 39, 10, + 101,108,115,101,105,102, 32,115,101,108,102, 46,116,121,112, + 101, 32, 61, 61, 32, 39, 95, 99,115,116,114,105,110,103, 39, + 32,116,104,101,110, 32,115,101,108,102, 46,116,121,112,101, + 32, 61, 32, 39, 99,104, 97,114, 42, 39, 10,101,110,100, 10, + 10, 10, 10, 10, 10, 10, 10, 10,101,110,100, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 68,101, + 99,108, 97,114, 97,116,105,111,110, 58,112,114,105,110,116, + 32, 40,105,100,101,110,116, 44, 99,108,111,115,101, 41, 10, + 112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 68, + 101, 99,108, 97,114, 97,116,105,111,110,123, 34, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32,109, + 111,100, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,109, + 111,100, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, + 40,105,100,101,110,116, 46, 46, 34, 32,116,121,112,101, 32, + 61, 32, 39, 34, 46, 46,115,101,108,102, 46,116,121,112,101, + 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105, + 100,101,110,116, 46, 46, 34, 32,112,116,114, 32, 61, 32, 39, + 34, 46, 46,115,101,108,102, 46,112,116,114, 46, 46, 34, 39, + 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, + 46, 46, 34, 32,110, 97,109,101, 32, 61, 32, 39, 34, 46, 46, + 115,101,108,102, 46,110, 97,109,101, 46, 46, 34, 39, 44, 34, + 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, + 34, 32,100,105,109, 32, 61, 32, 39, 34, 46, 46,115,101,108, + 102, 46,100,105,109, 46, 46, 34, 39, 44, 34, 41, 10,112,114, + 105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32,100,101, + 102, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,100,101, + 102, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40, + 105,100,101,110,116, 46, 46, 34, 32,114,101,116, 32, 61, 32, + 39, 34, 46, 46,115,101,108,102, 46,114,101,116, 46, 46, 34, + 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34,125, 34, 46, 46, 99,108,111,115,101, 41, 10, + 101,110,100, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, + 99,108, 97,115,115, 68,101, 99,108, 97,114, 97,116,105,111, + 110, 58,100,101, 99,108,116, 97,103, 32, 40, 41, 10,115,101, + 108,102, 46,105,116,121,112,101, 44, 32,115,101,108,102, 46, + 116, 97,103, 32, 61, 32,116, 97,103,118, 97,114, 40,115,101, + 108,102, 46,116,121,112,101, 44,115,116,114,102,105,110,100, + 40,115,101,108,102, 46,109,111,100, 44, 39, 99,111,110,115, + 116, 39, 41, 41, 10,101,110,100, 10, 10, 10, 10,102,117,110, + 99,116,105,111,110, 32, 99,108, 97,115,115, 68,101, 99,108, + 97,114, 97,116,105,111,110, 58,111,117,116, 99,104,101, 99, + 107,116,121,112,101, 32, 40,110, 97,114,103, 41, 10,108,111, + 99, 97,108, 32,116, 97,103, 44, 32,100,101,102, 10,105,102, + 32,115,101,108,102, 46,100,105,109, 32,126, 61, 32, 39, 39, + 32,116,104,101,110, 10,116, 97,103, 32, 61, 32, 39, 76, 85, + 65, 95, 84, 84, 65, 66, 76, 69, 39, 10,100,101,102, 32, 61, + 32, 48, 10,101,108,115,101, 10,116, 97,103, 32, 61, 32,115, + 101,108,102, 46,116, 97,103, 10,100,101,102, 32, 61, 32,115, + 101,108,102, 46,100,101,102,126, 61, 39, 39, 32,111,114, 32, + 48, 10,101,110,100, 10,114,101,116,117,114,110, 32, 39,116, + 111,108,117, 97, 95,105,115,116,121,112,101, 40,116,111,108, + 117, 97, 95, 83, 44, 39, 46, 46,110, 97,114,103, 46, 46, 39, + 44, 39, 46, 46,116, 97,103, 46, 46, 39, 44, 39, 46, 46,100, + 101,102, 46, 46, 39, 41, 39, 10,101,110,100, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 68,101, + 99,108, 97,114, 97,116,105,111,110, 58,100,101, 99,108, 97, + 114,101, 32, 40,110, 97,114,103, 41, 10,108,111, 99, 97,108, + 32,112,116,114, 32, 61, 32, 39, 39, 10,105,102, 32,115,101, + 108,102, 46,112,116,114,126, 61, 39, 39, 32,116,104,101,110, + 32,112,116,114, 32, 61, 32, 39, 42, 39, 32,101,110,100, 10, + 111,117,116,112,117,116, 40, 34, 32, 34, 44,115,101,108,102, + 46,109,111,100, 44,115,101,108,102, 46,116,121,112,101, 44, + 112,116,114, 41, 10,105,102, 32,115,101,108,102, 46,100,105, + 109, 32,126, 61, 32, 39, 39, 32, 97,110,100, 32,116,111,110, + 117,109, 98,101,114, 40,115,101,108,102, 46,100,105,109, 41, + 61, 61,110,105,108, 32,116,104,101,110, 10,111,117,116,112, + 117,116, 40, 39, 42, 39, 41, 10,101,110,100, 10,111,117,116, + 112,117,116, 40,115,101,108,102, 46,110, 97,109,101, 41, 10, + 105,102, 32,115,101,108,102, 46,100,105,109, 32,126, 61, 32, + 39, 39, 32,116,104,101,110, 10,105,102, 32,116,111,110,117, + 109, 98,101,114, 40,115,101,108,102, 46,100,105,109, 41,126, + 61,110,105,108, 32,116,104,101,110, 10,111,117,116,112,117, + 116, 40, 39, 91, 39, 44,115,101,108,102, 46,100,105,109, 44, + 39, 93, 59, 39, 41, 10,101,108,115,101, 10,111,117,116,112, + 117,116, 40, 39, 32, 61, 32, 40, 39, 44,115,101,108,102, 46, + 109,111,100, 44,115,101,108,102, 46,116,121,112,101, 44,112, + 116,114, 44, 39, 42, 41, 39, 44, 10, 39,109, 97,108,108,111, + 99, 40, 39, 44,115,101,108,102, 46,100,105,109, 44, 39, 42, + 115,105,122,101,111,102, 40, 39, 44,115,101,108,102, 46,116, + 121,112,101, 44,112,116,114, 44, 39, 41, 41, 59, 39, 41, 10, + 101,110,100, 10,101,108,115,101, 10,108,111, 99, 97,108, 32, + 116, 32, 61, 32,105,115, 98, 97,115,105, 99, 40,115,101,108, + 102, 46,116,121,112,101, 41, 10,111,117,116,112,117,116, 40, + 39, 32, 61, 32, 39, 41, 10,105,102, 32,110,111,116, 32,116, + 32, 97,110,100, 32,112,116,114, 61, 61, 39, 39, 32,116,104, + 101,110, 32,111,117,116,112,117,116, 40, 39, 42, 39, 41, 32, + 101,110,100, 10,111,117,116,112,117,116, 40, 39, 40, 40, 39, + 44,115,101,108,102, 46,109,111,100, 44,115,101,108,102, 46, + 116,121,112,101, 41, 10,105,102, 32,110,111,116, 32,116, 32, + 116,104,101,110, 10,111,117,116,112,117,116, 40, 39, 42, 39, + 41, 10,101,110,100, 10,111,117,116,112,117,116, 40, 39, 41, + 32, 39, 41, 10,108,111, 99, 97,108, 32,100,101,102, 32, 61, + 32, 48, 10,105,102, 32,115,101,108,102, 46,100,101,102, 32, + 126, 61, 32, 39, 39, 32,116,104,101,110, 32,100,101,102, 32, + 61, 32,115,101,108,102, 46,100,101,102, 32,101,110,100, 10, + 105,102, 32,116, 32,116,104,101,110, 10,111,117,116,112,117, + 116, 40, 39,116,111,108,117, 97, 95,103,101,116, 39, 46, 46, + 116, 44, 39, 40,116,111,108,117, 97, 95, 83, 44, 39, 44,110, + 97,114,103, 44, 39, 44, 39, 44,100,101,102, 44, 39, 41, 41, + 59, 39, 41, 10,101,108,115,101, 10,111,117,116,112,117,116, + 40, 39,116,111,108,117, 97, 95,103,101,116,117,115,101,114, + 116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 39, 44, + 110, 97,114,103, 44, 39, 44, 39, 44,100,101,102, 44, 39, 41, + 41, 59, 39, 41, 10,101,110,100, 10,101,110,100, 10,101,110, + 100, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, + 97,115,115, 68,101, 99,108, 97,114, 97,116,105,111,110, 58, + 103,101,116, 97,114,114, 97,121, 32, 40,110, 97,114,103, 41, + 10,105,102, 32,115,101,108,102, 46,100,105,109, 32,126, 61, + 32, 39, 39, 32,116,104,101,110, 10,111,117,116,112,117,116, + 40, 39, 32,123, 39, 41, 10,108,111, 99, 97,108, 32,100,101, + 102, 32, 61, 32,115,101,108,102, 46,100,101,102,126, 61, 39, + 39, 32,111,114, 32, 48, 10,111,117,116,112,117,116, 40, 39, + 32,105,102, 32, 40, 33,116,111,108,117, 97, 95, 97,114,114, + 97,121,105,115,116,121,112,101, 40,116,111,108,117, 97, 95, + 83, 44, 39, 44,110, 97,114,103, 44, 39, 44, 39, 44,115,101, + 108,102, 46,116, 97,103, 44, 39, 44, 39, 44,115,101,108,102, + 46,100,105,109, 44, 39, 44, 39, 44,100,101,102, 44, 39, 41, + 41, 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,103,111, + 116,111, 32,116,111,108,117, 97, 95,108,101,114,114,111,114, + 59, 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,101,108, + 115,101, 92,110, 39, 41, 10,111,117,116,112,117,116, 40, 39, + 32,123, 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,105, + 110,116, 32,105, 59, 39, 41, 10,111,117,116,112,117,116, 40, + 39, 32,102,111,114, 40,105, 61, 48, 59, 32,105, 60, 39, 46, + 46,115,101,108,102, 46,100,105,109, 46, 46, 39, 59,105, 43, + 43, 41, 39, 41, 10,108,111, 99, 97,108, 32,116, 32, 61, 32, + 105,115, 98, 97,115,105, 99, 40,115,101,108,102, 46,116,121, + 112,101, 41, 10,108,111, 99, 97,108, 32,112,116,114, 32, 61, + 32, 39, 39, 10,105,102, 32,115,101,108,102, 46,112,116,114, + 126, 61, 39, 39, 32,116,104,101,110, 32,112,116,114, 32, 61, + 32, 39, 42, 39, 32,101,110,100, 10,111,117,116,112,117,116, + 40, 39, 32, 39, 44,115,101,108,102, 46,110, 97,109,101, 46, + 46, 39, 91,105, 93, 32, 61, 32, 39, 41, 10,105,102, 32,110, + 111,116, 32,116, 32, 97,110,100, 32,112,116,114, 61, 61, 39, + 39, 32,116,104,101,110, 32,111,117,116,112,117,116, 40, 39, + 42, 39, 41, 32,101,110,100, 10,111,117,116,112,117,116, 40, + 39, 40, 40, 39, 44,115,101,108,102, 46,109,111,100, 44,115, + 101,108,102, 46,116,121,112,101, 41, 10,105,102, 32,110,111, + 116, 32,116, 32,116,104,101,110, 10,111,117,116,112,117,116, + 40, 39, 42, 39, 41, 10,101,110,100, 10,111,117,116,112,117, + 116, 40, 39, 41, 32, 39, 41, 10,108,111, 99, 97,108, 32,100, + 101,102, 32, 61, 32, 48, 10,105,102, 32,115,101,108,102, 46, + 100,101,102, 32,126, 61, 32, 39, 39, 32,116,104,101,110, 32, + 100,101,102, 32, 61, 32,115,101,108,102, 46,100,101,102, 32, + 101,110,100, 10,105,102, 32,116, 32,116,104,101,110, 10,111, + 117,116,112,117,116, 40, 39,116,111,108,117, 97, 95,103,101, + 116,102,105,101,108,100, 39, 46, 46,116, 46, 46, 39, 40,116, + 111,108,117, 97, 95, 83, 44, 39, 44,110, 97,114,103, 44, 39, + 44,105, 43, 49, 44, 39, 44,100,101,102, 44, 39, 41, 41, 59, + 39, 41, 10,101,108,115,101, 10,111,117,116,112,117,116, 40, + 39,116,111,108,117, 97, 95,103,101,116,102,105,101,108,100, + 117,115,101,114,116,121,112,101, 40,116,111,108,117, 97, 95, + 83, 44, 39, 44,110, 97,114,103, 44, 39, 44,105, 43, 49, 44, + 39, 44,100,101,102, 44, 39, 41, 41, 59, 39, 41, 10,101,110, + 100, 10,111,117,116,112,117,116, 40, 39, 32,125, 39, 41, 10, + 111,117,116,112,117,116, 40, 39, 32,125, 39, 41, 10,101,110, + 100, 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105,111, + 110, 32, 99,108, 97,115,115, 68,101, 99,108, 97,114, 97,116, + 105,111,110, 58,115,101,116, 97,114,114, 97,121, 32, 40,110, + 97,114,103, 41, 10,105,102, 32,115,101,108,102, 46,100,105, + 109, 32,126, 61, 32, 39, 39, 32,116,104,101,110, 10,111,117, + 116,112,117,116, 40, 39, 32,123, 39, 41, 10,111,117,116,112, + 117,116, 40, 39, 32,105,110,116, 32,105, 59, 39, 41, 10,111, + 117,116,112,117,116, 40, 39, 32,102,111,114, 40,105, 61, 48, + 59, 32,105, 60, 39, 46, 46,115,101,108,102, 46,100,105,109, + 46, 46, 39, 59,105, 43, 43, 41, 39, 41, 10,108,111, 99, 97, + 108, 32,116, 44, 99,116, 32, 61, 32,105,115, 98, 97,115,105, + 99, 40,115,101,108,102, 46,116,121,112,101, 41, 10,105,102, + 32,116, 32,116,104,101,110, 10,111,117,116,112,117,116, 40, + 39, 32,116,111,108,117, 97, 95,112,117,115,104,102,105,101, + 108,100, 39, 46, 46,116, 46, 46, 39, 40,116,111,108,117, 97, + 95, 83, 44, 39, 44,110, 97,114,103, 44, 39, 44,105, 43, 49, + 44, 40, 39, 44, 99,116, 44, 39, 41, 39, 44,115,101,108,102, + 46,110, 97,109,101, 44, 39, 91,105, 93, 41, 59, 39, 41, 10, + 101,108,115,101, 10,105,102, 32,115,101,108,102, 46,112,116, + 114, 32, 61, 61, 32, 39, 39, 32,116,104,101,110, 10,111,117, + 116,112,117,116, 40, 39, 32,123, 39, 41, 10,111,117,116,112, + 117,116, 40, 39, 35,105,102,100,101,102, 32, 95, 95, 99,112, + 108,117,115,112,108,117,115, 92,110, 39, 41, 10,111,117,116, + 112,117,116, 40, 39, 32,118,111,105,100, 42, 32,116,111,108, + 117, 97, 73, 95, 99,108,111,110,101, 32, 61, 32,110,101,119, + 39, 44,115,101,108,102, 46,116,121,112,101, 44, 39, 40, 39, + 44,115,101,108,102, 46,110, 97,109,101, 44, 39, 91,105, 93, + 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, 39, 35,101, + 108,115,101, 92,110, 39, 41, 10,111,117,116,112,117,116, 40, + 39, 32,118,111,105,100, 42, 32,116,111,108,117, 97, 73, 95, + 99,108,111,110,101, 32, 61, 32,116,111,108,117, 97, 95, 99, + 111,112,121, 40,116,111,108,117, 97, 95, 83, 44, 40,118,111, + 105,100, 42, 41, 38, 39, 44,115,101,108,102, 46,110, 97,109, + 101, 44, 39, 91,105, 93, 44,115,105,122,101,111,102, 40, 39, + 44,115,101,108,102, 46,116,121,112,101, 44, 39, 41, 41, 59, + 39, 41, 10,111,117,116,112,117,116, 40, 39, 35,101,110,100, + 105,102, 92,110, 39, 41, 10,111,117,116,112,117,116, 40, 39, + 32,116,111,108,117, 97, 95,112,117,115,104,102,105,101,108, + 100,117,115,101,114,116,121,112,101, 40,116,111,108,117, 97, + 95, 83, 44, 39, 44,110, 97,114,103, 44, 39, 44,105, 43, 49, + 44,116,111,108,117, 97, 95,100,111, 99,108,111,110,101, 40, + 116,111,108,117, 97, 95, 83, 44,116,111,108,117, 97, 73, 95, + 99,108,111,110,101, 44, 39, 44,115,101,108,102, 46,116, 97, + 103, 44, 39, 41, 44, 39, 44,115,101,108,102, 46,116, 97,103, + 44, 39, 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, 39, + 32,125, 39, 41, 10, 10, 10,101,108,115,101, 10,111,117,116, + 112,117,116, 40, 39, 32,116,111,108,117, 97, 95,112,117,115, + 104,102,105,101,108,100,117,115,101,114,116,121,112,101, 40, + 116,111,108,117, 97, 95, 83, 44, 39, 44,110, 97,114,103, 44, + 39, 44,105, 43, 49, 44, 40,118,111,105,100, 42, 41, 39, 44, + 115,101,108,102, 46,110, 97,109,101, 44, 39, 91,105, 93, 44, + 39, 44,115,101,108,102, 46,116, 97,103, 44, 39, 41, 59, 39, + 41, 10,101,110,100, 10,101,110,100, 10,111,117,116,112,117, + 116, 40, 39, 32,125, 39, 41, 10,101,110,100, 10,101,110,100, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97, + 115,115, 68,101, 99,108, 97,114, 97,116,105,111,110, 58,102, + 114,101,101, 97,114,114, 97,121, 32, 40, 41, 10,105,102, 32, + 115,101,108,102, 46,100,105,109, 32,126, 61, 32, 39, 39, 32, + 97,110,100, 32,116,111,110,117,109, 98,101,114, 40,115,101, + 108,102, 46,100,105,109, 41, 61, 61,110,105,108, 32,116,104, + 101,110, 10,111,117,116,112,117,116, 40, 39, 32,102,114,101, + 101, 40, 39, 44,115,101,108,102, 46,110, 97,109,101, 44, 39, + 41, 59, 39, 41, 10,101,110,100, 10,101,110,100, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 68, + 101, 99,108, 97,114, 97,116,105,111,110, 58,112, 97,115,115, + 112, 97,114, 32, 40, 41, 10,105,102, 32,115,101,108,102, 46, + 112,116,114, 61, 61, 39, 38, 39, 32,116,104,101,110, 10,111, + 117,116,112,117,116, 40, 39, 42, 39, 46, 46,115,101,108,102, + 46,110, 97,109,101, 41, 10,101,108,115,101,105,102, 32,115, + 101,108,102, 46,114,101,116, 61, 61, 39, 42, 39, 32,116,104, + 101,110, 10,111,117,116,112,117,116, 40, 39, 38, 39, 46, 46, + 115,101,108,102, 46,110, 97,109,101, 41, 10,101,108,115,101, + 10,111,117,116,112,117,116, 40,115,101,108,102, 46,110, 97, + 109,101, 41, 10,101,110,100, 10,101,110,100, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 68,101, + 99,108, 97,114, 97,116,105,111,110, 58,114,101,116,118, 97, + 108,117,101, 32, 40, 41, 10,105,102, 32,115,101,108,102, 46, + 114,101,116, 32,126, 61, 32, 39, 39, 32,116,104,101,110, 10, + 108,111, 99, 97,108, 32,116, 44, 99,116, 32, 61, 32,105,115, + 98, 97,115,105, 99, 40,115,101,108,102, 46,116,121,112,101, + 41, 10,105,102, 32,116, 32,116,104,101,110, 10,111,117,116, + 112,117,116, 40, 39, 32,116,111,108,117, 97, 95,112,117,115, + 104, 39, 46, 46,116, 46, 46, 39, 40,116,111,108,117, 97, 95, + 83, 44, 40, 39, 44, 99,116, 44, 39, 41, 39, 46, 46,115,101, + 108,102, 46,110, 97,109,101, 46, 46, 39, 41, 59, 39, 41, 10, + 101,108,115,101, 10,111,117,116,112,117,116, 40, 39, 32,116, + 111,108,117, 97, 95,112,117,115,104,117,115,101,114,116,121, + 112,101, 40,116,111,108,117, 97, 95, 83, 44, 40,118,111,105, + 100, 42, 41, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, + 46, 46, 39, 44, 39, 44,115,101,108,102, 46,116, 97,103, 44, + 39, 41, 59, 39, 41, 10,101,110,100, 10,114,101,116,117,114, + 110, 32, 49, 10,101,110,100, 10,114,101,116,117,114,110, 32, + 48, 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105,111, + 110, 32, 95, 68,101, 99,108, 97,114, 97,116,105,111,110, 32, + 40,116, 41, 10,105,102, 32,116, 46,110, 97,109,101, 32, 97, + 110,100, 32,116, 46,110, 97,109,101,126, 61, 39, 39, 32,116, + 104,101,110, 10,108,111, 99, 97,108, 32,110, 32, 61, 32,115, + 112,108,105,116, 40,116, 46,110, 97,109,101, 44, 39, 64, 39, + 41, 10,116, 46,110, 97,109,101, 32, 61, 32,110, 91, 49, 93, + 10,116, 46,108,110, 97,109,101, 32, 61, 32,103,115,117, 98, + 40,110, 91, 50, 93, 32,111,114, 32,110, 91, 49, 93, 44, 34, + 37, 91, 46, 45, 37, 93, 34, 44, 34, 34, 41, 10,101,110,100, + 10,116, 46, 95, 98, 97,115,101, 32, 61, 32, 99,108, 97,115, + 115, 68,101, 99,108, 97,114, 97,116,105,111,110, 10,115,101, + 116,116, 97,103, 40,116, 44,116,111,108,117, 97, 95,116, 97, + 103, 41, 10,116, 58, 99,104,101, 99,107,110, 97,109,101, 40, + 41, 10,116, 58, 99,104,101, 99,107,116,121,112,101, 40, 41, + 10,114,101,116,117,114,110, 32,116, 10,101,110,100, 10, 10, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 68,101, 99, + 108, 97,114, 97,116,105,111,110, 32, 40,115, 44,107,105,110, + 100, 41, 10, 10,115, 32, 61, 32,103,115,117, 98, 40,115, 44, + 34, 37,115, 42, 61, 37,115, 42, 34, 44, 34, 61, 34, 41, 10, + 10,105,102, 32,107,105,110,100, 32, 61, 61, 32, 34,118, 97, + 114, 34, 32,116,104,101,110, 10, 10,105,102, 32,115, 32, 61, + 61, 32, 39, 39, 32,111,114, 32,115, 32, 61, 61, 32, 39,118, + 111,105,100, 39, 32,116,104,101,110, 10,114,101,116,117,114, + 110, 32, 95, 68,101, 99,108, 97,114, 97,116,105,111,110,123, + 116,121,112,101, 32, 61, 32, 39,118,111,105,100, 39, 44, 32, + 107,105,110,100, 32, 61, 32,107,105,110,100,125, 10,101,110, + 100, 10,101,110,100, 10, 10, 10,108,111, 99, 97,108, 32,116, + 32, 61, 32,115,112,108,105,116, 40,115, 44, 39, 37, 42, 37, + 115, 42, 38, 39, 41, 10,105,102, 32,116, 46,110, 32, 61, 61, + 32, 50, 32,116,104,101,110, 10,105,102, 32,107,105,110,100, + 32, 61, 61, 32, 39,102,117,110, 99, 39, 32,116,104,101,110, + 10,101,114,114,111,114, 40, 34, 35,105,110,118, 97,108,105, + 100, 32,102,117,110, 99,116,105,111,110, 32,114,101,116,117, + 114,110, 32,116,121,112,101, 58, 32, 34, 46, 46,115, 41, 10, + 101,110,100, 10,108,111, 99, 97,108, 32,109, 32, 61, 32,115, + 112,108,105,116, 40,116, 91, 49, 93, 44, 39, 37,115, 37,115, + 42, 39, 41, 10,114,101,116,117,114,110, 32, 95, 68,101, 99, + 108, 97,114, 97,116,105,111,110,123, 10,110, 97,109,101, 32, + 61, 32,116, 91, 50, 93, 44, 10,112,116,114, 32, 61, 32, 39, + 42, 39, 44, 10,114,101,116, 32, 61, 32, 39, 38, 39, 44, 10, + 116,121,112,101, 32, 61, 32,109, 91,109, 46,110, 93, 44, 10, + 109,111,100, 32, 61, 32, 99,111,110, 99, 97,116, 40,109, 44, + 49, 44,109, 46,110, 45, 49, 41, 44, 10,107,105,110,100, 32, + 61, 32,107,105,110,100, 10,125, 10,101,110,100, 10, 10, 10, + 116, 32, 61, 32,115,112,108,105,116, 40,115, 44, 39, 37, 42, + 37,115, 42, 37, 42, 39, 41, 10,105,102, 32,116, 46,110, 32, + 61, 61, 32, 50, 32,116,104,101,110, 10,105,102, 32,107,105, + 110,100, 32, 61, 61, 32, 39,102,117,110, 99, 39, 32,116,104, + 101,110, 10,101,114,114,111,114, 40, 34, 35,105,110,118, 97, + 108,105,100, 32,102,117,110, 99,116,105,111,110, 32,114,101, + 116,117,114,110, 32,116,121,112,101, 58, 32, 34, 46, 46,115, + 41, 10,101,110,100, 10,108,111, 99, 97,108, 32,109, 32, 61, + 32,115,112,108,105,116, 40,116, 91, 49, 93, 44, 39, 37,115, + 37,115, 42, 39, 41, 10,114,101,116,117,114,110, 32, 95, 68, + 101, 99,108, 97,114, 97,116,105,111,110,123, 10,110, 97,109, + 101, 32, 61, 32,116, 91, 50, 93, 44, 10,112,116,114, 32, 61, + 32, 39, 42, 39, 44, 10,114,101,116, 32, 61, 32, 39, 42, 39, + 44, 10,116,121,112,101, 32, 61, 32,109, 91,109, 46,110, 93, + 44, 10,109,111,100, 32, 61, 32, 99,111,110, 99, 97,116, 40, + 109, 44, 49, 44,109, 46,110, 45, 49, 41, 44, 10,107,105,110, + 100, 32, 61, 32,107,105,110,100, 10,125, 10,101,110,100, 10, + 10, 10,116, 32, 61, 32,115,112,108,105,116, 40,115, 44, 39, + 38, 39, 41, 10,105,102, 32,116, 46,110, 32, 61, 61, 32, 50, + 32,116,104,101,110, 10,108,111, 99, 97,108, 32,109, 32, 61, + 32,115,112,108,105,116, 40,116, 91, 49, 93, 44, 39, 37,115, + 37,115, 42, 39, 41, 10,114,101,116,117,114,110, 32, 95, 68, + 101, 99,108, 97,114, 97,116,105,111,110,123, 10,110, 97,109, + 101, 32, 61, 32,116, 91, 50, 93, 44, 10,112,116,114, 32, 61, + 32, 39, 38, 39, 44, 10,116,121,112,101, 32, 61, 32,109, 91, + 109, 46,110, 93, 44, 10,109,111,100, 32, 61, 32, 99,111,110, + 99, 97,116, 40,109, 44, 49, 44,109, 46,110, 45, 49, 41, 32, + 44, 10,107,105,110,100, 32, 61, 32,107,105,110,100, 10,125, + 10,101,110,100, 10, 10, 10,108,111, 99, 97,108, 32,115, 49, + 32, 61, 32,103,115,117, 98, 40,115, 44, 34, 40, 37, 98, 92, + 91, 92, 93, 41, 34, 44,102,117,110, 99,116,105,111,110, 32, + 40,110, 41, 32,114,101,116,117,114,110, 32,103,115,117, 98, + 40,110, 44, 39, 37, 42, 39, 44, 39, 92, 49, 39, 41, 32,101, + 110,100, 41, 10,116, 32, 61, 32,115,112,108,105,116, 40,115, + 49, 44, 39, 37, 42, 39, 41, 10,105,102, 32,116, 46,110, 32, + 61, 61, 32, 50, 32,116,104,101,110, 10,116, 91, 50, 93, 32, + 61, 32,103,115,117, 98, 40,116, 91, 50, 93, 44, 39, 92, 49, + 39, 44, 39, 37, 42, 39, 41, 10,108,111, 99, 97,108, 32,109, + 32, 61, 32,115,112,108,105,116, 40,116, 91, 49, 93, 44, 39, + 37,115, 37,115, 42, 39, 41, 10,114,101,116,117,114,110, 32, + 95, 68,101, 99,108, 97,114, 97,116,105,111,110,123, 10,110, + 97,109,101, 32, 61, 32,116, 91, 50, 93, 44, 10,112,116,114, + 32, 61, 32, 39, 42, 39, 44, 10,116,121,112,101, 32, 61, 32, + 109, 91,109, 46,110, 93, 44, 10,109,111,100, 32, 61, 32, 99, + 111,110, 99, 97,116, 40,109, 44, 49, 44,109, 46,110, 45, 49, + 41, 32, 44, 10,107,105,110,100, 32, 61, 32,107,105,110,100, + 10,125, 10,101,110,100, 10, 10,105,102, 32,107,105,110,100, + 32, 61, 61, 32, 39,118, 97,114, 39, 32,116,104,101,110, 10, + 10,116, 32, 61, 32,115,112,108,105,116, 40,115, 44, 39, 37, + 115, 37,115, 42, 39, 41, 10,108,111, 99, 97,108, 32,118, 10, + 105,102, 32,105,115,116,121,112,101, 40,116, 91,116, 46,110, + 93, 41, 32,116,104,101,110, 32,118, 32, 61, 32, 39, 39, 32, + 101,108,115,101, 32,118, 32, 61, 32,116, 91,116, 46,110, 93, + 59, 32,116, 46,110, 32, 61, 32,116, 46,110, 45, 49, 32,101, + 110,100, 10,114,101,116,117,114,110, 32, 95, 68,101, 99,108, + 97,114, 97,116,105,111,110,123, 10,110, 97,109,101, 32, 61, + 32,118, 44, 10,116,121,112,101, 32, 61, 32,116, 91,116, 46, + 110, 93, 44, 10,109,111,100, 32, 61, 32, 99,111,110, 99, 97, + 116, 40,116, 44, 49, 44,116, 46,110, 45, 49, 41, 44, 10,107, + 105,110,100, 32, 61, 32,107,105,110,100, 10,125, 10, 10,101, + 108,115,101, 10, 10, 10,116, 32, 61, 32,115,112,108,105,116, + 40,115, 44, 39, 37,115, 37,115, 42, 39, 41, 10,108,111, 99, + 97,108, 32,118, 32, 61, 32,116, 91,116, 46,110, 93, 10,108, + 111, 99, 97,108, 32,116,112, 44,109,100, 10,105,102, 32,116, + 46,110, 62, 49, 32,116,104,101,110, 10,116,112, 32, 61, 32, + 116, 91,116, 46,110, 45, 49, 93, 10,109,100, 32, 61, 32, 99, + 111,110, 99, 97,116, 40,116, 44, 49, 44,116, 46,110, 45, 50, + 41, 10,101,110,100, 10,114,101,116,117,114,110, 32, 95, 68, + 101, 99,108, 97,114, 97,116,105,111,110,123, 10,110, 97,109, + 101, 32, 61, 32,118, 44, 10,116,121,112,101, 32, 61, 32,116, + 112, 44, 10,109,111,100, 32, 61, 32,109,100, 44, 10,107,105, + 110,100, 32, 61, 32,107,105,110,100, 10,125, 10,101,110,100, + 10, 10,101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 99,108, 97,115,115, 86, 97,114,105, + 97, 98,108,101, 32, 61, 32,123, 10, 95, 98, 97,115,101, 32, + 61, 32, 99,108, 97,115,115, 68,101, 99,108, 97,114, 97,116, + 105,111,110, 44, 10,125, 10, 10,115,101,116,116, 97,103, 40, + 99,108, 97,115,115, 86, 97,114,105, 97, 98,108,101, 44,116, + 111,108,117, 97, 95,116, 97,103, 41, 10, 10, 10,102,117,110, + 99,116,105,111,110, 32, 99,108, 97,115,115, 86, 97,114,105, + 97, 98,108,101, 58,112,114,105,110,116, 32, 40,105,100,101, + 110,116, 44, 99,108,111,115,101, 41, 10,112,114,105,110,116, + 40,105,100,101,110,116, 46, 46, 34, 86, 97,114,105, 97, 98, + 108,101,123, 34, 41, 10,112,114,105,110,116, 40,105,100,101, + 110,116, 46, 46, 34, 32,109,111,100, 32, 61, 32, 39, 34, 46, + 46,115,101,108,102, 46,109,111,100, 46, 46, 34, 39, 44, 34, + 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, + 34, 32,116,121,112,101, 32, 61, 32, 39, 34, 46, 46,115,101, + 108,102, 46,116,121,112,101, 46, 46, 34, 39, 44, 34, 41, 10, + 112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32, + 112,116,114, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46, + 112,116,114, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110, + 116, 40,105,100,101,110,116, 46, 46, 34, 32,110, 97,109,101, + 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,110, 97,109, + 101, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40, + 105,100,101,110,116, 46, 46, 34, 32,100,101,102, 32, 61, 32, + 39, 34, 46, 46,115,101,108,102, 46,100,101,102, 46, 46, 34, + 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34, 32,114,101,116, 32, 61, 32, 39, 34, 46, 46, + 115,101,108,102, 46,114,101,116, 46, 46, 34, 39, 44, 34, 41, + 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, + 125, 34, 46, 46, 99,108,111,115,101, 41, 10,101,110,100, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115, + 115, 86, 97,114,105, 97, 98,108,101, 58,103,101,116,118, 97, + 108,117,101, 32, 40, 99,108, 97,115,115, 44,115,116, 97,116, + 105, 99, 41, 10,105,102, 32, 99,108, 97,115,115, 32, 97,110, + 100, 32,115,116, 97,116,105, 99, 32,116,104,101,110, 10,114, + 101,116,117,114,110, 32, 99,108, 97,115,115, 46, 46, 39, 58, + 58, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, 10,101, + 108,115,101,105,102, 32, 99,108, 97,115,115, 32,116,104,101, + 110, 10,114,101,116,117,114,110, 32, 39,115,101,108,102, 45, + 62, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, 10,101, + 108,115,101, 10,114,101,116,117,114,110, 32,115,101,108,102, + 46,110, 97,109,101, 10,101,110,100, 10,101,110,100, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, + 86, 97,114,105, 97, 98,108,101, 58,115,117,112, 99,111,100, + 101, 32, 40, 41, 10,108,111, 99, 97,108, 32, 99,108, 97,115, + 115, 32, 61, 32,115,101,108,102, 58,105,110, 99,108, 97,115, + 115, 40, 41, 10, 10, 10,105,102, 32, 99,108, 97,115,115, 32, + 116,104,101,110, 10,111,117,116,112,117,116, 40, 34, 47, 42, + 32,103,101,116, 32,102,117,110, 99,116,105,111,110, 58, 34, + 44,115,101,108,102, 46,110, 97,109,101, 44, 34, 32,111,102, + 32, 99,108, 97,115,115, 32, 34, 44, 99,108, 97,115,115, 44, + 34, 32, 42, 47, 34, 41, 10,101,108,115,101, 10,111,117,116, + 112,117,116, 40, 34, 47, 42, 32,103,101,116, 32,102,117,110, + 99,116,105,111,110, 58, 34, 44,115,101,108,102, 46,110, 97, + 109,101, 44, 34, 32, 42, 47, 34, 41, 10,101,110,100, 10,115, + 101,108,102, 46, 99,103,101,116,110, 97,109,101, 32, 61, 32, + 115,101,108,102, 58, 99,102,117,110, 99,110, 97,109,101, 40, + 34,116,111,108,117, 97, 73, 95,103,101,116, 34, 41, 10,111, + 117,116,112,117,116, 40, 34,115,116, 97,116,105, 99, 32,105, + 110,116, 34, 44,115,101,108,102, 46, 99,103,101,116,110, 97, + 109,101, 44, 34, 40,108,117, 97, 95, 83,116, 97,116,101, 42, + 32,116,111,108,117, 97, 95, 83, 41, 34, 41, 10,111,117,116, + 112,117,116, 40, 34,123, 34, 41, 10, 10, 10,108,111, 99, 97, + 108, 32, 95, 44, 95, 44,115,116, 97,116,105, 99, 32, 61, 32, + 115,116,114,102,105,110,100, 40,115,101,108,102, 46,109,111, + 100, 44, 39, 94, 37,115, 42, 40,115,116, 97,116,105, 99, 41, + 39, 41, 10,105,102, 32, 99,108, 97,115,115, 32, 97,110,100, + 32,115,116, 97,116,105, 99, 61, 61,110,105,108, 32,116,104, + 101,110, 10,111,117,116,112,117,116, 40, 39, 32, 39, 44, 99, + 108, 97,115,115, 44, 39, 42, 39, 44, 39,115,101,108,102, 32, + 61, 32, 39, 41, 10,111,117,116,112,117,116, 40, 39, 40, 39, + 44, 99,108, 97,115,115, 44, 39, 42, 41, 32, 39, 41, 10,111, + 117,116,112,117,116, 40, 39,116,111,108,117, 97, 95,103,101, + 116,117,115,101,114,116,121,112,101, 40,116,111,108,117, 97, + 95, 83, 44, 49, 44, 48, 41, 59, 39, 41, 10,101,108,115,101, + 105,102, 32,115,116, 97,116,105, 99, 32,116,104,101,110, 10, + 95, 44, 95, 44,115,101,108,102, 46,109,111,100, 32, 61, 32, + 115,116,114,102,105,110,100, 40,115,101,108,102, 46,109,111, + 100, 44, 39, 94, 37,115, 42,115,116, 97,116,105, 99, 37,115, + 37,115, 42, 40, 46, 42, 41, 39, 41, 10,101,110,100, 10, 10, + 10, 10,105,102, 32, 99,108, 97,115,115, 32, 97,110,100, 32, + 115,116, 97,116,105, 99, 61, 61,110,105,108, 32,116,104,101, + 110, 10,111,117,116,112,117,116, 40, 39, 32,105,102, 32, 40, + 33,115,101,108,102, 41, 32, 84, 79, 76, 85, 65, 95, 69, 82, + 82, 95, 83, 69, 76, 70, 59, 39, 41, 59, 10,101,110,100, 10, + 10, 10,108,111, 99, 97,108, 32,116, 44, 99,116, 32, 61, 32, + 105,115, 98, 97,115,105, 99, 40,115,101,108,102, 46,116,121, + 112,101, 41, 10,105,102, 32,116, 32,116,104,101,110, 10,111, + 117,116,112,117,116, 40, 39, 32,116,111,108,117, 97, 95,112, + 117,115,104, 39, 46, 46,116, 46, 46, 39, 40,116,111,108,117, + 97, 95, 83, 44, 40, 39, 44, 99,116, 44, 39, 41, 39, 46, 46, + 115,101,108,102, 58,103,101,116,118, 97,108,117,101, 40, 99, + 108, 97,115,115, 44,115,116, 97,116,105, 99, 41, 46, 46, 39, + 41, 59, 39, 41, 10,101,108,115,101, 10,105,102, 32,115,101, + 108,102, 46,112,116,114, 32, 61, 61, 32, 39, 38, 39, 32,111, + 114, 32,115,101,108,102, 46,112,116,114, 32, 61, 61, 32, 39, + 39, 32,116,104,101,110, 10,111,117,116,112,117,116, 40, 39, + 32,116,111,108,117, 97, 95,112,117,115,104,117,115,101,114, + 116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 40,118, + 111,105,100, 42, 41, 38, 39, 46, 46,115,101,108,102, 58,103, + 101,116,118, 97,108,117,101, 40, 99,108, 97,115,115, 44,115, + 116, 97,116,105, 99, 41, 46, 46, 39, 44, 39, 44,115,101,108, + 102, 46,116, 97,103, 44, 39, 41, 59, 39, 41, 10,101,108,115, + 101, 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, + 97, 95,112,117,115,104,117,115,101,114,116,121,112,101, 40, + 116,111,108,117, 97, 95, 83, 44, 40,118,111,105,100, 42, 41, + 39, 46, 46,115,101,108,102, 58,103,101,116,118, 97,108,117, + 101, 40, 99,108, 97,115,115, 44,115,116, 97,116,105, 99, 41, + 46, 46, 39, 44, 39, 44,115,101,108,102, 46,116, 97,103, 44, + 39, 41, 59, 39, 41, 10,101,110,100, 10,101,110,100, 10,111, + 117,116,112,117,116, 40, 39, 32,114,101,116,117,114,110, 32, + 49, 59, 39, 41, 10,111,117,116,112,117,116, 40, 39,125, 39, + 41, 10,111,117,116,112,117,116, 40, 39, 92,110, 39, 41, 10, + 10, 10,105,102, 32,110,111,116, 32,115,116,114,102,105,110, + 100, 40,115,101,108,102, 46,109,111,100, 44, 39, 99,111,110, + 115,116, 39, 41, 32,116,104,101,110, 10,105,102, 32, 99,108, + 97,115,115, 32,116,104,101,110, 10,111,117,116,112,117,116, + 40, 34, 47, 42, 32,115,101,116, 32,102,117,110, 99,116,105, + 111,110, 58, 34, 44,115,101,108,102, 46,110, 97,109,101, 44, + 34, 32,111,102, 32, 99,108, 97,115,115, 32, 34, 44, 99,108, + 97,115,115, 44, 34, 32, 42, 47, 34, 41, 10,101,108,115,101, + 10,111,117,116,112,117,116, 40, 34, 47, 42, 32,115,101,116, + 32,102,117,110, 99,116,105,111,110, 58, 34, 44,115,101,108, + 102, 46,110, 97,109,101, 44, 34, 32, 42, 47, 34, 41, 10,101, + 110,100, 10,115,101,108,102, 46, 99,115,101,116,110, 97,109, + 101, 32, 61, 32,115,101,108,102, 58, 99,102,117,110, 99,110, + 97,109,101, 40, 34,116,111,108,117, 97, 73, 95,115,101,116, + 34, 41, 10,111,117,116,112,117,116, 40, 34,115,116, 97,116, + 105, 99, 32,105,110,116, 34, 44,115,101,108,102, 46, 99,115, + 101,116,110, 97,109,101, 44, 34, 40,108,117, 97, 95, 83,116, + 97,116,101, 42, 32,116,111,108,117, 97, 95, 83, 41, 34, 41, + 10,111,117,116,112,117,116, 40, 34,123, 34, 41, 10, 10, 10, + 108,111, 99, 97,108, 32,110, 97,114,103, 61, 49, 10,105,102, + 32, 99,108, 97,115,115, 32, 97,110,100, 32,115,116, 97,116, + 105, 99, 61, 61,110,105,108, 32,116,104,101,110, 10,111,117, + 116,112,117,116, 40, 39, 32, 39, 44, 99,108, 97,115,115, 44, + 39, 42, 39, 44, 39,115,101,108,102, 32, 61, 32, 39, 41, 10, + 111,117,116,112,117,116, 40, 39, 40, 39, 44, 99,108, 97,115, + 115, 44, 39, 42, 41, 32, 39, 41, 10,111,117,116,112,117,116, + 40, 39,116,111,108,117, 97, 95,103,101,116,117,115,101,114, + 116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 49, 44, + 48, 41, 59, 39, 41, 10, 10,111,117,116,112,117,116, 40, 39, + 32,105,102, 32, 40, 33,115,101,108,102, 41, 32, 84, 79, 76, + 85, 65, 95, 69, 82, 82, 95, 83, 69, 76, 70, 59, 39, 41, 59, + 10,110, 97,114,103, 32, 61, 32,110, 97,114,103, 43, 49, 10, + 101,108,115,101,105,102, 32,115,116, 97,116,105, 99, 32,116, + 104,101,110, 10, 95, 44, 95, 44,115,101,108,102, 46,109,111, + 100, 32, 61, 32,115,116,114,102,105,110,100, 40,115,101,108, + 102, 46,109,111,100, 44, 39, 94, 37,115, 42,115,116, 97,116, + 105, 99, 37,115, 37,115, 42, 40, 46, 42, 41, 39, 41, 10,110, + 97,114,103, 32, 61, 32,110, 97,114,103, 43, 49, 10,101,110, + 100, 10, 10, 10,111,117,116,112,117,116, 40, 39, 32,105,102, + 32, 40, 33, 39, 46, 46,115,101,108,102, 58,111,117,116, 99, + 104,101, 99,107,116,121,112,101, 40,110, 97,114,103, 41, 46, + 46, 39, 41, 39, 41, 10,111,117,116,112,117,116, 40, 39, 32, + 84, 79, 76, 85, 65, 95, 69, 82, 82, 95, 65, 83, 83, 73, 71, + 78, 59, 39, 41, 10, 10, 10,108,111, 99, 97,108, 32,112,116, + 114, 32, 61, 32, 39, 39, 10,105,102, 32,115,101,108,102, 46, + 112,116,114,126, 61, 39, 39, 32,116,104,101,110, 32,112,116, + 114, 32, 61, 32, 39, 42, 39, 32,101,110,100, 10,111,117,116, + 112,117,116, 40, 39, 32, 39, 41, 10,105,102, 32, 99,108, 97, + 115,115, 32, 97,110,100, 32,115,116, 97,116,105, 99, 32,116, + 104,101,110, 10,111,117,116,112,117,116, 40, 99,108, 97,115, + 115, 46, 46, 39, 58, 58, 39, 46, 46,115,101,108,102, 46,110, + 97,109,101, 41, 10,101,108,115,101,105,102, 32, 99,108, 97, + 115,115, 32,116,104,101,110, 10,111,117,116,112,117,116, 40, + 39,115,101,108,102, 45, 62, 39, 46, 46,115,101,108,102, 46, + 110, 97,109,101, 41, 10,101,108,115,101, 10,111,117,116,112, + 117,116, 40,115,101,108,102, 46,110, 97,109,101, 41, 10,101, + 110,100, 10,108,111, 99, 97,108, 32,116, 32, 61, 32,105,115, + 98, 97,115,105, 99, 40,115,101,108,102, 46,116,121,112,101, + 41, 10,111,117,116,112,117,116, 40, 39, 32, 61, 32, 39, 41, + 10,105,102, 32,110,111,116, 32,116, 32, 97,110,100, 32,112, + 116,114, 61, 61, 39, 39, 32,116,104,101,110, 32,111,117,116, + 112,117,116, 40, 39, 42, 39, 41, 32,101,110,100, 10,111,117, + 116,112,117,116, 40, 39, 40, 40, 39, 44,115,101,108,102, 46, + 109,111,100, 44,115,101,108,102, 46,116,121,112,101, 41, 10, + 105,102, 32,110,111,116, 32,116, 32,116,104,101,110, 10,111, + 117,116,112,117,116, 40, 39, 42, 39, 41, 10,101,110,100, 10, + 111,117,116,112,117,116, 40, 39, 41, 32, 39, 41, 10,108,111, + 99, 97,108, 32,100,101,102, 32, 61, 32, 48, 10,105,102, 32, + 115,101,108,102, 46,100,101,102, 32,126, 61, 32, 39, 39, 32, + 116,104,101,110, 32,100,101,102, 32, 61, 32,115,101,108,102, + 46,100,101,102, 32,101,110,100, 10,105,102, 32,116, 32,116, + 104,101,110, 10,111,117,116,112,117,116, 40, 39,116,111,108, + 117, 97, 95,103,101,116, 39, 46, 46,116, 44, 39, 40,116,111, + 108,117, 97, 95, 83, 44, 39, 44,110, 97,114,103, 44, 39, 44, + 39, 44,100,101,102, 44, 39, 41, 41, 59, 39, 41, 10,101,108, + 115,101, 10,111,117,116,112,117,116, 40, 39,116,111,108,117, + 97, 95,103,101,116,117,115,101,114,116,121,112,101, 40,116, + 111,108,117, 97, 95, 83, 44, 39, 44,110, 97,114,103, 44, 39, + 44, 39, 44,100,101,102, 44, 39, 41, 41, 59, 39, 41, 10,101, + 110,100, 10,111,117,116,112,117,116, 40, 39, 32,114,101,116, + 117,114,110, 32, 48, 59, 39, 41, 10,111,117,116,112,117,116, + 40, 39,125, 39, 41, 10,111,117,116,112,117,116, 40, 39, 92, + 110, 39, 41, 10,101,110,100, 10, 10,101,110,100, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, 86, 97, + 114,105, 97, 98,108,101, 58,114,101,103,105,115,116,101,114, + 32, 40, 41, 10,108,111, 99, 97,108, 32,112, 97,114,101,110, + 116, 32, 61, 32,115,101,108,102, 58,105,110, 99,108, 97,115, + 115, 40, 41, 32,111,114, 32,115,101,108,102, 58,105,110,109, + 111,100,117,108,101, 40, 41, 10,105,102, 32,112, 97,114,101, + 110,116, 32,116,104,101,110, 10,105,102, 32,115,101,108,102, + 46, 99,115,101,116,110, 97,109,101, 32,116,104,101,110, 10, + 111,117,116,112,117,116, 40, 39, 32,116,111,108,117, 97, 95, + 116, 97, 98,108,101,118, 97,114, 40,116,111,108,117, 97, 95, + 83, 44, 34, 39, 46, 46,112, 97,114,101,110,116, 46, 46, 39, + 34, 44, 34, 39, 46, 46,115,101,108,102, 46,108,110, 97,109, + 101, 46, 46, 39, 34, 44, 39, 46, 46,115,101,108,102, 46, 99, + 103,101,116,110, 97,109,101, 46, 46, 39, 44, 39, 46, 46,115, + 101,108,102, 46, 99,115,101,116,110, 97,109,101, 46, 46, 39, + 41, 59, 39, 41, 10,101,108,115,101, 10,111,117,116,112,117, + 116, 40, 39, 32,116,111,108,117, 97, 95,116, 97, 98,108,101, + 118, 97,114, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, + 46,112, 97,114,101,110,116, 46, 46, 39, 34, 44, 34, 39, 46, + 46,115,101,108,102, 46,108,110, 97,109,101, 46, 46, 39, 34, + 44, 39, 46, 46,115,101,108,102, 46, 99,103,101,116,110, 97, + 109,101, 46, 46, 39, 44, 78, 85, 76, 76, 41, 59, 39, 41, 10, + 101,110,100, 10,101,108,115,101, 10,105,102, 32,115,101,108, + 102, 46, 99,115,101,116,110, 97,109,101, 32,116,104,101,110, + 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, 97, + 95,103,108,111, 98, 97,108,118, 97,114, 40,116,111,108,117, + 97, 95, 83, 44, 34, 39, 46, 46,115,101,108,102, 46,108,110, + 97,109,101, 46, 46, 39, 34, 44, 39, 46, 46,115,101,108,102, + 46, 99,103,101,116,110, 97,109,101, 46, 46, 39, 44, 39, 46, + 46,115,101,108,102, 46, 99,115,101,116,110, 97,109,101, 46, + 46, 39, 41, 59, 39, 41, 10,101,108,115,101, 10,111,117,116, + 112,117,116, 40, 39, 32,116,111,108,117, 97, 95,103,108,111, + 98, 97,108,118, 97,114, 40,116,111,108,117, 97, 95, 83, 44, + 34, 39, 46, 46,115,101,108,102, 46,108,110, 97,109,101, 46, + 46, 39, 34, 44, 39, 46, 46,115,101,108,102, 46, 99,103,101, + 116,110, 97,109,101, 46, 46, 39, 44, 78, 85, 76, 76, 41, 59, + 39, 41, 10,101,110,100, 10,101,110,100, 10,101,110,100, 10, + 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, + 86, 97,114,105, 97, 98,108,101, 58,117,110,114,101,103,105, + 115,116,101,114, 32, 40, 41, 10,105,102, 32,115,101,108,102, + 58,105,110, 99,108, 97,115,115, 40, 41, 61, 61,110,105,108, + 32, 97,110,100, 32,115,101,108,102, 58,105,110,109,111,100, + 117,108,101, 40, 41, 61, 61,110,105,108, 32,116,104,101,110, + 10,111,117,116,112,117,116, 40, 39, 32,108,117, 97, 95,103, + 101,116,103,108,111, 98, 97,108,115, 40,116,111,108,117, 97, + 95, 83, 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, 39, + 32,108,117, 97, 95,112,117,115,104,115,116,114,105,110,103, + 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 44,115,101,108, + 102, 46,108,110, 97,109,101, 44, 39, 34, 41, 59, 32,108,117, + 97, 95,112,117,115,104,110,105,108, 40,116,111,108,117, 97, + 95, 83, 41, 59, 32,108,117, 97, 95,114, 97,119,115,101,116, + 40,116,111,108,117, 97, 95, 83, 44, 45, 51, 41, 59, 39, 41, + 10,111,117,116,112,117,116, 40, 39, 32,108,117, 97, 95,112, + 111,112, 40,116,111,108,117, 97, 95, 83, 44, 49, 41, 59, 39, + 41, 10,101,110,100, 10,101,110,100, 10, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 95, 86, 97,114,105, 97, 98,108, + 101, 32, 40,116, 41, 10,116, 46, 95, 98, 97,115,101, 32, 61, + 32, 99,108, 97,115,115, 86, 97,114,105, 97, 98,108,101, 10, + 115,101,116,116, 97,103, 40,116, 44,116,111,108,117, 97, 95, + 116, 97,103, 41, 10, 97,112,112,101,110,100, 40,116, 41, 10, + 114,101,116,117,114,110, 32,116, 10,101,110,100, 10, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 86, 97,114,105, 97, + 98,108,101, 32, 40,115, 41, 10,114,101,116,117,114,110, 32, + 95, 86, 97,114,105, 97, 98,108,101, 32, 40, 68,101, 99,108, + 97,114, 97,116,105,111,110, 40,115, 44, 39,118, 97,114, 39, + 41, 41, 10,101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115,115, 65, + 114,114, 97,121, 32, 61, 32,123, 10, 95, 98, 97,115,101, 32, + 61, 32, 99,108, 97,115,115, 68,101, 99,108, 97,114, 97,116, + 105,111,110, 44, 10,125, 10, 10,115,101,116,116, 97,103, 40, + 99,108, 97,115,115, 65,114,114, 97,121, 44,116,111,108,117, + 97, 95,116, 97,103, 41, 10, 10, 10,102,117,110, 99,116,105, + 111,110, 32, 99,108, 97,115,115, 65,114,114, 97,121, 58,112, + 114,105,110,116, 32, 40,105,100,101,110,116, 44, 99,108,111, + 115,101, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, + 46, 46, 34, 65,114,114, 97,121,123, 34, 41, 10,112,114,105, + 110,116, 40,105,100,101,110,116, 46, 46, 34, 32,109,111,100, + 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,109,111,100, + 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105, + 100,101,110,116, 46, 46, 34, 32,116,121,112,101, 32, 61, 32, + 39, 34, 46, 46,115,101,108,102, 46,116,121,112,101, 46, 46, + 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101, + 110,116, 46, 46, 34, 32,112,116,114, 32, 61, 32, 39, 34, 46, + 46,115,101,108,102, 46,112,116,114, 46, 46, 34, 39, 44, 34, + 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, + 34, 32,110, 97,109,101, 32, 61, 32, 39, 34, 46, 46,115,101, + 108,102, 46,110, 97,109,101, 46, 46, 34, 39, 44, 34, 41, 10, + 112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32, + 100,101,102, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46, + 100,101,102, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110, + 116, 40,105,100,101,110,116, 46, 46, 34, 32,100,105,109, 32, + 61, 32, 39, 34, 46, 46,115,101,108,102, 46,100,105,109, 46, + 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100, + 101,110,116, 46, 46, 34, 32,114,101,116, 32, 61, 32, 39, 34, + 46, 46,115,101,108,102, 46,114,101,116, 46, 46, 34, 39, 44, + 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, + 46, 34,125, 34, 46, 46, 99,108,111,115,101, 41, 10,101,110, + 100, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, + 97,115,115, 65,114,114, 97,121, 58,103,101,116,118, 97,108, + 117,101, 32, 40, 99,108, 97,115,115, 44,115,116, 97,116,105, + 99, 41, 10,105,102, 32, 99,108, 97,115,115, 32, 97,110,100, + 32,115,116, 97,116,105, 99, 32,116,104,101,110, 10,114,101, + 116,117,114,110, 32, 99,108, 97,115,115, 46, 46, 39, 58, 58, + 39, 46, 46,115,101,108,102, 46,110, 97,109,101, 46, 46, 39, + 91,116,111,108,117, 97, 73, 95,105,110,100,101,120, 93, 39, + 10,101,108,115,101,105,102, 32, 99,108, 97,115,115, 32,116, + 104,101,110, 10,114,101,116,117,114,110, 32, 39,115,101,108, + 102, 45, 62, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, + 46, 46, 39, 91,116,111,108,117, 97, 73, 95,105,110,100,101, + 120, 93, 39, 10,101,108,115,101, 10,114,101,116,117,114,110, + 32,115,101,108,102, 46,110, 97,109,101, 46, 46, 39, 91,116, + 111,108,117, 97, 73, 95,105,110,100,101,120, 93, 39, 10,101, + 110,100, 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105, + 111,110, 32, 99,108, 97,115,115, 65,114,114, 97,121, 58,115, + 117,112, 99,111,100,101, 32, 40, 41, 10,108,111, 99, 97,108, + 32, 99,108, 97,115,115, 32, 61, 32,115,101,108,102, 58,105, + 110, 99,108, 97,115,115, 40, 41, 10, 10, 10,105,102, 32, 99, + 108, 97,115,115, 32,116,104,101,110, 10,111,117,116,112,117, + 116, 40, 34, 47, 42, 32,103,101,116, 32,102,117,110, 99,116, + 105,111,110, 58, 34, 44,115,101,108,102, 46,110, 97,109,101, + 44, 34, 32,111,102, 32, 99,108, 97,115,115, 32, 34, 44, 99, + 108, 97,115,115, 44, 34, 32, 42, 47, 34, 41, 10,101,108,115, + 101, 10,111,117,116,112,117,116, 40, 34, 47, 42, 32,103,101, + 116, 32,102,117,110, 99,116,105,111,110, 58, 34, 44,115,101, + 108,102, 46,110, 97,109,101, 44, 34, 32, 42, 47, 34, 41, 10, + 101,110,100, 10,115,101,108,102, 46, 99,103,101,116,110, 97, + 109,101, 32, 61, 32,115,101,108,102, 58, 99,102,117,110, 99, + 110, 97,109,101, 40, 34,116,111,108,117, 97, 73, 95,103,101, + 116, 34, 41, 10,111,117,116,112,117,116, 40, 34,115,116, 97, + 116,105, 99, 32,105,110,116, 34, 44,115,101,108,102, 46, 99, + 103,101,116,110, 97,109,101, 44, 34, 40,108,117, 97, 95, 83, + 116, 97,116,101, 42, 32,116,111,108,117, 97, 95, 83, 41, 34, + 41, 10,111,117,116,112,117,116, 40, 34,123, 34, 41, 10, 10, + 10,111,117,116,112,117,116, 40, 39, 32,105,110,116, 32,116, + 111,108,117, 97, 73, 95,105,110,100,101,120, 59, 39, 41, 10, + 10, 10,108,111, 99, 97,108, 32, 95, 44, 95, 44,115,116, 97, + 116,105, 99, 32, 61, 32,115,116,114,102,105,110,100, 40,115, + 101,108,102, 46,109,111,100, 44, 39, 94, 37,115, 42, 40,115, + 116, 97,116,105, 99, 41, 39, 41, 10,105,102, 32, 99,108, 97, + 115,115, 32, 97,110,100, 32,115,116, 97,116,105, 99, 61, 61, + 110,105,108, 32,116,104,101,110, 10,111,117,116,112,117,116, + 40, 39, 32, 39, 44, 99,108, 97,115,115, 44, 39, 42, 39, 44, + 39,115,101,108,102, 59, 39, 41, 10,111,117,116,112,117,116, + 40, 39, 32,108,117, 97, 95,112,117,115,104,115,116,114,105, + 110,103, 40,116,111,108,117, 97, 95, 83, 44, 34, 46,115,101, + 108,102, 34, 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, + 39, 32,108,117, 97, 95,114, 97,119,103,101,116, 40,116,111, + 108,117, 97, 95, 83, 44, 49, 41, 59, 39, 41, 10,111,117,116, + 112,117,116, 40, 39, 32,115,101,108,102, 32, 61, 32, 39, 41, + 10,111,117,116,112,117,116, 40, 39, 40, 39, 44, 99,108, 97, + 115,115, 44, 39, 42, 41, 32, 39, 41, 10,111,117,116,112,117, + 116, 40, 39,108,117, 97, 95,116,111,117,115,101,114,100, 97, + 116, 97, 40,116,111,108,117, 97, 95, 83, 44, 45, 49, 41, 59, + 39, 41, 10,101,108,115,101,105,102, 32,115,116, 97,116,105, + 99, 32,116,104,101,110, 10, 95, 44, 95, 44,115,101,108,102, + 46,109,111,100, 32, 61, 32,115,116,114,102,105,110,100, 40, + 115,101,108,102, 46,109,111,100, 44, 39, 94, 37,115, 42,115, + 116, 97,116,105, 99, 37,115, 37,115, 42, 40, 46, 42, 41, 39, + 41, 10,101,110,100, 10, 10, 10,111,117,116,112,117,116, 40, + 39, 32,105,102, 32, 40, 33,116,111,108,117, 97, 95,105,115, + 116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 50, 44, + 76, 85, 65, 95, 84, 78, 85, 77, 66, 69, 82, 44, 48, 41, 41, + 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,116,111,108, + 117, 97, 95,101,114,114,111,114, 40,116,111,108,117, 97, 95, + 83, 44, 34,105,110,118, 97,108,105,100, 32,116,121,112,101, + 32,105,110, 32, 97,114,114, 97,121, 32,105,110,100,101,120, + 105,110,103, 46, 34, 41, 59, 39, 41, 10,111,117,116,112,117, + 116, 40, 39, 32,116,111,108,117, 97, 73, 95,105,110,100,101, + 120, 32, 61, 32, 40,105,110,116, 41,116,111,108,117, 97, 95, + 103,101,116,110,117,109, 98,101,114, 40,116,111,108,117, 97, + 95, 83, 44, 50, 44, 48, 41, 45, 49, 59, 39, 41, 10,111,117, + 116,112,117,116, 40, 39, 32,105,102, 32, 40,116,111,108,117, + 97, 73, 95,105,110,100,101,120, 60, 48, 32,124,124, 32,116, + 111,108,117, 97, 73, 95,105,110,100,101,120, 62, 61, 39, 46, + 46,115,101,108,102, 46,100,105,109, 46, 46, 39, 41, 39, 41, + 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, 97, + 95,101,114,114,111,114, 40,116,111,108,117, 97, 95, 83, 44, + 34, 97,114,114, 97,121, 32,105,110,100,101,120,105,110,103, + 32,111,117,116, 32,111,102, 32,114, 97,110,103,101, 46, 34, + 41, 59, 39, 41, 10, 10, 10,108,111, 99, 97,108, 32,116, 44, + 99,116, 32, 61, 32,105,115, 98, 97,115,105, 99, 40,115,101, + 108,102, 46,116,121,112,101, 41, 10,105,102, 32,116, 32,116, + 104,101,110, 10,111,117,116,112,117,116, 40, 39, 32,116,111, + 108,117, 97, 95,112,117,115,104, 39, 46, 46,116, 46, 46, 39, + 40,116,111,108,117, 97, 95, 83, 44, 40, 39, 44, 99,116, 44, + 39, 41, 39, 46, 46,115,101,108,102, 58,103,101,116,118, 97, + 108,117,101, 40, 99,108, 97,115,115, 44,115,116, 97,116,105, + 99, 41, 46, 46, 39, 41, 59, 39, 41, 10,101,108,115,101, 10, + 105,102, 32,115,101,108,102, 46,112,116,114, 32, 61, 61, 32, + 39, 38, 39, 32,111,114, 32,115,101,108,102, 46,112,116,114, + 32, 61, 61, 32, 39, 39, 32,116,104,101,110, 10,111,117,116, + 112,117,116, 40, 39, 32,116,111,108,117, 97, 95,112,117,115, + 104,117,115,101,114,116,121,112,101, 40,116,111,108,117, 97, + 95, 83, 44, 40,118,111,105,100, 42, 41, 38, 39, 46, 46,115, + 101,108,102, 58,103,101,116,118, 97,108,117,101, 40, 99,108, + 97,115,115, 44,115,116, 97,116,105, 99, 41, 46, 46, 39, 44, + 39, 44,115,101,108,102, 46,116, 97,103, 44, 39, 41, 59, 39, + 41, 10,101,108,115,101, 10,111,117,116,112,117,116, 40, 39, + 32,116,111,108,117, 97, 95,112,117,115,104,117,115,101,114, + 116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 40,118, + 111,105,100, 42, 41, 39, 46, 46,115,101,108,102, 58,103,101, + 116,118, 97,108,117,101, 40, 99,108, 97,115,115, 44,115,116, + 97,116,105, 99, 41, 46, 46, 39, 44, 39, 44,115,101,108,102, + 46,116, 97,103, 44, 39, 41, 59, 39, 41, 10,101,110,100, 10, + 101,110,100, 10,111,117,116,112,117,116, 40, 39, 32,114,101, + 116,117,114,110, 32, 49, 59, 39, 41, 10,111,117,116,112,117, + 116, 40, 39,125, 39, 41, 10,111,117,116,112,117,116, 40, 39, + 92,110, 39, 41, 10, 10, 10,105,102, 32,110,111,116, 32,115, + 116,114,102,105,110,100, 40,115,101,108,102, 46,109,111,100, + 44, 39, 99,111,110,115,116, 39, 41, 32,116,104,101,110, 10, + 105,102, 32, 99,108, 97,115,115, 32,116,104,101,110, 10,111, + 117,116,112,117,116, 40, 34, 47, 42, 32,115,101,116, 32,102, + 117,110, 99,116,105,111,110, 58, 34, 44,115,101,108,102, 46, + 110, 97,109,101, 44, 34, 32,111,102, 32, 99,108, 97,115,115, + 32, 34, 44, 99,108, 97,115,115, 44, 34, 32, 42, 47, 34, 41, + 10,101,108,115,101, 10,111,117,116,112,117,116, 40, 34, 47, + 42, 32,115,101,116, 32,102,117,110, 99,116,105,111,110, 58, + 34, 44,115,101,108,102, 46,110, 97,109,101, 44, 34, 32, 42, + 47, 34, 41, 10,101,110,100, 10,115,101,108,102, 46, 99,115, + 101,116,110, 97,109,101, 32, 61, 32,115,101,108,102, 58, 99, + 102,117,110, 99,110, 97,109,101, 40, 34,116,111,108,117, 97, + 73, 95,115,101,116, 34, 41, 10,111,117,116,112,117,116, 40, + 34,115,116, 97,116,105, 99, 32,105,110,116, 34, 44,115,101, + 108,102, 46, 99,115,101,116,110, 97,109,101, 44, 34, 40,108, + 117, 97, 95, 83,116, 97,116,101, 42, 32,116,111,108,117, 97, + 95, 83, 41, 34, 41, 10,111,117,116,112,117,116, 40, 34,123, + 34, 41, 10, 10, 10,111,117,116,112,117,116, 40, 39, 32,105, + 110,116, 32,116,111,108,117, 97, 73, 95,105,110,100,101,120, + 59, 39, 41, 10, 10, 10,108,111, 99, 97,108, 32, 95, 44, 95, + 44,115,116, 97,116,105, 99, 32, 61, 32,115,116,114,102,105, + 110,100, 40,115,101,108,102, 46,109,111,100, 44, 39, 94, 37, + 115, 42, 40,115,116, 97,116,105, 99, 41, 39, 41, 10,105,102, + 32, 99,108, 97,115,115, 32, 97,110,100, 32,115,116, 97,116, + 105, 99, 61, 61,110,105,108, 32,116,104,101,110, 10,111,117, + 116,112,117,116, 40, 39, 32, 39, 44, 99,108, 97,115,115, 44, + 39, 42, 39, 44, 39,115,101,108,102, 59, 39, 41, 10,111,117, + 116,112,117,116, 40, 39, 32,108,117, 97, 95,112,117,115,104, + 115,116,114,105,110,103, 40,116,111,108,117, 97, 95, 83, 44, + 34, 46,115,101,108,102, 34, 41, 59, 39, 41, 10,111,117,116, + 112,117,116, 40, 39, 32,108,117, 97, 95,114, 97,119,103,101, + 116, 40,116,111,108,117, 97, 95, 83, 44, 49, 41, 59, 39, 41, + 10,111,117,116,112,117,116, 40, 39, 32,115,101,108,102, 32, + 61, 32, 39, 41, 10,111,117,116,112,117,116, 40, 39, 40, 39, + 44, 99,108, 97,115,115, 44, 39, 42, 41, 32, 39, 41, 10,111, + 117,116,112,117,116, 40, 39,108,117, 97, 95,116,111,117,115, + 101,114,100, 97,116, 97, 40,116,111,108,117, 97, 95, 83, 44, + 45, 49, 41, 59, 39, 41, 10,101,108,115,101,105,102, 32,115, + 116, 97,116,105, 99, 32,116,104,101,110, 10, 95, 44, 95, 44, + 115,101,108,102, 46,109,111,100, 32, 61, 32,115,116,114,102, + 105,110,100, 40,115,101,108,102, 46,109,111,100, 44, 39, 94, + 37,115, 42,115,116, 97,116,105, 99, 37,115, 37,115, 42, 40, + 46, 42, 41, 39, 41, 10,101,110,100, 10, 10, 10,111,117,116, + 112,117,116, 40, 39, 32,105,102, 32, 40, 33,116,111,108,117, + 97, 95,105,115,116,121,112,101, 40,116,111,108,117, 97, 95, + 83, 44, 50, 44, 76, 85, 65, 95, 84, 78, 85, 77, 66, 69, 82, + 44, 48, 41, 41, 39, 41, 10,111,117,116,112,117,116, 40, 39, + 32,116,111,108,117, 97, 95,101,114,114,111,114, 40,116,111, + 108,117, 97, 95, 83, 44, 34,105,110,118, 97,108,105,100, 32, + 116,121,112,101, 32,105,110, 32, 97,114,114, 97,121, 32,105, + 110,100,101,120,105,110,103, 46, 34, 41, 59, 39, 41, 10,111, + 117,116,112,117,116, 40, 39, 32,116,111,108,117, 97, 73, 95, + 105,110,100,101,120, 32, 61, 32, 40,105,110,116, 41,116,111, + 108,117, 97, 95,103,101,116,110,117,109, 98,101,114, 40,116, + 111,108,117, 97, 95, 83, 44, 50, 44, 48, 41, 45, 49, 59, 39, + 41, 10,111,117,116,112,117,116, 40, 39, 32,105,102, 32, 40, + 116,111,108,117, 97, 73, 95,105,110,100,101,120, 60, 48, 32, + 124,124, 32,116,111,108,117, 97, 73, 95,105,110,100,101,120, + 62, 61, 39, 46, 46,115,101,108,102, 46,100,105,109, 46, 46, + 39, 41, 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,116, + 111,108,117, 97, 95,101,114,114,111,114, 40,116,111,108,117, + 97, 95, 83, 44, 34, 97,114,114, 97,121, 32,105,110,100,101, + 120,105,110,103, 32,111,117,116, 32,111,102, 32,114, 97,110, + 103,101, 46, 34, 41, 59, 39, 41, 10, 10, 10,108,111, 99, 97, + 108, 32,112,116,114, 32, 61, 32, 39, 39, 10,105,102, 32,115, + 101,108,102, 46,112,116,114,126, 61, 39, 39, 32,116,104,101, + 110, 32,112,116,114, 32, 61, 32, 39, 42, 39, 32,101,110,100, + 10,111,117,116,112,117,116, 40, 39, 32, 39, 41, 10,105,102, + 32, 99,108, 97,115,115, 32, 97,110,100, 32,115,116, 97,116, + 105, 99, 32,116,104,101,110, 10,111,117,116,112,117,116, 40, + 99,108, 97,115,115, 46, 46, 39, 58, 58, 39, 46, 46,115,101, + 108,102, 46,110, 97,109,101, 46, 46, 39, 91,116,111,108,117, + 97, 73, 95,105,110,100,101,120, 93, 39, 41, 10,101,108,115, + 101,105,102, 32, 99,108, 97,115,115, 32,116,104,101,110, 10, + 111,117,116,112,117,116, 40, 39,115,101,108,102, 45, 62, 39, + 46, 46,115,101,108,102, 46,110, 97,109,101, 46, 46, 39, 91, + 116,111,108,117, 97, 73, 95,105,110,100,101,120, 93, 39, 41, + 10,101,108,115,101, 10,111,117,116,112,117,116, 40,115,101, + 108,102, 46,110, 97,109,101, 46, 46, 39, 91,116,111,108,117, + 97, 73, 95,105,110,100,101,120, 93, 39, 41, 10,101,110,100, + 10,108,111, 99, 97,108, 32,116, 32, 61, 32,105,115, 98, 97, + 115,105, 99, 40,115,101,108,102, 46,116,121,112,101, 41, 10, + 111,117,116,112,117,116, 40, 39, 32, 61, 32, 39, 41, 10,105, + 102, 32,110,111,116, 32,116, 32, 97,110,100, 32,112,116,114, + 61, 61, 39, 39, 32,116,104,101,110, 32,111,117,116,112,117, + 116, 40, 39, 42, 39, 41, 32,101,110,100, 10,111,117,116,112, + 117,116, 40, 39, 40, 40, 39, 44,115,101,108,102, 46,109,111, + 100, 44,115,101,108,102, 46,116,121,112,101, 41, 10,105,102, + 32,110,111,116, 32,116, 32,116,104,101,110, 10,111,117,116, + 112,117,116, 40, 39, 42, 39, 41, 10,101,110,100, 10,111,117, + 116,112,117,116, 40, 39, 41, 32, 39, 41, 10,108,111, 99, 97, + 108, 32,100,101,102, 32, 61, 32, 48, 10,105,102, 32,115,101, + 108,102, 46,100,101,102, 32,126, 61, 32, 39, 39, 32,116,104, + 101,110, 32,100,101,102, 32, 61, 32,115,101,108,102, 46,100, + 101,102, 32,101,110,100, 10,105,102, 32,116, 32,116,104,101, + 110, 10,111,117,116,112,117,116, 40, 39,116,111,108,117, 97, + 95,103,101,116, 39, 46, 46,116, 44, 39, 40,116,111,108,117, + 97, 95, 83, 44, 51, 44, 39, 44,100,101,102, 44, 39, 41, 41, + 59, 39, 41, 10,101,108,115,101, 10,111,117,116,112,117,116, + 40, 39,116,111,108,117, 97, 95,103,101,116,117,115,101,114, + 116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 51, 44, + 39, 44,100,101,102, 44, 39, 41, 41, 59, 39, 41, 10,101,110, + 100, 10,111,117,116,112,117,116, 40, 39, 32,114,101,116,117, + 114,110, 32, 48, 59, 39, 41, 10,111,117,116,112,117,116, 40, + 39,125, 39, 41, 10,111,117,116,112,117,116, 40, 39, 92,110, + 39, 41, 10,101,110,100, 10, 10,101,110,100, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 99,108, 97,115,115, 65,114,114, + 97,121, 58,114,101,103,105,115,116,101,114, 32, 40, 41, 10, + 108,111, 99, 97,108, 32,112, 97,114,101,110,116, 32, 61, 32, + 115,101,108,102, 58,105,110, 99,108, 97,115,115, 40, 41, 32, + 111,114, 32,115,101,108,102, 58,105,110,109,111,100,117,108, + 101, 40, 41, 10,105,102, 32,112, 97,114,101,110,116, 32,116, + 104,101,110, 10,105,102, 32,115,101,108,102, 46, 99,115,101, + 116,110, 97,109,101, 32,116,104,101,110, 10,111,117,116,112, + 117,116, 40, 39, 32,116,111,108,117, 97, 95,116, 97, 98,108, + 101, 97,114,114, 97,121, 40,116,111,108,117, 97, 95, 83, 44, + 34, 39, 46, 46,112, 97,114,101,110,116, 46, 46, 39, 34, 44, + 34, 39, 46, 46,115,101,108,102, 46,108,110, 97,109,101, 46, + 46, 39, 34, 44, 39, 46, 46,115,101,108,102, 46, 99,103,101, + 116,110, 97,109,101, 46, 46, 39, 44, 39, 46, 46,115,101,108, + 102, 46, 99,115,101,116,110, 97,109,101, 46, 46, 39, 41, 59, + 39, 41, 10,101,108,115,101, 10,111,117,116,112,117,116, 40, + 39, 32,116,111,108,117, 97, 95,116, 97, 98,108,101, 97,114, + 114, 97,121, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, + 46,112, 97,114,101,110,116, 46, 46, 39, 34, 44, 34, 39, 46, + 46,115,101,108,102, 46,108,110, 97,109,101, 46, 46, 39, 34, + 44, 39, 46, 46,115,101,108,102, 46, 99,103,101,116,110, 97, + 109,101, 46, 46, 39, 44, 78, 85, 76, 76, 41, 59, 39, 41, 10, + 101,110,100, 10,101,108,115,101, 10,105,102, 32,115,101,108, + 102, 46, 99,115,101,116,110, 97,109,101, 32,116,104,101,110, + 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, 97, + 95,103,108,111, 98, 97,108, 97,114,114, 97,121, 40,116,111, + 108,117, 97, 95, 83, 44, 34, 39, 46, 46,115,101,108,102, 46, + 108,110, 97,109,101, 46, 46, 39, 34, 44, 39, 46, 46,115,101, + 108,102, 46, 99,103,101,116,110, 97,109,101, 46, 46, 39, 44, + 39, 46, 46,115,101,108,102, 46, 99,115,101,116,110, 97,109, + 101, 46, 46, 39, 41, 59, 39, 41, 10,101,108,115,101, 10,111, + 117,116,112,117,116, 40, 39, 32,116,111,108,117, 97, 95,103, + 108,111, 98, 97,108, 97,114,114, 97,121, 40,116,111,108,117, + 97, 95, 83, 44, 34, 39, 46, 46,115,101,108,102, 46,108,110, + 97,109,101, 46, 46, 39, 34, 44, 39, 46, 46,115,101,108,102, + 46, 99,103,101,116,110, 97,109,101, 46, 46, 39, 44, 78, 85, + 76, 76, 41, 59, 39, 41, 10,101,110,100, 10,101,110,100, 10, + 101,110,100, 10, 10,102,117,110, 99,116,105,111,110, 32, 99, + 108, 97,115,115, 65,114,114, 97,121, 58,117,110,114,101,103, + 105,115,116,101,114, 32, 40, 41, 10,105,102, 32,115,101,108, + 102, 58,105,110, 99,108, 97,115,115, 40, 41, 61, 61,110,105, + 108, 32, 97,110,100, 32,115,101,108,102, 58,105,110,109,111, + 100,117,108,101, 40, 41, 61, 61,110,105,108, 32,116,104,101, + 110, 10,111,117,116,112,117,116, 40, 39, 32,108,117, 97, 95, + 112,117,115,104,110,105,108, 40,116,111,108,117, 97, 95, 83, + 41, 59, 32,108,117, 97, 95,115,101,116,103,108,111, 98, 97, + 108, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, 46,115, + 101,108,102, 46,108,110, 97,109,101, 46, 46, 39, 34, 41, 59, + 39, 41, 10,101,110,100, 10,101,110,100, 10, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 95, 65,114,114, 97,121, 32, + 40,116, 41, 10,116, 46, 95, 98, 97,115,101, 32, 61, 32, 99, + 108, 97,115,115, 65,114,114, 97,121, 10,115,101,116,116, 97, + 103, 40,116, 44,116,111,108,117, 97, 95,116, 97,103, 41, 10, + 97,112,112,101,110,100, 40,116, 41, 10,114,101,116,117,114, + 110, 32,116, 10,101,110,100, 10, 10, 10, 10,102,117,110, 99, + 116,105,111,110, 32, 65,114,114, 97,121, 32, 40,115, 41, 10, + 114,101,116,117,114,110, 32, 95, 65,114,114, 97,121, 32, 40, + 68,101, 99,108, 97,114, 97,116,105,111,110, 40,115, 44, 39, + 118, 97,114, 39, 41, 41, 10,101,110,100, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 99,108, 97,115,115, 70,117,110, 99,116,105,111, + 110, 32, 61, 32,123, 10,109,111,100, 32, 61, 32, 39, 39, 44, + 10,116,121,112,101, 32, 61, 32, 39, 39, 44, 10,112,116,114, + 32, 61, 32, 39, 39, 44, 10,110, 97,109,101, 32, 61, 32, 39, + 39, 44, 10, 97,114,103,115, 32, 61, 32,123,110, 61, 48,125, + 44, 10, 99,111,110,115,116, 32, 61, 32, 39, 39, 44, 10, 95, + 98, 97,115,101, 32, 61, 32, 99,108, 97,115,115, 70,101, 97, + 116,117,114,101, 44, 10,125, 10,115,101,116,116, 97,103, 40, + 99,108, 97,115,115, 70,117,110, 99,116,105,111,110, 44,116, + 111,108,117, 97, 95,116, 97,103, 41, 10, 10, 10,102,117,110, + 99,116,105,111,110, 32, 99,108, 97,115,115, 70,117,110, 99, + 116,105,111,110, 58,100,101, 99,108,116, 97,103, 32, 40, 41, + 10,115,101,108,102, 46,105,116,121,112,101, 44,115,101,108, + 102, 46,116, 97,103, 32, 61, 32,116, 97,103,118, 97,114, 40, + 115,101,108,102, 46,116,121,112,101, 44,115,116,114,102,105, + 110,100, 40,115,101,108,102, 46,109,111,100, 44, 39, 99,111, + 110,115,116, 39, 41, 41, 10,108,111, 99, 97,108, 32,105, 61, + 49, 10,119,104,105,108,101, 32,115,101,108,102, 46, 97,114, + 103,115, 91,105, 93, 32,100,111, 10,115,101,108,102, 46, 97, + 114,103,115, 91,105, 93, 58,100,101, 99,108,116, 97,103, 40, + 41, 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,101, + 110,100, 10, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, + 32, 99,108, 97,115,115, 70,117,110, 99,116,105,111,110, 58, + 115,117,112, 99,111,100,101, 32, 40, 41, 10,108,111, 99, 97, + 108, 32,110,114,101,116, 32, 61, 32, 48, 10,108,111, 99, 97, + 108, 32, 99,108, 97,115,115, 32, 61, 32,115,101,108,102, 58, + 105,110, 99,108, 97,115,115, 40, 41, 10,108,111, 99, 97,108, + 32, 95, 44, 95, 44,115,116, 97,116,105, 99, 32, 61, 32,115, + 116,114,102,105,110,100, 40,115,101,108,102, 46,109,111,100, + 44, 39, 94, 37,115, 42, 40,115,116, 97,116,105, 99, 41, 39, + 41, 10, 10,105,102, 32, 99,108, 97,115,115, 32,116,104,101, + 110, 10,111,117,116,112,117,116, 40, 34, 47, 42, 32,109,101, + 116,104,111,100, 58, 34, 44,115,101,108,102, 46,110, 97,109, + 101, 44, 34, 32,111,102, 32, 99,108, 97,115,115, 32, 34, 44, + 99,108, 97,115,115, 44, 34, 32, 42, 47, 34, 41, 10,101,108, + 115,101, 10,111,117,116,112,117,116, 40, 34, 47, 42, 32,102, + 117,110, 99,116,105,111,110, 58, 34, 44,115,101,108,102, 46, + 110, 97,109,101, 44, 34, 32, 42, 47, 34, 41, 10,101,110,100, + 10,111,117,116,112,117,116, 40, 34,115,116, 97,116,105, 99, + 32,105,110,116, 34, 44,115,101,108,102, 46, 99,110, 97,109, + 101, 44, 34, 40,108,117, 97, 95, 83,116, 97,116,101, 42, 32, + 116,111,108,117, 97, 95, 83, 41, 34, 41, 10,111,117,116,112, + 117,116, 40, 34,123, 34, 41, 10, 10, 10,111,117,116,112,117, + 116, 40, 39, 32,105,102, 32, 40, 92,110, 39, 41, 10, 10,108, + 111, 99, 97,108, 32,110, 97,114,103, 10,105,102, 32, 99,108, + 97,115,115, 32,116,104,101,110, 32,110, 97,114,103, 61, 50, + 32,101,108,115,101, 32,110, 97,114,103, 61, 49, 32,101,110, + 100, 10,105,102, 32, 99,108, 97,115,115, 32, 97,110,100, 32, + 115,101,108,102, 46,110, 97,109,101,126, 61, 39,110,101,119, + 39, 32, 97,110,100, 32,115,116, 97,116,105, 99, 61, 61,110, + 105,108, 32,116,104,101,110, 10,105,102, 32,115,101,108,102, + 46, 99,111,110,115,116, 32, 61, 61, 32, 39, 99,111,110,115, + 116, 39, 32,116,104,101,110, 10,111,117,116,112,117,116, 40, + 39, 32, 33,116,111,108,117, 97, 95,105,115,116,121,112,101, + 40,116,111,108,117, 97, 95, 83, 44, 49, 44, 39, 44,115,101, + 108,102, 46,112, 97,114,101,110,116, 46, 99,116, 97,103, 44, + 39, 44, 48, 41, 32,124,124, 92,110, 39, 41, 10,101,108,115, + 101, 10,111,117,116,112,117,116, 40, 39, 32, 33,116,111,108, + 117, 97, 95,105,115,116,121,112,101, 40,116,111,108,117, 97, + 95, 83, 44, 49, 44, 39, 44,115,101,108,102, 46,112, 97,114, + 101,110,116, 46,116, 97,103, 44, 39, 44, 48, 41, 32,124,124, + 92,110, 39, 41, 10,101,110,100, 10,101,110,100, 10, 10,105, + 102, 32,115,101,108,102, 46, 97,114,103,115, 91, 49, 93, 46, + 116,121,112,101, 32,126, 61, 32, 39,118,111,105,100, 39, 32, + 116,104,101,110, 10,108,111, 99, 97,108, 32,105, 61, 49, 10, + 119,104,105,108,101, 32,115,101,108,102, 46, 97,114,103,115, + 91,105, 93, 32,100,111, 10,105,102, 32,105,115, 98, 97,115, + 105, 99, 40,115,101,108,102, 46, 97,114,103,115, 91,105, 93, + 46,116,121,112,101, 41, 32,126, 61, 32, 39,118, 97,108,117, + 101, 39, 32,116,104,101,110, 10,111,117,116,112,117,116, 40, + 39, 32, 33, 39, 46, 46,115,101,108,102, 46, 97,114,103,115, + 91,105, 93, 58,111,117,116, 99,104,101, 99,107,116,121,112, + 101, 40,110, 97,114,103, 41, 46, 46, 39, 32,124,124, 92,110, + 39, 41, 10,101,110,100, 10,110, 97,114,103, 32, 61, 32,110, + 97,114,103, 43, 49, 10,105, 32, 61, 32,105, 43, 49, 10,101, + 110,100, 10,101,110,100, 10, 10,111,117,116,112,117,116, 40, + 39, 32, 33,116,111,108,117, 97, 95,105,115,110,111,111, 98, + 106, 40,116,111,108,117, 97, 95, 83, 44, 39, 46, 46,110, 97, + 114,103, 46, 46, 39, 41, 92,110, 32, 41, 92,110, 32,103,111, + 116,111, 32,116,111,108,117, 97, 95,108,101,114,114,111,114, + 59, 39, 41, 10, 10,111,117,116,112,117,116, 40, 39, 32,101, + 108,115,101, 92,110, 32,123, 39, 41, 10, 10, 10,108,111, 99, + 97,108, 32,110, 97,114,103, 10,105,102, 32, 99,108, 97,115, + 115, 32,116,104,101,110, 32,110, 97,114,103, 61, 50, 32,101, + 108,115,101, 32,110, 97,114,103, 61, 49, 32,101,110,100, 10, + 105,102, 32, 99,108, 97,115,115, 32, 97,110,100, 32,115,101, + 108,102, 46,110, 97,109,101,126, 61, 39,110,101,119, 39, 32, + 97,110,100, 32,115,116, 97,116,105, 99, 61, 61,110,105,108, + 32,116,104,101,110, 10,111,117,116,112,117,116, 40, 39, 32, + 39, 44,115,101,108,102, 46, 99,111,110,115,116, 44, 99,108, + 97,115,115, 44, 39, 42, 39, 44, 39,115,101,108,102, 32, 61, + 32, 39, 41, 10,111,117,116,112,117,116, 40, 39, 40, 39, 44, + 115,101,108,102, 46, 99,111,110,115,116, 44, 99,108, 97,115, + 115, 44, 39, 42, 41, 32, 39, 41, 10,111,117,116,112,117,116, + 40, 39,116,111,108,117, 97, 95,103,101,116,117,115,101,114, + 116,121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 49, 44, + 48, 41, 59, 39, 41, 10,101,108,115,101,105,102, 32,115,116, + 97,116,105, 99, 32,116,104,101,110, 10, 95, 44, 95, 44,115, + 101,108,102, 46,109,111,100, 32, 61, 32,115,116,114,102,105, + 110,100, 40,115,101,108,102, 46,109,111,100, 44, 39, 94, 37, + 115, 42,115,116, 97,116,105, 99, 37,115, 37,115, 42, 40, 46, + 42, 41, 39, 41, 10,101,110,100, 10, 10,105,102, 32,115,101, + 108,102, 46, 97,114,103,115, 91, 49, 93, 46,116,121,112,101, + 32,126, 61, 32, 39,118,111,105,100, 39, 32,116,104,101,110, + 10,108,111, 99, 97,108, 32,105, 61, 49, 10,119,104,105,108, + 101, 32,115,101,108,102, 46, 97,114,103,115, 91,105, 93, 32, + 100,111, 10,115,101,108,102, 46, 97,114,103,115, 91,105, 93, + 58,100,101, 99,108, 97,114,101, 40,110, 97,114,103, 41, 10, + 110, 97,114,103, 32, 61, 32,110, 97,114,103, 43, 49, 10,105, + 32, 61, 32,105, 43, 49, 10,101,110,100, 10,101,110,100, 10, + 10, 10,105,102, 32, 99,108, 97,115,115, 32, 97,110,100, 32, + 115,101,108,102, 46,110, 97,109,101,126, 61, 39,110,101,119, + 39, 32, 97,110,100, 32,115,116, 97,116,105, 99, 61, 61,110, + 105,108, 32,116,104,101,110, 10,111,117,116,112,117,116, 40, + 39, 32,105,102, 32, 40, 33,115,101,108,102, 41, 32,116,111, + 108,117, 97, 95,101,114,114,111,114, 40,116,111,108,117, 97, + 95, 83, 44, 34,105,110,118, 97,108,105,100, 32, 92, 39,115, + 101,108,102, 92, 39, 32,105,110, 32,102,117,110, 99,116,105, + 111,110, 32, 92, 39, 39, 46, 46,115,101,108,102, 46,110, 97, + 109,101, 46, 46, 39, 92, 39, 34, 41, 59, 39, 41, 59, 10,101, + 110,100, 10, 10, 10,105,102, 32, 99,108, 97,115,115, 32,116, + 104,101,110, 32,110, 97,114,103, 61, 50, 32,101,108,115,101, + 32,110, 97,114,103, 61, 49, 32,101,110,100, 10,105,102, 32, + 115,101,108,102, 46, 97,114,103,115, 91, 49, 93, 46,116,121, + 112,101, 32,126, 61, 32, 39,118,111,105,100, 39, 32,116,104, + 101,110, 10,108,111, 99, 97,108, 32,105, 61, 49, 10,119,104, + 105,108,101, 32,115,101,108,102, 46, 97,114,103,115, 91,105, + 93, 32,100,111, 10,115,101,108,102, 46, 97,114,103,115, 91, + 105, 93, 58,103,101,116, 97,114,114, 97,121, 40,110, 97,114, + 103, 41, 10,110, 97,114,103, 32, 61, 32,110, 97,114,103, 43, + 49, 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,101, + 110,100, 10, 10, 10,105,102, 32, 99,108, 97,115,115, 32, 97, + 110,100, 32,115,101,108,102, 46,110, 97,109,101, 61, 61, 39, + 100,101,108,101,116,101, 39, 32,116,104,101,110, 10,111,117, + 116,112,117,116, 40, 39, 32,100,101,108,101,116,101, 32,115, + 101,108,102, 59, 39, 41, 10,101,108,115,101,105,102, 32, 99, + 108, 97,115,115, 32, 97,110,100, 32,115,101,108,102, 46,110, + 97,109,101, 32, 61, 61, 32, 39,111,112,101,114, 97,116,111, + 114, 38, 91, 93, 39, 32,116,104,101,110, 10,111,117,116,112, + 117,116, 40, 39, 32,115,101,108,102, 45, 62,111,112,101,114, + 97,116,111,114, 91, 93, 40, 39, 44,115,101,108,102, 46, 97, + 114,103,115, 91, 49, 93, 46,110, 97,109,101, 44, 39, 41, 32, + 61, 32, 39, 44,115,101,108,102, 46, 97,114,103,115, 91, 50, + 93, 46,110, 97,109,101, 44, 39, 59, 39, 41, 10,101,108,115, + 101, 10,111,117,116,112,117,116, 40, 39, 32,123, 39, 41, 10, + 105,102, 32,115,101,108,102, 46,116,121,112,101, 32,126, 61, + 32, 39, 39, 32, 97,110,100, 32,115,101,108,102, 46,116,121, + 112,101, 32,126, 61, 32, 39,118,111,105,100, 39, 32,116,104, + 101,110, 10,111,117,116,112,117,116, 40, 39, 32, 39, 44,115, + 101,108,102, 46,109,111,100, 44,115,101,108,102, 46,116,121, + 112,101, 44,115,101,108,102, 46,112,116,114, 44, 39,116,111, + 108,117, 97, 73, 95,114,101,116, 32, 61, 32, 39, 41, 10,111, + 117,116,112,117,116, 40, 39, 40, 39, 44,115,101,108,102, 46, + 109,111,100, 44,115,101,108,102, 46,116,121,112,101, 44,115, + 101,108,102, 46,112,116,114, 44, 39, 41, 32, 39, 41, 10,101, + 108,115,101, 10,111,117,116,112,117,116, 40, 39, 32, 39, 41, + 10,101,110,100, 10,105,102, 32, 99,108, 97,115,115, 32, 97, + 110,100, 32,115,101,108,102, 46,110, 97,109,101, 61, 61, 39, + 110,101,119, 39, 32,116,104,101,110, 10,111,117,116,112,117, + 116, 40, 39,110,101,119, 39, 44, 99,108, 97,115,115, 44, 39, + 40, 39, 41, 10,101,108,115,101,105,102, 32, 99,108, 97,115, + 115, 32, 97,110,100, 32,115,116, 97,116,105, 99, 32,116,104, + 101,110, 10,111,117,116,112,117,116, 40, 99,108, 97,115,115, + 46, 46, 39, 58, 58, 39, 46, 46,115,101,108,102, 46,110, 97, + 109,101, 44, 39, 40, 39, 41, 10,101,108,115,101,105,102, 32, + 99,108, 97,115,115, 32,116,104,101,110, 10,111,117,116,112, + 117,116, 40, 39,115,101,108,102, 45, 62, 39, 46, 46,115,101, + 108,102, 46,110, 97,109,101, 44, 39, 40, 39, 41, 10,101,108, + 115,101, 10,111,117,116,112,117,116, 40,115,101,108,102, 46, + 110, 97,109,101, 44, 39, 40, 39, 41, 10,101,110,100, 10, 10, + 10,108,111, 99, 97,108, 32,105, 61, 49, 10,119,104,105,108, + 101, 32,115,101,108,102, 46, 97,114,103,115, 91,105, 93, 32, + 100,111, 10,115,101,108,102, 46, 97,114,103,115, 91,105, 93, + 58,112, 97,115,115,112, 97,114, 40, 41, 10,105, 32, 61, 32, + 105, 43, 49, 10,105,102, 32,115,101,108,102, 46, 97,114,103, + 115, 91,105, 93, 32,116,104,101,110, 10,111,117,116,112,117, + 116, 40, 39, 44, 39, 41, 10,101,110,100, 10,101,110,100, 10, + 10,111,117,116,112,117,116, 40, 39, 41, 59, 39, 41, 10, 10, + 10,105,102, 32,115,101,108,102, 46,116,121,112,101, 32,126, + 61, 32, 39, 39, 32, 97,110,100, 32,115,101,108,102, 46,116, + 121,112,101, 32,126, 61, 32, 39,118,111,105,100, 39, 32,116, + 104,101,110, 10,110,114,101,116, 32, 61, 32,110,114,101,116, + 32, 43, 32, 49, 10,108,111, 99, 97,108, 32,116, 44, 99,116, + 32, 61, 32,105,115, 98, 97,115,105, 99, 40,115,101,108,102, + 46,116,121,112,101, 41, 10,105,102, 32,116, 32,116,104,101, + 110, 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, + 97, 95,112,117,115,104, 39, 46, 46,116, 46, 46, 39, 40,116, + 111,108,117, 97, 95, 83, 44, 40, 39, 44, 99,116, 44, 39, 41, + 116,111,108,117, 97, 73, 95,114,101,116, 41, 59, 39, 41, 10, + 101,108,115,101, 10,105,102, 32,115,101,108,102, 46,112,116, + 114, 32, 61, 61, 32, 39, 39, 32,116,104,101,110, 10,111,117, + 116,112,117,116, 40, 39, 32,123, 39, 41, 10,111,117,116,112, + 117,116, 40, 39, 35,105,102,100,101,102, 32, 95, 95, 99,112, + 108,117,115,112,108,117,115, 92,110, 39, 41, 10,111,117,116, + 112,117,116, 40, 39, 32,118,111,105,100, 42, 32,116,111,108, + 117, 97, 73, 95, 99,108,111,110,101, 32, 61, 32,110,101,119, + 39, 44,115,101,108,102, 46,116,121,112,101, 44, 39, 40,116, + 111,108,117, 97, 73, 95,114,101,116, 41, 59, 39, 41, 10,111, + 117,116,112,117,116, 40, 39, 35,101,108,115,101, 92,110, 39, + 41, 10,111,117,116,112,117,116, 40, 39, 32,118,111,105,100, + 42, 32,116,111,108,117, 97, 73, 95, 99,108,111,110,101, 32, + 61, 32,116,111,108,117, 97, 95, 99,111,112,121, 40,116,111, + 108,117, 97, 95, 83, 44, 40,118,111,105,100, 42, 41, 38,116, + 111,108,117, 97, 73, 95,114,101,116, 44,115,105,122,101,111, + 102, 40, 39, 44,115,101,108,102, 46,116,121,112,101, 44, 39, + 41, 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, 39, 35, + 101,110,100,105,102, 92,110, 39, 41, 10,111,117,116,112,117, + 116, 40, 39, 32,116,111,108,117, 97, 95,112,117,115,104,117, + 115,101,114,116,121,112,101, 40,116,111,108,117, 97, 95, 83, + 44,116,111,108,117, 97, 95,100,111, 99,108,111,110,101, 40, + 116,111,108,117, 97, 95, 83, 44,116,111,108,117, 97, 73, 95, + 99,108,111,110,101, 44, 39, 44,115,101,108,102, 46,116, 97, + 103, 44, 39, 41, 44, 39, 44,115,101,108,102, 46,116, 97,103, + 44, 39, 41, 59, 39, 41, 10,111,117,116,112,117,116, 40, 39, + 32,125, 39, 41, 10, 10,101,108,115,101,105,102, 32,115,101, + 108,102, 46,112,116,114, 32, 61, 61, 32, 39, 38, 39, 32,116, + 104,101,110, 10,111,117,116,112,117,116, 40, 39, 32,116,111, + 108,117, 97, 95,112,117,115,104,117,115,101,114,116,121,112, + 101, 40,116,111,108,117, 97, 95, 83, 44, 40,118,111,105,100, + 42, 41, 38,116,111,108,117, 97, 73, 95,114,101,116, 44, 39, + 44,115,101,108,102, 46,116, 97,103, 44, 39, 41, 59, 39, 41, + 10,101,108,115,101, 10,111,117,116,112,117,116, 40, 39, 32, + 116,111,108,117, 97, 95,112,117,115,104,117,115,101,114,116, + 121,112,101, 40,116,111,108,117, 97, 95, 83, 44, 40,118,111, + 105,100, 42, 41,116,111,108,117, 97, 73, 95,114,101,116, 44, + 39, 44,115,101,108,102, 46,116, 97,103, 44, 39, 41, 59, 39, + 41, 10,101,110,100, 10,101,110,100, 10,101,110,100, 10,108, + 111, 99, 97,108, 32,105, 61, 49, 10,119,104,105,108,101, 32, + 115,101,108,102, 46, 97,114,103,115, 91,105, 93, 32,100,111, + 10,110,114,101,116, 32, 61, 32,110,114,101,116, 32, 43, 32, + 115,101,108,102, 46, 97,114,103,115, 91,105, 93, 58,114,101, + 116,118, 97,108,117,101, 40, 41, 10,105, 32, 61, 32,105, 43, + 49, 10,101,110,100, 10,111,117,116,112,117,116, 40, 39, 32, + 125, 39, 41, 10, 10, 10,105,102, 32, 99,108, 97,115,115, 32, + 116,104,101,110, 32,110, 97,114,103, 61, 50, 32,101,108,115, + 101, 32,110, 97,114,103, 61, 49, 32,101,110,100, 10,105,102, + 32,115,101,108,102, 46, 97,114,103,115, 91, 49, 93, 46,116, + 121,112,101, 32,126, 61, 32, 39,118,111,105,100, 39, 32,116, + 104,101,110, 10,108,111, 99, 97,108, 32,105, 61, 49, 10,119, + 104,105,108,101, 32,115,101,108,102, 46, 97,114,103,115, 91, + 105, 93, 32,100,111, 10,115,101,108,102, 46, 97,114,103,115, + 91,105, 93, 58,115,101,116, 97,114,114, 97,121, 40,110, 97, + 114,103, 41, 10,110, 97,114,103, 32, 61, 32,110, 97,114,103, + 43, 49, 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10, + 101,110,100, 10, 10, 10,105,102, 32,115,101,108,102, 46, 97, + 114,103,115, 91, 49, 93, 46,116,121,112,101, 32,126, 61, 32, + 39,118,111,105,100, 39, 32,116,104,101,110, 10,108,111, 99, + 97,108, 32,105, 61, 49, 10,119,104,105,108,101, 32,115,101, + 108,102, 46, 97,114,103,115, 91,105, 93, 32,100,111, 10,115, + 101,108,102, 46, 97,114,103,115, 91,105, 93, 58,102,114,101, + 101, 97,114,114, 97,121, 40, 41, 10,105, 32, 61, 32,105, 43, + 49, 10,101,110,100, 10,101,110,100, 10,101,110,100, 10, 10, + 111,117,116,112,117,116, 40, 39, 32,125, 39, 41, 10,111,117, + 116,112,117,116, 40, 39, 32,114,101,116,117,114,110, 32, 39, + 46, 46,110,114,101,116, 46, 46, 39, 59, 39, 41, 10, 10, 10, + 111,117,116,112,117,116, 40, 39,116,111,108,117, 97, 95,108, + 101,114,114,111,114, 58, 92,110, 39, 41, 10,108,111, 99, 97, + 108, 32,111,118,101,114,108,111, 97,100, 32, 61, 32,115,116, + 114,115,117, 98, 40,115,101,108,102, 46, 99,110, 97,109,101, + 44, 45, 50, 44, 45, 49, 41, 32, 45, 32, 49, 10,105,102, 32, + 111,118,101,114,108,111, 97,100, 32, 62, 61, 32, 48, 32,116, + 104,101,110, 10,111,117,116,112,117,116, 40, 39, 32,114,101, + 116,117,114,110, 32, 39, 46, 46,115,116,114,115,117, 98, 40, + 115,101,108,102, 46, 99,110, 97,109,101, 44, 49, 44, 45, 51, + 41, 46, 46,102,111,114,109, 97,116, 40, 34, 37, 48, 50,100, + 34, 44,111,118,101,114,108,111, 97,100, 41, 46, 46, 39, 40, + 116,111,108,117, 97, 95, 83, 41, 59, 39, 41, 10,101,108,115, + 101, 10,111,117,116,112,117,116, 40, 39, 32,116,111,108,117, + 97, 95,101,114,114,111,114, 40,116,111,108,117, 97, 95, 83, + 44, 34, 35,102,101,114,114,111,114, 32,105,110, 32,102,117, + 110, 99,116,105,111,110, 32, 92, 39, 39, 46, 46,115,101,108, + 102, 46,108,110, 97,109,101, 46, 46, 39, 92, 39, 46, 34, 41, + 59, 39, 41, 10,111,117,116,112,117,116, 40, 39, 32,114,101, + 116,117,114,110, 32, 48, 59, 39, 41, 10,101,110,100, 10, 10, + 111,117,116,112,117,116, 40, 39,125, 39, 41, 10,111,117,116, + 112,117,116, 40, 39, 92,110, 39, 41, 10,101,110,100, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115,115, + 70,117,110, 99,116,105,111,110, 58,114,101,103,105,115,116, + 101,114, 32, 40, 41, 10,108,111, 99, 97,108, 32,112, 97,114, + 101,110,116, 32, 61, 32,115,101,108,102, 58,105,110, 99,108, + 97,115,115, 40, 41, 32,111,114, 32,115,101,108,102, 58,105, + 110,109,111,100,117,108,101, 40, 41, 10,105,102, 32,112, 97, + 114,101,110,116, 32,116,104,101,110, 10,111,117,116,112,117, + 116, 40, 39, 32,116,111,108,117, 97, 95,102,117,110, 99,116, + 105,111,110, 40,116,111,108,117, 97, 95, 83, 44, 34, 39, 46, + 46,112, 97,114,101,110,116, 46, 46, 39, 34, 44, 34, 39, 46, + 46,115,101,108,102, 46,108,110, 97,109,101, 46, 46, 39, 34, + 44, 39, 46, 46,115,101,108,102, 46, 99,110, 97,109,101, 46, + 46, 39, 41, 59, 39, 41, 10,101,108,115,101, 10,111,117,116, + 112,117,116, 40, 39, 32,116,111,108,117, 97, 95,102,117,110, + 99,116,105,111,110, 40,116,111,108,117, 97, 95, 83, 44, 78, + 85, 76, 76, 44, 34, 39, 46, 46,115,101,108,102, 46,108,110, + 97,109,101, 46, 46, 39, 34, 44, 39, 46, 46,115,101,108,102, + 46, 99,110, 97,109,101, 46, 46, 39, 41, 59, 39, 41, 10,101, + 110,100, 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105, + 111,110, 32, 99,108, 97,115,115, 70,117,110, 99,116,105,111, + 110, 58,117,110,114,101,103,105,115,116,101,114, 32, 40, 41, + 10,105,102, 32,115,101,108,102, 58,105,110, 99,108, 97,115, + 115, 40, 41, 61, 61,110,105,108, 32, 97,110,100, 32,115,101, + 108,102, 58,105,110,109,111,100,117,108,101, 40, 41, 61, 61, + 110,105,108, 32,116,104,101,110, 10,111,117,116,112,117,116, + 40, 39, 32,108,117, 97, 95,112,117,115,104,110,105,108, 40, + 116,111,108,117, 97, 95, 83, 41, 59, 32,108,117, 97, 95,115, + 101,116,103,108,111, 98, 97,108, 40,116,111,108,117, 97, 95, + 83, 44, 34, 39, 46, 46,115,101,108,102, 46,108,110, 97,109, + 101, 46, 46, 39, 34, 41, 59, 39, 41, 10,101,110,100, 10,101, + 110,100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, + 99,108, 97,115,115, 70,117,110, 99,116,105,111,110, 58,112, + 114,105,110,116, 32, 40,105,100,101,110,116, 44, 99,108,111, + 115,101, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, + 46, 46, 34, 70,117,110, 99,116,105,111,110,123, 34, 41, 10, + 112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32, + 109,111,100, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46, + 109,111,100, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110, + 116, 40,105,100,101,110,116, 46, 46, 34, 32,116,121,112,101, + 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,116,121,112, + 101, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40, + 105,100,101,110,116, 46, 46, 34, 32,112,116,114, 32, 61, 32, + 39, 34, 46, 46,115,101,108,102, 46,112,116,114, 46, 46, 34, + 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34, 32,110, 97,109,101, 32, 61, 32, 39, 34, 46, + 46,115,101,108,102, 46,110, 97,109,101, 46, 46, 34, 39, 44, + 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, + 46, 34, 32, 99,111,110,115,116, 32, 61, 32, 39, 34, 46, 46, + 115,101,108,102, 46, 99,111,110,115,116, 46, 46, 34, 39, 44, + 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, + 46, 34, 32, 99,110, 97,109,101, 32, 61, 32, 39, 34, 46, 46, + 115,101,108,102, 46, 99,110, 97,109,101, 46, 46, 34, 39, 44, + 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, + 46, 34, 32,108,110, 97,109,101, 32, 61, 32, 39, 34, 46, 46, + 115,101,108,102, 46,108,110, 97,109,101, 46, 46, 34, 39, 44, + 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, + 46, 34, 32, 97,114,103,115, 32, 61, 32,123, 34, 41, 10,108, + 111, 99, 97,108, 32,105, 61, 49, 10,119,104,105,108,101, 32, + 115,101,108,102, 46, 97,114,103,115, 91,105, 93, 32,100,111, + 10,115,101,108,102, 46, 97,114,103,115, 91,105, 93, 58,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32, 34, + 44, 34, 44, 34, 41, 10,105, 32, 61, 32,105, 43, 49, 10,101, + 110,100, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, + 46, 34, 32,125, 34, 41, 10,112,114,105,110,116, 40,105,100, + 101,110,116, 46, 46, 34,125, 34, 46, 46, 99,108,111,115,101, + 41, 10,101,110,100, 10, 10, 10,102,117,110, 99,116,105,111, + 110, 32, 99,108, 97,115,115, 70,117,110, 99,116,105,111,110, + 58,111,118,101,114,108,111, 97,100, 32, 40, 41, 10,114,101, + 116,117,114,110, 32,115,101,108,102, 46,112, 97,114,101,110, + 116, 58,111,118,101,114,108,111, 97,100, 40,115,101,108,102, + 46,108,110, 97,109,101, 41, 10,101,110,100, 10, 10, 10, 10, + 10,102,117,110, 99,116,105,111,110, 32, 95, 70,117,110, 99, + 116,105,111,110, 32, 40,116, 41, 10,116, 46, 95, 98, 97,115, + 101, 32, 61, 32, 99,108, 97,115,115, 70,117,110, 99,116,105, + 111,110, 10,115,101,116,116, 97,103, 40,116, 44,116,111,108, + 117, 97, 95,116, 97,103, 41, 10, 10,105,102, 32,116, 46, 99, + 111,110,115,116, 32,126, 61, 32, 39, 99,111,110,115,116, 39, + 32, 97,110,100, 32,116, 46, 99,111,110,115,116, 32,126, 61, + 32, 39, 39, 32,116,104,101,110, 10,101,114,114,111,114, 40, + 34, 35,105,110,118, 97,108,105,100, 32, 39, 99,111,110,115, + 116, 39, 32,115,112,101, 99,105,102,105, 99, 97,116,105,111, + 110, 34, 41, 10,101,110,100, 10, 10, 97,112,112,101,110,100, + 40,116, 41, 10,105,102, 32,116, 58,105,110, 99,108, 97,115, + 115, 40, 41, 32,116,104,101,110, 10,105,102, 32,116, 46,110, + 97,109,101, 32, 61, 61, 32,116, 46,112, 97,114,101,110,116, + 46,110, 97,109,101, 32,116,104,101,110, 10,116, 46,110, 97, + 109,101, 32, 61, 32, 39,110,101,119, 39, 10,116, 46,108,110, + 97,109,101, 32, 61, 32, 39,110,101,119, 39, 10,116, 46,116, + 121,112,101, 32, 61, 32,116, 46,112, 97,114,101,110,116, 46, + 110, 97,109,101, 10,116, 46,112,116,114, 32, 61, 32, 39, 42, + 39, 10,101,108,115,101,105,102, 32,116, 46,110, 97,109,101, + 32, 61, 61, 32, 39,126, 39, 46, 46,116, 46,112, 97,114,101, + 110,116, 46,110, 97,109,101, 32,116,104,101,110, 10,116, 46, + 110, 97,109,101, 32, 61, 32, 39,100,101,108,101,116,101, 39, + 10,116, 46,108,110, 97,109,101, 32, 61, 32, 39,100,101,108, + 101,116,101, 39, 10,101,110,100, 10,101,110,100, 10,116, 46, + 99,110, 97,109,101, 32, 61, 32,116, 58, 99,102,117,110, 99, + 110, 97,109,101, 40, 34,116,111,108,117, 97, 73, 34, 41, 46, + 46,116, 58,111,118,101,114,108,111, 97,100, 40,116, 41, 10, + 114,101,116,117,114,110, 32,116, 10,101,110,100, 10, 10, 10, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 70,117,110, + 99,116,105,111,110, 32, 40,100, 44, 97, 44, 99, 41, 10,108, + 111, 99, 97,108, 32,116, 32, 61, 32,115,112,108,105,116, 40, + 115,116,114,115,117, 98, 40, 97, 44, 50, 44, 45, 50, 41, 44, + 39, 44, 39, 41, 10,108,111, 99, 97,108, 32,105, 61, 49, 10, + 108,111, 99, 97,108, 32,108, 32, 61, 32,123,110, 61, 48,125, + 10,119,104,105,108,101, 32,116, 91,105, 93, 32,100,111, 10, + 108, 46,110, 32, 61, 32,108, 46,110, 43, 49, 10,108, 91,108, + 46,110, 93, 32, 61, 32, 68,101, 99,108, 97,114, 97,116,105, + 111,110, 40,116, 91,105, 93, 44, 39,118, 97,114, 39, 41, 10, + 105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,108,111, 99, + 97,108, 32,102, 32, 61, 32, 68,101, 99,108, 97,114, 97,116, + 105,111,110, 40,100, 44, 39,102,117,110, 99, 39, 41, 10,102, + 46, 97,114,103,115, 32, 61, 32,108, 10,102, 46, 99,111,110, + 115,116, 32, 61, 32, 99, 10,114,101,116,117,114,110, 32, 95, + 70,117,110, 99,116,105,111,110, 40,102, 41, 10,101,110,100, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 99,108, 97,115,115, 79,112,101,114, 97,116, + 111,114, 32, 61, 32,123, 10,107,105,110,100, 32, 61, 32, 39, + 39, 44, 10, 95, 98, 97,115,101, 32, 61, 32, 99,108, 97,115, + 115, 70,117,110, 99,116,105,111,110, 44, 10,125, 10,115,101, + 116,116, 97,103, 40, 99,108, 97,115,115, 79,112,101,114, 97, + 116,111,114, 44,116,111,108,117, 97, 95,116, 97,103, 41, 10, + 10, 10, 95, 84, 77, 32, 61, 32,123, 91, 39, 43, 39, 93, 32, + 61, 32, 39,111,112,101,114, 97,116,111,114, 95, 97,100,100, + 39, 44, 10, 91, 39, 45, 39, 93, 32, 61, 32, 39,111,112,101, + 114, 97,116,111,114, 95,115,117, 98, 39, 44, 10, 91, 39, 42, + 39, 93, 32, 61, 32, 39,111,112,101,114, 97,116,111,114, 95, + 109,117,108, 39, 44, 10, 91, 39, 47, 39, 93, 32, 61, 32, 39, + 111,112,101,114, 97,116,111,114, 95,100,105,118, 39, 44, 10, + 91, 39, 60, 39, 93, 32, 61, 32, 39,111,112,101,114, 97,116, + 111,114, 95,108,116, 39, 44, 10, 91, 39, 91, 93, 39, 93, 32, + 61, 32, 39,111,112,101,114, 97,116,111,114, 95,103,101,116, + 39, 44, 10, 91, 39, 38, 91, 93, 39, 93, 32, 61, 32, 39,111, + 112,101,114, 97,116,111,114, 95,115,101,116, 39, 44, 10,125, + 10, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, + 97,115,115, 79,112,101,114, 97,116,111,114, 58,112,114,105, + 110,116, 32, 40,105,100,101,110,116, 44, 99,108,111,115,101, + 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, + 34, 79,112,101,114, 97,116,111,114,123, 34, 41, 10,112,114, + 105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32,107,105, + 110,100, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, 46,107, + 105,110,100, 46, 46, 34, 39, 44, 34, 41, 10,112,114,105,110, + 116, 40,105,100,101,110,116, 46, 46, 34, 32,109,111,100, 32, + 61, 32, 39, 34, 46, 46,115,101,108,102, 46,109,111,100, 46, + 46, 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100, + 101,110,116, 46, 46, 34, 32,116,121,112,101, 32, 61, 32, 39, + 34, 46, 46,115,101,108,102, 46,116,121,112,101, 46, 46, 34, + 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101,110, + 116, 46, 46, 34, 32,112,116,114, 32, 61, 32, 39, 34, 46, 46, + 115,101,108,102, 46,112,116,114, 46, 46, 34, 39, 44, 34, 41, + 10,112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, + 32,110, 97,109,101, 32, 61, 32, 39, 34, 46, 46,115,101,108, + 102, 46,110, 97,109,101, 46, 46, 34, 39, 44, 34, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32, 99, + 111,110,115,116, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, + 46, 99,111,110,115,116, 46, 46, 34, 39, 44, 34, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32, 99, + 110, 97,109,101, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, + 46, 99,110, 97,109,101, 46, 46, 34, 39, 44, 34, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32,108, + 110, 97,109,101, 32, 61, 32, 39, 34, 46, 46,115,101,108,102, + 46,108,110, 97,109,101, 46, 46, 34, 39, 44, 34, 41, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32, 97, + 114,103,115, 32, 61, 32,123, 34, 41, 10,108,111, 99, 97,108, + 32,105, 61, 49, 10,119,104,105,108,101, 32,115,101,108,102, + 46, 97,114,103,115, 91,105, 93, 32,100,111, 10,115,101,108, + 102, 46, 97,114,103,115, 91,105, 93, 58,112,114,105,110,116, + 40,105,100,101,110,116, 46, 46, 34, 32, 34, 44, 34, 44, 34, + 41, 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,112, + 114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 32,125, + 34, 41, 10,112,114,105,110,116, 40,105,100,101,110,116, 46, + 46, 34,125, 34, 46, 46, 99,108,111,115,101, 41, 10,101,110, + 100, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 95, 79, + 112,101,114, 97,116,111,114, 32, 40,116, 41, 10,116, 46, 95, + 98, 97,115,101, 32, 61, 32, 99,108, 97,115,115, 79,112,101, + 114, 97,116,111,114, 10,115,101,116,116, 97,103, 40,116, 44, + 116,111,108,117, 97, 95,116, 97,103, 41, 10, 10,105,102, 32, + 116, 46, 99,111,110,115,116, 32,126, 61, 32, 39, 99,111,110, + 115,116, 39, 32, 97,110,100, 32,116, 46, 99,111,110,115,116, + 32,126, 61, 32, 39, 39, 32,116,104,101,110, 10,101,114,114, + 111,114, 40, 34, 35,105,110,118, 97,108,105,100, 32, 39, 99, + 111,110,115,116, 39, 32,115,112,101, 99,105,102,105, 99, 97, + 116,105,111,110, 34, 41, 10,101,110,100, 10, 10, 97,112,112, + 101,110,100, 40,116, 41, 10,105,102, 32,110,111,116, 32,116, + 58,105,110, 99,108, 97,115,115, 40, 41, 32,116,104,101,110, + 10,101,114,114,111,114, 40, 34, 35,111,112,101,114, 97,116, + 111,114, 32, 99, 97,110, 32,111,110,108,121, 32, 98,101, 32, + 100,101,102,105,110,101,100, 32, 97,115, 32, 99,108, 97,115, + 115, 32,109,101,109, 98,101,114, 34, 41, 10,101,110,100, 10, + 10,116, 46, 99,110, 97,109,101, 32, 61, 32,116, 58, 99,102, + 117,110, 99,110, 97,109,101, 40, 34,116,111,108,117, 97, 73, + 34, 41, 46, 46,116, 58,111,118,101,114,108,111, 97,100, 40, + 116, 41, 10,116, 46,110, 97,109,101, 32, 61, 32,116, 46,110, + 97,109,101, 46, 46,116, 46,107,105,110,100, 10,114,101,116, + 117,114,110, 32,116, 10,101,110,100, 10, 10, 10, 10, 10, 10, + 102,117,110, 99,116,105,111,110, 32, 79,112,101,114, 97,116, + 111,114, 32, 40,100, 44,107, 44, 97, 44, 99, 41, 10,108,111, + 99, 97,108, 32,116, 32, 61, 32,115,112,108,105,116, 40,115, + 116,114,115,117, 98, 40, 97, 44, 50, 44,115,116,114,108,101, + 110, 40, 97, 41, 45, 49, 41, 44, 39, 44, 39, 41, 10,108,111, + 99, 97,108, 32,105, 61, 49, 10,108,111, 99, 97,108, 32,108, + 32, 61, 32,123,110, 61, 48,125, 10,119,104,105,108,101, 32, + 116, 91,105, 93, 32,100,111, 10,108, 46,110, 32, 61, 32,108, + 46,110, 43, 49, 10,108, 91,108, 46,110, 93, 32, 61, 32, 68, + 101, 99,108, 97,114, 97,116,105,111,110, 40,116, 91,105, 93, + 44, 39,118, 97,114, 39, 41, 10,105, 32, 61, 32,105, 43, 49, + 10,101,110,100, 10,105,102, 32,107, 32, 61, 61, 32, 39, 91, + 93, 39, 32,116,104,101,110, 10,100, 32, 61, 32,103,115,117, + 98, 40,100, 44, 39, 38, 39, 44, 39, 39, 41, 10,101,108,115, + 101,105,102, 32,107, 61, 61, 39, 38, 91, 93, 39, 32,116,104, + 101,110, 10,108, 46,110, 32, 61, 32,108, 46,110, 43, 49, 10, + 108, 91,108, 46,110, 93, 32, 61, 32, 68,101, 99,108, 97,114, + 97,116,105,111,110, 40,100, 44, 39,118, 97,114, 39, 41, 10, + 108, 91,108, 46,110, 93, 46,110, 97,109,101, 32, 61, 32, 39, + 116,111,108,117, 97, 73, 95,118, 97,108,117,101, 39, 10,101, + 110,100, 10,108,111, 99, 97,108, 32,102, 32, 61, 32, 68,101, + 99,108, 97,114, 97,116,105,111,110, 40,100, 44, 39,102,117, + 110, 99, 39, 41, 10,105,102, 32,107, 32, 61, 61, 32, 39, 91, + 93, 39, 32, 97,110,100, 32, 40,108, 91, 49, 93, 61, 61,110, + 105,108, 32,111,114, 32,105,115, 98, 97,115,105, 99, 40,108, + 91, 49, 93, 46,116,121,112,101, 41,126, 61, 39,110,117,109, + 98,101,114, 39, 41, 32,116,104,101,110, 10,101,114,114,111, + 114, 40, 39,111,112,101,114, 97,116,111,114, 91, 93, 32, 99, + 97,110, 32,111,110,108,121, 32, 98,101, 32,100,101,102,105, + 110,101,100, 32,102,111,114, 32,110,117,109,101,114,105, 99, + 32,105,110,100,101,120, 46, 39, 41, 10,101,110,100, 10,102, + 46, 97,114,103,115, 32, 61, 32,108, 10,102, 46, 99,111,110, + 115,116, 32, 61, 32, 99, 10,102, 46,107,105,110,100, 32, 61, + 32,103,115,117, 98, 40,107, 44, 34, 37,115, 34, 44, 34, 34, + 41, 10,102, 46,108,110, 97,109,101, 32, 61, 32, 95, 84, 77, + 91,102, 46,107,105,110,100, 93, 10,105,102, 32,110,111,116, + 32,102, 46,108,110, 97,109,101, 32,116,104,101,110, 10,101, + 114,114,111,114, 40, 34,116,111,108,117, 97, 58, 32,110,111, + 32,115,117,112,112,111,114,116, 32,102,111,114, 32,111,112, + 101,114, 97,116,111,114, 34, 32, 46, 46, 32,102, 46,107,105, + 110,100, 41, 10,101,110,100, 10,105,102, 32,102, 46,107,105, + 110,100, 32, 61, 61, 32, 39, 91, 93, 39, 32, 97,110,100, 32, + 110,111,116, 32,115,116,114,102,105,110,100, 40,102, 46,109, + 111,100, 44, 39, 99,111,110,115,116, 39, 41, 32,116,104,101, + 110, 10, 79,112,101,114, 97,116,111,114, 40,100, 44, 39, 38, + 39, 46, 46,107, 44, 97, 44, 99, 41, 10,101,110,100, 10,114, + 101,116,117,114,110, 32, 95, 79,112,101,114, 97,116,111,114, + 40,102, 41, 10,101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 99,108, 97,115, + 115, 67,108, 97,115,115, 32, 61, 32,123, 10, 95, 98, 97,115, + 101, 32, 61, 32, 99,108, 97,115,115, 67,111,110,116, 97,105, + 110,101,114, 44, 10,116,121,112,101, 32, 61, 32, 39, 99,108, + 97,115,115, 39, 44, 10,110, 97,109,101, 32, 61, 32, 39, 39, + 44, 10, 98, 97,115,101, 32, 61, 32, 39, 39, 44, 10,125, 10, + 115,101,116,116, 97,103, 40, 99,108, 97,115,115, 67,108, 97, + 115,115, 44,116,111,108,117, 97, 95,116, 97,103, 41, 10, 10, + 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97,115, + 115, 67,108, 97,115,115, 58,114,101,103,105,115,116,101,114, + 32, 40, 41, 10,111,117,116,112,117,116, 40, 39, 32,116,111, + 108,117, 97, 95, 99, 99,108, 97,115,115, 40,116,111,108,117, + 97, 95, 83, 44, 34, 39, 46, 46,115,101,108,102, 46,110, 97, + 109,101, 46, 46, 39, 34, 44, 34, 39, 46, 46,115,101,108,102, + 46, 98, 97,115,101, 46, 46, 39, 34, 41, 59, 39, 41, 10,108, + 111, 99, 97,108, 32,105, 61, 49, 10,119,104,105,108,101, 32, + 115,101,108,102, 91,105, 93, 32,100,111, 10,115,101,108,102, + 91,105, 93, 58,114,101,103,105,115,116,101,114, 40, 41, 10, + 105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,101,110,100, + 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, 97, + 115,115, 67,108, 97,115,115, 58,117,110,114,101,103,105,115, + 116,101,114, 32, 40, 41, 10,111,117,116,112,117,116, 40, 39, + 32,108,117, 97, 95,112,117,115,104,110,105,108, 40,116,111, + 108,117, 97, 95, 83, 41, 59, 32,108,117, 97, 95,115,101,116, + 103,108,111, 98, 97,108, 40,116,111,108,117, 97, 95, 83, 44, + 34, 39, 46, 46,115,101,108,102, 46,110, 97,109,101, 46, 46, + 39, 34, 41, 59, 39, 41, 10,101,110,100, 10, 10, 10,102,117, + 110, 99,116,105,111,110, 32, 99,108, 97,115,115, 67,108, 97, + 115,115, 58,100,101, 99,108,116, 97,103, 32, 40, 41, 10,115, + 101,108,102, 46,105,116,121,112,101, 44,115,101,108,102, 46, + 116, 97,103, 32, 61, 32,116, 97,103,118, 97,114, 40,115,101, + 108,102, 46,110, 97,109,101, 41, 59, 10,115,101,108,102, 46, + 99,105,116,121,112,101, 44,115,101,108,102, 46, 99,116, 97, + 103, 32, 61, 32,116, 97,103,118, 97,114, 40,115,101,108,102, + 46,110, 97,109,101, 44, 39, 99,111,110,115,116, 39, 41, 59, + 10,108,111, 99, 97,108, 32,105, 61, 49, 10,119,104,105,108, + 101, 32,115,101,108,102, 91,105, 93, 32,100,111, 10,115,101, + 108,102, 91,105, 93, 58,100,101, 99,108,116, 97,103, 40, 41, + 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,101,110, + 100, 10, 10, 10, 10,102,117,110, 99,116,105,111,110, 32, 99, + 108, 97,115,115, 67,108, 97,115,115, 58,112,114,105,110,116, + 32, 40,105,100,101,110,116, 44, 99,108,111,115,101, 41, 10, + 112,114,105,110,116, 40,105,100,101,110,116, 46, 46, 34, 67, + 108, 97,115,115,123, 34, 41, 10,112,114,105,110,116, 40,105, + 100,101,110,116, 46, 46, 34, 32,110, 97,109,101, 32, 61, 32, + 39, 34, 46, 46,115,101,108,102, 46,110, 97,109,101, 46, 46, + 34, 39, 44, 34, 41, 10,112,114,105,110,116, 40,105,100,101, + 110,116, 46, 46, 34, 32, 98, 97,115,101, 32, 61, 32, 39, 34, + 46, 46,115,101,108,102, 46, 98, 97,115,101, 46, 46, 34, 39, + 59, 34, 41, 10,108,111, 99, 97,108, 32,105, 61, 49, 10,119, + 104,105,108,101, 32,115,101,108,102, 91,105, 93, 32,100,111, + 10,115,101,108,102, 91,105, 93, 58,112,114,105,110,116, 40, + 105,100,101,110,116, 46, 46, 34, 32, 34, 44, 34, 44, 34, 41, + 10,105, 32, 61, 32,105, 43, 49, 10,101,110,100, 10,112,114, + 105,110,116, 40,105,100,101,110,116, 46, 46, 34,125, 34, 46, + 46, 99,108,111,115,101, 41, 10,101,110,100, 10, 10, 10,102, + 117,110, 99,116,105,111,110, 32, 95, 67,108, 97,115,115, 32, + 40,116, 41, 10,116, 46, 95, 98, 97,115,101, 32, 61, 32, 99, + 108, 97,115,115, 67,108, 97,115,115, 10,115,101,116,116, 97, + 103, 40,116, 44,116,111,108,117, 97, 95,116, 97,103, 41, 10, + 97,112,112,101,110,100, 40,116, 41, 10,114,101,116,117,114, + 110, 32,116, 10,101,110,100, 10, 10, 10, 10,102,117,110, 99, + 116,105,111,110, 32, 67,108, 97,115,115, 32, 40,110, 44,112, + 44, 98, 41, 10,108,111, 99, 97,108, 32, 99, 32, 61, 32, 95, + 67,108, 97,115,115, 40, 95, 67,111,110,116, 97,105,110,101, + 114,123,110, 97,109,101, 61,110, 44, 32, 98, 97,115,101, 61, + 112,125, 41, 10,112,117,115,104, 40, 99, 41, 10, 99, 58,112, + 97,114,115,101, 40,115,116,114,115,117, 98, 40, 98, 44, 50, + 44,115,116,114,108,101,110, 40, 98, 41, 45, 49, 41, 41, 10, + 112,111,112, 40, 41, 10,101,110,100, 10, 10, 10, 10, 83, 84, + 82, 49, 32, 61, 32, 34, 92, 48, 48, 49, 34, 10, 83, 84, 82, + 50, 32, 61, 32, 34, 92, 48, 48, 50, 34, 10, 83, 84, 82, 51, + 32, 61, 32, 34, 92, 48, 48, 51, 34, 10, 83, 84, 82, 52, 32, + 61, 32, 34, 92, 48, 48, 52, 34, 10, 82, 69, 77, 32, 61, 32, + 34, 92, 48, 48, 53, 34, 10, 65, 78, 89, 32, 61, 32, 34, 40, + 91, 92, 48, 48, 49, 45, 92, 48, 48, 53, 93, 41, 34, 10, 69, + 83, 67, 49, 32, 61, 32, 34, 92, 48, 48, 54, 34, 10, 69, 83, + 67, 50, 32, 61, 32, 34, 92, 48, 48, 55, 34, 10, 10, 77, 65, + 83, 75, 32, 61, 32,123, 10,123, 69, 83, 67, 49, 44, 32, 34, + 92, 92, 39, 34,125, 44, 10,123, 69, 83, 67, 50, 44, 32, 39, + 92, 92, 34, 39,125, 44, 10,123, 83, 84, 82, 49, 44, 32, 34, + 39, 34,125, 44, 10,123, 83, 84, 82, 50, 44, 32, 39, 34, 39, + 125, 44, 10,123, 83, 84, 82, 51, 44, 32, 34, 37, 91, 37, 91, + 34,125, 44, 10,123, 83, 84, 82, 52, 44, 32, 34, 37, 93, 37, + 93, 34,125, 44, 10,123, 82, 69, 77, 32, 44, 32, 34, 37, 45, + 37, 45, 34,125, 44, 10,125, 10, 10,102,117,110, 99,116,105, + 111,110, 32,109, 97,115,107, 32, 40,115, 41, 10,102,111,114, + 32,105, 32, 61, 32, 49, 44,103,101,116,110, 40, 77, 65, 83, + 75, 41, 32,100,111, 10,115, 32, 61, 32,103,115,117, 98, 40, + 115, 44, 77, 65, 83, 75, 91,105, 93, 91, 50, 93, 44, 77, 65, + 83, 75, 91,105, 93, 91, 49, 93, 41, 10,101,110,100, 10,114, + 101,116,117,114,110, 32,115, 10,101,110,100, 10, 10,102,117, + 110, 99,116,105,111,110, 32,117,110,109, 97,115,107, 32, 40, + 115, 41, 10,102,111,114, 32,105, 32, 61, 32, 49, 44,103,101, + 116,110, 40, 77, 65, 83, 75, 41, 32,100,111, 10,115, 32, 61, + 32,103,115,117, 98, 40,115, 44, 77, 65, 83, 75, 91,105, 93, + 91, 49, 93, 44, 77, 65, 83, 75, 91,105, 93, 91, 50, 93, 41, + 10,101,110,100, 10,114,101,116,117,114,110, 32,115, 10,101, + 110,100, 10, 10,102,117,110, 99,116,105,111,110, 32, 99,108, + 101, 97,110, 32, 40,115, 41, 10, 10,108,111, 99, 97,108, 32, + 99,111,100,101, 32, 61, 32, 34,114,101,116,117,114,110, 32, + 102,117,110, 99,116,105,111,110, 32, 40, 41, 32, 34, 32, 46, + 46, 32,115, 32, 46, 46, 32, 34, 32,101,110,100, 34, 10,105, + 102, 32,110,111,116, 32,100,111,115,116,114,105,110,103, 40, + 99,111,100,101, 41, 32,116,104,101,110, 10,114,101,116,117, + 114,110, 32,110,105,108, 10,101,110,100, 10, 10,108,111, 99, + 97,108, 32, 83, 32, 61, 32, 34, 34, 10, 10,115, 32, 61, 32, + 109, 97,115,107, 40,115, 41, 10, 10, 10,119,104,105,108,101, + 32, 49, 32,100,111, 10,108,111, 99, 97,108, 32, 98, 44,101, + 44,100, 32, 61, 32,115,116,114,102,105,110,100, 40,115, 44, + 65, 78, 89, 41, 10,105,102, 32, 98, 32,116,104,101,110, 10, + 83, 32, 61, 32, 83, 46, 46,115,116,114,115,117, 98, 40,115, + 44, 49, 44, 98, 45, 49, 41, 10,115, 32, 61, 32,115,116,114, + 115,117, 98, 40,115, 44, 98, 43, 49, 41, 10,105,102, 32,100, + 61, 61, 83, 84, 82, 49, 32,111,114, 32,100, 61, 61, 83, 84, + 82, 50, 32,116,104,101,110, 10,101, 32, 61, 32,115,116,114, + 102,105,110,100, 40,115, 44,100, 41, 10, 83, 32, 61, 32, 83, + 32, 46, 46,100, 46, 46,115,116,114,115,117, 98, 40,115, 44, + 49, 44,101, 41, 10,115, 32, 61, 32,115,116,114,115,117, 98, + 40,115, 44,101, 43, 49, 41, 10,101,108,115,101,105,102, 32, + 100, 61, 61, 83, 84, 82, 51, 32,116,104,101,110, 10,101, 32, + 61, 32,115,116,114,102,105,110,100, 40,115, 44, 83, 84, 82, + 52, 41, 10, 83, 32, 61, 32, 83, 46, 46,100, 46, 46,115,116, + 114,115,117, 98, 40,115, 44, 49, 44,101, 41, 10,115, 32, 61, + 32,115,116,114,115,117, 98, 40,115, 44,101, 43, 49, 41, 10, + 101,108,115,101,105,102, 32,100, 61, 61, 82, 69, 77, 32,116, + 104,101,110, 10,115, 32, 61, 32,103,115,117, 98, 40,115, 44, + 34, 91, 94, 92,110, 93, 42, 40, 92,110, 63, 41, 34, 44, 34, + 37, 49, 34, 44, 49, 41, 10,101,110,100, 10,101,108,115,101, + 10, 83, 32, 61, 32, 83, 46, 46,115, 10, 98,114,101, 97,107, + 10,101,110,100, 10,101,110,100, 10, 10, 83, 32, 61, 32,103, + 115,117, 98, 40, 83, 44, 34, 91, 32, 92,116, 93, 43, 34, 44, + 34, 32, 34, 41, 10, 83, 32, 61, 32,103,115,117, 98, 40, 83, + 44, 34, 91, 32, 92,116, 93, 42, 92,110, 91, 32, 92,116, 93, + 42, 34, 44, 34, 92,110, 34, 41, 10, 83, 32, 61, 32,117,110, + 109, 97,115,107, 40, 83, 41, 10,114,101,116,117,114,110, 32, + 83, 10,101,110,100, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10,105,102, 32,102,108, 97,103,115, 46,102, + 32,116,104,101,110, 10,108,111, 99, 97,108, 32,115,116, 44, + 32,109,115,103, 32, 61, 32,114,101, 97,100,102,114,111,109, + 40,102,108, 97,103,115, 46,102, 41, 10,105,102, 32,110,111, + 116, 32,115,116, 32,116,104,101,110, 10,101,114,114,111,114, + 40, 39, 35, 39, 46, 46,109,115,103, 41, 10,101,110,100, 10, + 101,110,100, 10, 10, 10,105,102, 32,110,111,116, 32,102,108, + 97,103,115, 46,110, 32,116,104,101,110, 10,105,102, 32,102, + 108, 97,103,115, 46,102, 32,116,104,101,110, 10,102,108, 97, + 103,115, 46,110, 32, 61, 32,103,115,117, 98, 40,102,108, 97, + 103,115, 46,102, 44, 34, 37, 46, 46, 42, 34, 44, 34, 34, 41, + 10,101,108,115,101, 10,101,114,114,111,114, 40, 34, 35,110, + 111, 32,112, 97, 99,107, 97,103,101, 32,110, 97,109,101, 32, + 110,111,114, 32,105,110,112,117,116, 32,102,105,108,101, 32, + 112,114,111,118,105,100,101,100, 34, 41, 10,101,110,100, 10, + 101,110,100, 10, 10,108,111, 99, 97,108, 32,112, 32, 61, 32, + 80, 97, 99,107, 97,103,101, 40,102,108, 97,103,115, 46,110, + 41, 10, 10,105,102, 32,102,108, 97,103,115, 46,102, 32,116, + 104,101,110, 10,114,101, 97,100,102,114,111,109, 40, 41, 10, + 101,110,100, 10, 10,105,102, 32,102,108, 97,103,115, 46,112, + 32,116,104,101,110, 10,114,101,116,117,114,110, 10,101,110, + 100, 10, 10,105,102, 32,102,108, 97,103,115, 46,111, 32,116, + 104,101,110, 10,108,111, 99, 97,108, 32,115,116, 44,109,115, + 103, 32, 61, 32,119,114,105,116,101,116,111, 40,102,108, 97, + 103,115, 46,111, 41, 10,105,102, 32,110,111,116, 32,115,116, + 32,116,104,101,110, 10,101,114,114,111,114, 40, 39, 35, 39, + 46, 46,109,115,103, 41, 10,101,110,100, 10,101,110,100, 10, + 10,105,102, 32,102,108, 97,103,115, 46, 80, 32,116,104,101, + 110, 10,112, 58,112,114,105,110,116, 40, 41, 10,101,108,115, + 101, 10,112, 58,100,101, 99,108,116, 97,103, 40, 41, 10,112, + 58,112,114,101, 97,109, 98,108,101, 40, 41, 10,112, 58,115, + 117,112, 99,111,100,101, 40, 41, 10,112, 58,114,101,103,105, + 115,116,101,114, 40, 41, 10,112, 58,117,110,114,101,103,105, + 115,116,101,114, 40, 41, 10,101,110,100, 10, 10,105,102, 32, + 102,108, 97,103,115, 46,111, 32,116,104,101,110, 10,119,114, + 105,116,101,116,111, 40, 41, 10,101,110,100, 10, 10, 10,105, + 102, 32,110,111,116, 32,102,108, 97,103,115, 46, 80, 32,116, + 104,101,110, 10,105,102, 32,102,108, 97,103,115, 46, 72, 32, + 116,104,101,110, 10,108,111, 99, 97,108, 32,115,116, 44,109, + 115,103, 32, 61, 32,119,114,105,116,101,116,111, 40,102,108, + 97,103,115, 46, 72, 41, 10,105,102, 32,110,111,116, 32,115, + 116, 32,116,104,101,110, 10,101,114,114,111,114, 40, 39, 35, + 39, 46, 46,109,115,103, 41, 10,101,110,100, 10,112, 58,104, + 101, 97,100,101,114, 40, 41, 10,119,114,105,116,101,116,111, + 40, 41, 10,101,110,100, 10,101,110,100,32 + }; + lua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code"); + } /* end of embedded lua code */ + + return 1; +} +/* Close function */ +void tolua_tolualua_close (lua_State* tolua_S) +{ +} diff --git a/src/lua/tolualua.h b/src/lua/tolualua.h new file mode 100644 index 00000000..b380dcef --- /dev/null +++ b/src/lua/tolualua.h @@ -0,0 +1,2713 @@ +/* code automatically generated by bin2c -- DO NOT EDIT */ +{ +/* #include'ing this file in a C program is equivalent to calling + lua_dofile("basic.lo"); + lua_dofile("feature.lo"); + lua_dofile("declaration.lo"); + lua_dofile("container.lo"); + lua_dofile("package.lo"); + lua_dofile("module.lo"); + lua_dofile("class.lo"); + lua_dofile("typedef.lo"); + lua_dofile("define.lo"); + lua_dofile("enumerate.lo"); + lua_dofile("variable.lo"); + lua_dofile("array.lo"); + lua_dofile("function.lo"); + lua_dofile("operator.lo"); + lua_dofile("verbatim.lo"); + lua_dofile("code.lo"); + lua_dofile("doit.lo"); +*/ +/* basic.lo */ +static char B1[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 11, 64, 98, 97,115,105, 99, + 46,108,117, 97, 0, 0, 0, 0,190, 25, 0, 60, 17, 22, 12, 60, 18, 11, 1, 11, + 2, 60, 19, 11, 3, 11, 4, 60, 20, 11, 5, 11, 4, 60, 21, 11, 6, 11, 4, 60, + 22, 11, 7, 11, 4, 60, 23, 11, 8, 11, 4, 60, 24, 11, 9, 11, 4, 60, 25, 11, + 10, 11, 11, 60, 26, 11, 12, 11, 13, 60, 27, 11, 14, 11, 11, 60, 28, 11, 15, 11, + 13, 60, 29, 11, 16, 11, 17, 30, 11, 60, 30, 25, 0, 60, 34, 22, 0, 25, 18, 60, + 37, 11, 20, 25, 19, 60, 45, 15, 22, 2, 1, 0, 25, 21, 60, 46, 15, 24, 15, 21, + 11, 25, 15, 19, 2, 1, 3, 25, 23, 60, 49, 11, 27, 25, 26, 60, 69, 15, 28, 15, + 26, 2, 0, 1, 60, 72, 11, 30, 25, 29, 60, 80, 22, 0, 25, 31, 60, 81, 11, 33, + 25, 32, 60, 89, 11, 35, 25, 34, 60,109, 11, 37, 25, 36, 60,115, 11, 39, 25, 38, + 60,121, 11, 41, 25, 40, 60,138, 11, 43, 25, 42, 60,150, 11, 45, 25, 44, 0, 0, + 0, 0, 0, 0, 0, 0, 46, 2, 0, 0, 0, 7, 95, 98, 97,115,105, 99, 0, 2, + 0, 0, 0, 5,118,111,105,100, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 5, + 99,104, 97,114, 0, 2, 0, 0, 0, 7,110,117,109, 98,101,114, 0, 2, 0, 0, + 0, 4,105,110,116, 0, 2, 0, 0, 0, 6,115,104,111,114,116, 0, 2, 0, 0, + 0, 5,108,111,110,103, 0, 2, 0, 0, 0, 6,102,108,111, 97,116, 0, 2, 0, + 0, 0, 7,100,111,117, 98,108,101, 0, 2, 0, 0, 0, 9, 95, 99,115,116,114, +105,110,103, 0, 2, 0, 0, 0, 7,115,116,114,105,110,103, 0, 2, 0, 0, 0, + 10, 95,117,115,101,114,100, 97,116, 97, 0, 2, 0, 0, 0, 9,117,115,101,114, +100, 97,116, 97, 0, 2, 0, 0, 0, 6, 99,104, 97,114, 42, 0, 2, 0, 0, 0, + 6,118,111,105,100, 42, 0, 2, 0, 0, 0, 11,108,117, 97, 95, 79, 98,106,101, + 99,116, 0, 2, 0, 0, 0, 7,111, 98,106,101, 99,116, 0, 2, 0, 0, 0, 10, + 95,117,115,101,114,116,121,112,101, 0, 2, 0, 0, 0, 12,116,111,108,117, 97, + 95,105,110,100,101,120, 0, 4, 0, 0, 0, 37, 0, 0, 0, 11, 64, 98, 97,115, +105, 99, 46,108,117, 97, 0, 0, 0, 0, 40, 5, 2, 60, 38, 13, 1, 11, 2, 32, + 52, 13, 60, 39, 15, 3, 13, 0, 13, 1, 3, 2, 2, 50, 13, 60, 41, 13, 0, 18, + 2, 13, 1, 16, 1, 2, 60, 42, 60, 43, 0, 0, 0, 0, 2, 0, 0, 0, 37, 0, + 0, 0, 2,116, 0, 0, 0, 0, 37, 0, 0, 0, 2,102, 0, 0, 0, 0, 4, 2, + 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 2,102, 0, 2, 0, 0, 0, 6, 95, 98, + 97,115,101, 0, 2, 0, 0, 0, 16,116,111,108,117, 97, 95,111,108,100, 95,105, +110,100,101,120, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, + 2, 0, 0, 0, 7,110,101,119,116, 97,103, 0, 2, 0, 0, 0, 16,116,111,108, +117, 97, 95,111,108,100, 95,105,110,100,101,120, 0, 2, 0, 0, 0, 13,115,101, +116,116, 97,103,109,101,116,104,111,100, 0, 2, 0, 0, 0, 6,105,110,100,101, +120, 0, 2, 0, 0, 0, 12,116,111,108,117, 97, 95,101,114,114,111,114, 0, 4, + 0, 0, 0, 49, 0, 0, 0, 11, 64, 98, 97,115,105, 99, 46,108,117, 97, 0, 0, + 0, 0,163, 9, 1, 60, 50, 15, 2, 60, 51, 15, 3, 25, 2, 60, 52, 15, 4, 13, + 0, 7, 1, 7, 1, 2, 1, 3, 11, 5, 32, 52, 24, 60, 53, 15, 6, 11, 7, 15, + 4, 13, 0, 7, 2, 2, 1, 2, 42, 11, 8, 42, 2, 0, 1, 50, 19, 60, 55, 15, + 6, 11, 9, 13, 0, 42, 11, 8, 42, 2, 0, 1, 60, 57, 1, 2, 60, 59, 15, 10, + 52, 73, 60, 60, 15, 12, 15, 10, 11, 13, 2, 3, 2, 60, 61, 13, 4, 4, 0, 32, + 52, 4, 15, 10, 23, 4, 60, 62, 15, 14, 13, 4, 11, 15, 11, 16, 2, 1, 3, 23, + 4, 60, 63, 15, 14, 13, 4, 11, 17, 11, 18, 2, 1, 3, 23, 4, 60, 64, 15, 6, + 11, 19, 13, 4, 42, 11, 20, 42, 2, 0, 1, 5, 3, 50, 2, 60, 65, 60, 66, 13, + 1, 25, 2, 60, 67, 0, 0, 0, 0, 8, 0, 0, 0, 49, 0, 0, 0, 2,115, 0, + 0, 0, 0, 50, 0, 0, 0, 4,111,117,116, 0, 0, 0, 0, 60, 0, 0, 0, 2, + 95, 0, 0, 0, 0, 60, 0, 0, 0, 2, 95, 0, 0, 0, 0, 60, 0, 0, 0, 2, +115, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, + 0, 64, 0, 0, 0, 0, 0, 0, 0, 21, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, + 0, 4,111,117,116, 0, 2, 0, 0, 0, 8, 95, 79, 85, 84, 80, 85, 84, 0, 2, + 0, 0, 0, 8, 95, 83, 84, 68, 69, 82, 82, 0, 2, 0, 0, 0, 7,115,116,114, +115,117, 98, 0, 2, 0, 0, 0, 2, 35, 0, 2, 0, 0, 0, 6,119,114,105,116, +101, 0, 2, 0, 0, 0, 12, 10, 42, 42, 32,116,111,108,117, 97, 58, 32, 0, 2, + 0, 0, 0, 4, 46, 10, 10, 0, 2, 0, 0, 0, 27, 10, 42, 42, 32,116,111,108, +117, 97, 32,105,110,116,101,114,110, 97,108, 32,101,114,114,111,114, 58, 32, 0, + 2, 0, 0, 0, 11, 95, 99,117,114,114, 95, 99,111,100,101, 0, 2, 0, 0, 0, + 2, 95, 0, 2, 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, 0, 0, 0, + 10, 94, 37,115, 42, 40, 46, 45, 10, 41, 0, 2, 0, 0, 0, 5,103,115,117, 98, + 0, 2, 0, 0, 0, 10, 95,117,115,101,114,100, 97,116, 97, 0, 2, 0, 0, 0, + 6,118,111,105,100, 42, 0, 2, 0, 0, 0, 9, 95, 99,115,116,114,105,110,103, + 0, 2, 0, 0, 0, 6, 99,104, 97,114, 42, 0, 2, 0, 0, 0, 23, 67,111,100, +101, 32, 98,101,105,110,103, 32,112,114,111, 99,101,115,115,101,100, 58, 10, 0, + 2, 0, 0, 0, 2, 10, 0, 2, 0, 0, 0, 15,115,101,116,101,114,114,111,114, +109,101,116,104,111,100, 0, 2, 0, 0, 0, 8,114,101,103,116,121,112,101, 0, + 4, 0, 0, 0, 72, 0, 0, 0, 11, 64, 98, 97,115,105, 99, 46,108,117, 97, 0, + 0, 0, 0, 36, 4, 1, 60, 73, 15, 1, 13, 0, 2, 1, 1, 44, 52, 11, 60, 74, + 15, 2, 13, 0, 13, 0, 26, 50, 2, 60, 75, 60, 76, 13, 0, 1, 1, 60, 77, 0, + 0, 0, 0, 1, 0, 0, 0, 72, 0, 0, 0, 2,116, 0, 0, 0, 0, 3, 2, 0, + 0, 0, 2,116, 0, 2, 0, 0, 0, 7,105,115,116,121,112,101, 0, 2, 0, 0, + 0, 10, 95,117,115,101,114,116,121,112,101, 0, 2, 0, 0, 0, 10, 95,116, 97, +103,110, 97,109,101,115, 0, 2, 0, 0, 0, 8,100,101, 99,108,116, 97,103, 0, + 4, 0, 0, 0, 81, 0, 0, 0, 11, 64, 98, 97,115,105, 99, 46,108,117, 97, 0, + 0, 0, 0, 67, 5, 2, 60, 82, 13, 0, 11, 2, 31, 48, 5, 13, 1, 7, 0, 31, + 48, 8, 15, 3, 13, 0, 2, 1, 1, 44, 48, 6, 15, 4, 13, 1, 16, 44, 52, 26, + 60, 83, 15, 4, 13, 1, 13, 0, 26, 60, 84, 15, 5, 11, 6, 13, 1, 42, 11, 7, + 42, 2, 0, 1, 50, 2, 60, 85, 60, 86, 0, 0, 0, 0, 2, 0, 0, 0, 81, 0, + 0, 0, 6,105,116,121,112,101, 0, 0, 0, 0, 81, 0, 0, 0, 4,116, 97,103, + 0, 0, 0, 0, 8, 2, 0, 0, 0, 6,105,116,121,112,101, 0, 2, 0, 0, 0, + 4,116, 97,103, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 8,105,115, 98, 97, +115,105, 99, 0, 2, 0, 0, 0, 10, 95,116, 97,103,110, 97,109,101,115, 0, 2, + 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 12,115,116, 97,116, +105, 99, 32,105,110,116, 32, 0, 2, 0, 0, 0, 2, 59, 0, 2, 0, 0, 0, 7, +116, 97,103,118, 97,114, 0, 4, 0, 0, 0, 89, 0, 0, 0, 11, 64, 98, 97,115, +105, 99, 46,108,117, 97, 0, 0, 0, 0,155, 8, 2, 60, 90, 13, 0, 11, 2, 32, + 46, 5, 13, 0, 11, 3, 32, 52, 10, 60, 91, 13, 0, 7, 0, 1, 2, 50,124, 60, + 92, 15, 4, 13, 0, 2, 1, 1, 52, 18, 60, 93, 13, 0, 11, 5, 15, 4, 13, 0, + 2, 1, 1, 42, 1, 2, 50, 95, 60, 95, 15, 8, 13, 0, 2, 2, 1, 60, 96, 15, + 9, 13, 2, 11, 1, 2, 1, 2, 52, 4, 11, 1, 23, 1, 60, 97, 13, 3, 23, 0, + 60, 98, 15, 10, 13, 3, 2, 0, 1, 60, 99, 11, 5, 60,100, 13, 1, 48, 5, 13, + 1, 11, 2, 31, 52, 20, 60,101, 11, 12, 13, 3, 42, 23, 3, 60,102, 13, 4, 11, + 13, 42, 23, 4, 50, 2, 60,103, 60,104, 13, 3, 13, 4, 13, 0, 42, 1, 5, 5, + 3, 60,105, 60,106, 0, 0, 0, 0, 8, 0, 0, 0, 89, 0, 0, 0, 5,116,121, +112,101, 0, 0, 0, 0, 89, 0, 0, 0, 6, 99,111,110,115,116, 0, 0, 0, 0, + 95, 0, 0, 0, 2,109, 0, 0, 0, 0, 95, 0, 0, 0, 2,116, 0, 0, 0, 0, + 99, 0, 0, 0, 2,118, 0, 0, 0, 0,104, 0, 0, 0, 0, 0, 0, 0,104, 0, + 0, 0, 0, 0, 0, 0,104, 0, 0, 0, 0, 0, 0, 0, 14, 2, 0, 0, 0, 5, +116,121,112,101, 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, 0, 0, 0, + 1, 0, 2, 0, 0, 0, 5,118,111,105,100, 0, 2, 0, 0, 0, 8,105,115, 98, + 97,115,105, 99, 0, 2, 0, 0, 0, 11,116,111,108,117, 97, 95,116, 97,103, 95, + 0, 2, 0, 0, 0, 2,109, 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 12, +102,105,110,100,116,121,112,101,100,101,102, 0, 2, 0, 0, 0, 8,115,116,114, +102,105,110,100, 0, 2, 0, 0, 0, 8,114,101,103,116,121,112,101, 0, 2, 0, + 0, 0, 2,118, 0, 2, 0, 0, 0, 7, 99,111,110,115,116, 32, 0, 2, 0, 0, + 0, 7, 99,111,110,115,116, 95, 0, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, + 99, 0, 4, 0, 0, 0,109, 0, 0, 0, 11, 64, 98, 97,115,105, 99, 46,108,117, + 97, 0, 0, 0, 0, 23, 5, 1, 60,110, 15, 3, 13, 0, 2, 2, 1, 60,111, 15, + 4, 13, 2, 16, 1, 3, 60,112, 0, 0, 0, 0, 3, 0, 0, 0,109, 0, 0, 0, + 5,116,121,112,101, 0, 0, 0, 0,110, 0, 0, 0, 2,109, 0, 0, 0, 0,110, + 0, 0, 0, 2,116, 0, 0, 0, 0, 5, 2, 0, 0, 0, 5,116,121,112,101, 0, + 2, 0, 0, 0, 2,109, 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 12,102, +105,110,100,116,121,112,101,100,101,102, 0, 2, 0, 0, 0, 7, 95, 98, 97,115, +105, 99, 0, 2, 0, 0, 0, 7,105,115,116,121,112,101, 0, 4, 0, 0, 0,115, + 0, 0, 0, 11, 64, 98, 97,115,105, 99, 46,108,117, 97, 0, 0, 0, 0, 30, 3, + 1, 60,116, 15, 1, 13, 0, 16, 46, 5, 15, 2, 13, 0, 16, 46, 7, 15, 3, 13, + 0, 2, 1, 1, 1, 1, 60,117, 0, 0, 0, 0, 1, 0, 0, 0,115, 0, 0, 0, + 2,116, 0, 0, 0, 0, 4, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 7, 95, + 98, 97,115,105, 99, 0, 2, 0, 0, 0, 10, 95,117,115,101,114,116,121,112,101, + 0, 2, 0, 0, 0, 10,105,115,116,121,112,101,100,101,102, 0, 2, 0, 0, 0, + 6,115,112,108,105,116, 0, 4, 0, 0, 0,121, 0, 0, 0, 11, 64, 98, 97,115, +105, 99, 46,108,117, 97, 0, 0, 0, 0,117, 11, 2, 60,122, 22, 1, 11, 3, 7, + 0, 30, 0, 60,123, 13, 2, 58, 5, 1, 60,127, 11, 7, 13, 1, 42, 11, 8, 42, + 60,128, 15, 9, 13, 0, 11, 10, 11, 11, 2, 1, 3, 23, 0, 60,129, 15, 9, 13, + 0, 11, 12, 11, 11, 2, 1, 3, 23, 0, 60,130, 15, 9, 13, 0, 13, 4, 13, 3, + 2, 1, 3, 23, 0, 60,131, 13, 2, 11, 14, 13, 2, 18, 14, 7, 1, 37, 26, 60, +132, 13, 2, 13, 2, 18, 14, 15, 9, 13, 0, 11, 15, 11, 11, 2, 1, 3, 26, 60, +133, 13, 2, 1, 5, 60,134, 0, 0, 0, 0, 5, 0, 0, 0,121, 0, 0, 0, 2, +115, 0, 0, 0, 0,121, 0, 0, 0, 2,116, 0, 0, 0, 0,122, 0, 0, 0, 2, +108, 0, 0, 0, 0,123, 0, 0, 0, 2,102, 0, 0, 0, 0,127, 0, 0, 0, 2, +112, 0, 0, 0, 0, 16, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 2,116, 0, + 2, 0, 0, 0, 2,108, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 2,102, + 0, 4, 0, 0, 0,123, 0, 0, 0, 11, 64, 98, 97,115,105, 99, 46,108,117, 97, + 0, 0, 0, 0, 30, 5, 1, 60,124, 12, 0, 11, 2, 12, 0, 18, 2, 7, 1, 37, + 26, 60,125, 12, 0, 12, 0, 18, 2, 13, 0, 26, 60,126, 0, 0, 0, 0, 1, 0, + 0, 0,123, 0, 0, 0, 2,115, 0, 0, 0, 0, 3, 2, 0, 0, 0, 2,115, 0, + 2, 0, 0, 0, 2,108, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 2,112, + 0, 2, 0, 0, 0, 11, 37,115, 42, 40, 46, 45, 41, 37,115, 42, 0, 2, 0, 0, + 0, 4, 37,115, 42, 0, 2, 0, 0, 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, + 5, 94, 37,115, 43, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 5, 37,115, 43, + 36, 0, 2, 0, 0, 0, 2,108, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, + 9, 40, 37,115, 37,115, 42, 41, 36, 0, 2, 0, 0, 0, 7, 99,111,110, 99, 97, +116, 0, 4, 0, 0, 0,138, 0, 0, 0, 11, 64, 98, 97,115,105, 99, 46,108,117, + 97, 0, 0, 0, 0, 69, 8, 3, 60,139, 11, 4, 60,140, 13, 1, 50, 39, 60,142, + 13, 3, 13, 0, 13, 4, 16, 42, 23, 3, 60,143, 13, 4, 7, 1, 37, 23, 4, 60, +144, 13, 4, 13, 2, 34, 52, 7, 13, 3, 11, 6, 42, 23, 3, 60,145, 60,141, 13, + 4, 13, 2, 34, 54, 48, 60,146, 13, 3, 1, 5, 60,147, 0, 0, 0, 0, 5, 0, + 0, 0,138, 0, 0, 0, 2,116, 0, 0, 0, 0,138, 0, 0, 0, 2,102, 0, 0, + 0, 0,138, 0, 0, 0, 2,108, 0, 0, 0, 0,139, 0, 0, 0, 2,115, 0, 0, + 0, 0,140, 0, 0, 0, 2,105, 0, 0, 0, 0, 7, 2, 0, 0, 0, 2,116, 0, + 2, 0, 0, 0, 2,102, 0, 2, 0, 0, 0, 2,108, 0, 2, 0, 0, 0, 2,115, + 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 2, 32, + 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 4, 0, 0, 0,150, 0, 0, + 0, 11, 64, 98, 97,115,105, 99, 46,108,117, 97, 0, 0, 0, 0,161, 6,128, 60, +151, 7, 1, 50,104, 60,153, 15, 3, 48, 10, 15, 4, 15, 3, 11, 5, 2, 1, 2, + 44, 48, 14, 60,154, 15, 4, 13, 0, 13, 1, 16, 11, 6, 2, 1, 2, 52, 11, 60, +155, 15, 7, 11, 8, 2, 0, 1, 50, 2, 60,156, 60,157, 15, 7, 13, 0, 13, 1, + 16, 2, 0, 1, 60,158, 13, 0, 13, 1, 16, 11, 9, 31, 52, 20, 60,159, 15, 10, + 13, 0, 13, 1, 16, 9, 1, 9, 1, 2, 1, 3, 25, 3, 50, 2, 60,160, 60,161, + 13, 1, 7, 1, 37, 23, 1, 60,162, 60,152, 13, 1, 13, 0, 18, 2, 34, 54,115, + 60,163, 15, 4, 13, 0, 13, 0, 18, 2, 16, 11, 11, 2, 1, 2, 52, 15, 60,164, + 4, 0, 25, 3, 15, 7, 11, 12, 2, 0, 1, 50, 2, 60,165, 60,166, 0, 0, 0, + 0, 2, 0, 0, 0,150, 0, 0, 0, 4, 97,114,103, 0, 0, 0, 0,151, 0, 0, + 0, 2,105, 0, 0, 0, 0, 13, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 4, + 97,114,103, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 6, 95, 99,111,110, +116, 0, 2, 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, 0, 0, 0, 7, + 91, 37, 40, 44, 34, 93, 0, 2, 0, 0, 0, 8, 94, 91, 37, 97, 95,126, 93, 0, + 2, 0, 0, 0, 6,119,114,105,116,101, 0, 2, 0, 0, 0, 2, 32, 0, 2, 0, + 0, 0, 1, 0, 2, 0, 0, 0, 7,115,116,114,115,117, 98, 0, 2, 0, 0, 0, + 14, 91, 37, 47, 37, 41, 37, 59, 37,123, 37,125, 93, 36, 0, 2, 0, 0, 0, 2, + 10, 0, +}; + +/* feature.lo */ +static char B2[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 13, 64,102,101, 97,116,117, +114,101, 46,108,117, 97, 0, 0, 0, 0, 83, 3, 0, 60, 16, 22, 0, 60, 17, 25, + 0, 60, 20, 15, 0, 11, 1, 11, 2, 26, 60, 24, 15, 0, 11, 3, 11, 4, 26, 60, + 28, 15, 0, 11, 5, 11, 6, 26, 60, 32, 15, 0, 11, 7, 11, 8, 26, 60, 36, 15, + 0, 11, 9, 11, 10, 26, 60, 40, 15, 0, 11, 11, 11, 12, 26, 60, 49, 15, 0, 11, + 13, 11, 14, 26, 60, 59, 15, 0, 11, 15, 11, 16, 26, 0, 0, 0, 0, 0, 0, 0, + 0, 17, 2, 0, 0, 0, 13, 99,108, 97,115,115, 70,101, 97,116,117,114,101, 0, + 2, 0, 0, 0, 8,115,117,112, 99,111,100,101, 0, 4, 0, 0, 0, 20, 0, 0, + 0, 13, 64,102,101, 97,116,117,114,101, 46,108,117, 97, 0, 0, 0, 0, 5, 1, + 1, 60, 21, 0, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 5,115,101,108,102, + 0, 0, 0, 0, 0, 2, 0, 0, 0, 8,100,101, 99,108,116, 97,103, 0, 4, 0, + 0, 0, 24, 0, 0, 0, 13, 64,102,101, 97,116,117,114,101, 46,108,117, 97, 0, + 0, 0, 0, 5, 1, 1, 60, 25, 0, 0, 0, 0, 1, 0, 0, 0, 24, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 0, 2, 0, 0, 0, 9,114,101,103,105,115, +116,101,114, 0, 4, 0, 0, 0, 28, 0, 0, 0, 13, 64,102,101, 97,116,117,114, +101, 46,108,117, 97, 0, 0, 0, 0, 5, 1, 1, 60, 29, 0, 0, 0, 0, 1, 0, + 0, 0, 28, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 11,117,110,114,101,103,105,115,116,101,114, 0, 4, 0, 0, 0, 32, 0, 0, 0, + 13, 64,102,101, 97,116,117,114,101, 46,108,117, 97, 0, 0, 0, 0, 5, 1, 1, + 60, 33, 0, 0, 0, 0, 1, 0, 0, 0, 32, 0, 0, 0, 5,115,101,108,102, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 9,112,114,101, 97,109, 98,108,101, 0, 4, 0, + 0, 0, 36, 0, 0, 0, 13, 64,102,101, 97,116,117,114,101, 46,108,117, 97, 0, + 0, 0, 0, 5, 1, 1, 60, 37, 0, 0, 0, 0, 1, 0, 0, 0, 36, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 0, 2, 0, 0, 0, 8,105,110, 99,108, 97, +115,115, 0, 4, 0, 0, 0, 40, 0, 0, 0, 13, 64,102,101, 97,116,117,114,101, + 46,108,117, 97, 0, 0, 0, 0, 44, 3, 1, 60, 41, 13, 0, 18, 1, 48, 9, 13, + 0, 18, 1, 18, 2, 11, 3, 32, 52, 12, 60, 42, 13, 0, 18, 1, 18, 4, 1, 1, + 50, 8, 60, 44, 4, 0, 1, 1, 60, 45, 60, 46, 0, 0, 0, 0, 1, 0, 0, 0, + 40, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 5, 2, 0, 0, 0, 5,115, +101,108,102, 0, 2, 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, 0, 0, 0, + 5,116,121,112,101, 0, 2, 0, 0, 0, 6, 99,108, 97,115,115, 0, 2, 0, 0, + 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 9,105,110,109,111,100,117,108,101, + 0, 4, 0, 0, 0, 49, 0, 0, 0, 13, 64,102,101, 97,116,117,114,101, 46,108, +117, 97, 0, 0, 0, 0, 44, 3, 1, 60, 50, 13, 0, 18, 1, 48, 9, 13, 0, 18, + 1, 18, 2, 11, 3, 32, 52, 12, 60, 51, 13, 0, 18, 1, 18, 4, 1, 1, 50, 8, + 60, 53, 4, 0, 1, 1, 60, 54, 60, 55, 0, 0, 0, 0, 1, 0, 0, 0, 49, 0, + 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 5, 2, 0, 0, 0, 5,115,101,108, +102, 0, 2, 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, 0, 0, 0, 5,116, +121,112,101, 0, 2, 0, 0, 0, 7,109,111,100,117,108,101, 0, 2, 0, 0, 0, + 5,110, 97,109,101, 0, 2, 0, 0, 0, 10, 99,102,117,110, 99,110, 97,109,101, + 0, 4, 0, 0, 0, 59, 0, 0, 0, 13, 64,102,101, 97,116,117,114,101, 46,108, +117, 97, 0, 0, 0, 0, 72, 5, 2, 60, 60, 13, 0, 18, 2, 52, 17, 60, 61, 13, + 0, 18, 2, 20, 3, 13, 1, 2, 1, 2, 23, 1, 50, 2, 60, 62, 60, 63, 13, 0, + 18, 4, 52, 16, 60, 64, 13, 1, 11, 5, 42, 13, 0, 18, 4, 42, 1, 2, 50, 16, + 60, 66, 13, 1, 11, 5, 42, 13, 0, 18, 6, 42, 1, 2, 60, 67, 60, 68, 0, 0, + 0, 0, 2, 0, 0, 0, 59, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 59, + 0, 0, 0, 2,110, 0, 0, 0, 0, 7, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, + 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, + 0, 0, 0, 10, 99,102,117,110, 99,110, 97,109,101, 0, 2, 0, 0, 0, 6,108, +110, 97,109,101, 0, 2, 0, 0, 0, 2, 95, 0, 2, 0, 0, 0, 5,110, 97,109, +101, 0, +}; + +/* declaration.lo */ +static char B3[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 17, 64,100,101, 99,108, 97, +114, 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0,193, 17, 0, 60, 24, 22, + 8, 60, 25, 11, 1, 15, 2, 11, 3, 60, 26, 11, 4, 11, 5, 60, 27, 11, 4, 11, + 6, 60, 28, 11, 4, 11, 7, 60, 29, 11, 4, 11, 8, 60, 30, 11, 4, 11, 9, 60, + 31, 11, 4, 11, 10, 60, 32, 11, 4, 30, 7, 60, 33, 25, 0, 60, 34, 15, 11, 15, + 0, 15, 12, 2, 0, 2, 60, 37, 11, 14, 25, 13, 60, 45, 15, 0, 11, 15, 11, 16, + 26, 60, 84, 15, 0, 11, 17, 11, 18, 26, 60,117, 15, 0, 11, 19, 11, 20, 26, 60, +130, 15, 0, 11, 21, 11, 22, 26, 60,136, 15, 0, 11, 23, 11, 24, 26, 60,149, 15, + 0, 11, 25, 11, 26, 26, 60,184, 15, 0, 11, 27, 11, 28, 26, 60,218, 15, 0, 11, + 29, 11, 30, 26, 60,250, 15, 0, 11, 31, 11, 32, 26, 59, 1, 1, 15, 0, 11, 33, + 11, 34, 26, 59, 1, 12, 15, 0, 11, 35, 11, 36, 26, 59, 1, 26, 11, 38, 25, 37, + 59, 1, 42, 11, 40, 25, 39, 0, 0, 0, 0, 0, 0, 0, 0, 41, 2, 0, 0, 0, + 17, 99,108, 97,115,115, 68,101, 99,108, 97,114, 97,116,105,111,110, 0, 2, 0, + 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, 70, +101, 97,116,117,114,101, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, + 1, 0, 2, 0, 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 4,112,116,114, + 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 4,100,105,109, 0, + 2, 0, 0, 0, 4,114,101,116, 0, 2, 0, 0, 0, 4,100,101,102, 0, 2, 0, + 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, + 95,116, 97,103, 0, 2, 0, 0, 0, 15, 99,114,101, 97,116,101, 95,118, 97,114, +110, 97,109,101, 0, 4, 0, 0, 0, 37, 0, 0, 0, 17, 64,100,101, 99,108, 97, +114, 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0, 34, 2, 0, 60, 38, 15, + 0, 44, 52, 4, 7, 0, 25, 0, 60, 39, 15, 0, 7, 1, 37, 25, 0, 60, 40, 11, + 1, 15, 0, 42, 1, 0, 60, 41, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, + 0, 11, 95,118, 97,114,110,117,109, 98,101,114, 0, 2, 0, 0, 0, 11,116,111, +108,117, 97, 95,118, 97,114, 95, 0, 2, 0, 0, 0, 10, 99,104,101, 99,107,110, + 97,109,101, 0, 4, 0, 0, 0, 45, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, + 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 1,140, 12, 1, 60, 47, 15, 0, + 13, 0, 18, 2, 7, 1, 7, 1, 2, 1, 3, 11, 3, 32, 48, 10, 15, 4, 13, 0, + 18, 5, 2, 1, 1, 44, 52, 70, 60, 48, 13, 0, 11, 2, 13, 0, 18, 5, 13, 0, + 18, 2, 42, 26, 60, 49, 15, 7, 13, 0, 18, 8, 11, 9, 2, 1, 2, 60, 50, 13, + 0, 11, 5, 13, 1, 13, 1, 18, 10, 16, 26, 60, 51, 13, 0, 11, 8, 15, 11, 13, + 1, 7, 1, 13, 1, 18, 10, 7, 1, 38, 2, 1, 3, 26, 5, 1, 50, 2, 60, 52, + 60, 54, 15, 7, 13, 0, 18, 2, 11, 13, 2, 1, 2, 60, 55, 13, 1, 18, 10, 7, + 2, 32, 52, 28, 60, 56, 13, 0, 11, 2, 13, 1, 7, 1, 16, 26, 60, 57, 13, 0, + 11, 14, 13, 1, 13, 1, 18, 10, 16, 26, 50, 2, 60, 58, 60, 60, 15, 18, 13, 0, + 18, 2, 11, 19, 2, 3, 2, 60, 61, 13, 2, 52, 34, 60, 62, 13, 0, 11, 2, 15, + 0, 13, 0, 18, 2, 7, 1, 13, 2, 7, 1, 38, 2, 1, 3, 26, 60, 63, 13, 0, + 11, 20, 13, 4, 26, 50, 2, 60, 64, 60, 67, 13, 0, 18, 5, 11, 21, 31, 48, 7, + 13, 0, 18, 5, 11, 22, 31, 48, 7, 13, 0, 18, 2, 11, 21, 32, 52, 14, 60, 68, + 13, 0, 11, 2, 15, 23, 2, 1, 0, 26, 50,135, 60, 69, 13, 0, 18, 24, 11, 25, + 32, 52,122, 60, 70, 13, 0, 18, 5, 11, 21, 32, 48, 7, 13, 0, 18, 2, 11, 21, + 31, 52, 30, 60, 71, 13, 0, 11, 5, 13, 0, 18, 5, 13, 0, 18, 2, 42, 26, 60, + 72, 13, 0, 11, 2, 15, 23, 2, 1, 0, 26, 50, 70, 60, 73, 15, 4, 13, 0, 18, + 2, 2, 1, 1, 52, 55, 60, 74, 13, 0, 18, 5, 11, 21, 32, 52, 11, 13, 0, 11, + 5, 13, 0, 18, 2, 26, 50, 19, 60, 75, 13, 0, 11, 5, 13, 0, 18, 5, 11, 26, + 42, 13, 0, 18, 2, 42, 26, 60, 76, 13, 0, 11, 2, 15, 23, 2, 1, 0, 26, 50, + 2, 60, 77, 50, 2, 60, 78, 60, 80, 0, 0, 0, 0, 7, 0, 0, 0, 45, 0, 0, + 0, 5,115,101,108,102, 0, 0, 0, 0, 49, 0, 0, 0, 2,109, 0, 0, 0, 0, + 51, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 2,116, 0, 0, 0, 0, 60, 0, + 0, 0, 2, 98, 0, 0, 0, 0, 60, 0, 0, 0, 2,101, 0, 0, 0, 0, 60, 0, + 0, 0, 2,100, 0, 0, 0, 0, 27, 2, 0, 0, 0, 7,115,116,114,115,117, 98, + 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, + 0, 2, 0, 0, 0, 2, 91, 0, 2, 0, 0, 0, 7,105,115,116,121,112,101, 0, + 2, 0, 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 2,109, 0, 2, 0, 0, + 0, 6,115,112,108,105,116, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, + 0, 6, 37,115, 37,115, 42, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 7, + 99,111,110, 99, 97,116, 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 2, 61, + 0, 2, 0, 0, 0, 4,100,101,102, 0, 2, 0, 0, 0, 2, 98, 0, 2, 0, 0, + 0, 2,101, 0, 2, 0, 0, 0, 2,100, 0, 2, 0, 0, 0, 8,115,116,114,102, +105,110,100, 0, 2, 0, 0, 0, 9, 37, 91, 40, 46, 45, 41, 37, 93, 0, 2, 0, + 0, 0, 4,100,105,109, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 5,118,111, +105,100, 0, 2, 0, 0, 0, 15, 99,114,101, 97,116,101, 95,118, 97,114,110, 97, +109,101, 0, 2, 0, 0, 0, 5,107,105,110,100, 0, 2, 0, 0, 0, 4,118, 97, +114, 0, 2, 0, 0, 0, 2, 32, 0, 2, 0, 0, 0, 10, 99,104,101, 99,107,116, +121,112,101, 0, 4, 0, 0, 0, 84, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, + 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0,152, 4, 1, 60, 87, 15, 0, + 13, 0, 18, 2, 2, 1, 1, 48, 7, 13, 0, 18, 3, 11, 4, 31, 52, 22, 60, 88, + 13, 0, 11, 5, 13, 0, 18, 3, 26, 60, 89, 13, 0, 11, 3, 4, 0, 26, 50, 2, + 60, 90, 60, 93, 13, 0, 18, 6, 11, 4, 31, 48, 7, 13, 0, 18, 5, 11, 4, 31, + 52, 11, 60, 94, 15, 7, 11, 8, 2, 0, 1, 50, 2, 60, 95, 60, 98, 13, 0, 18, + 2, 11, 4, 31, 52, 13, 60, 99, 15, 9, 13, 0, 18, 2, 2, 0, 1, 50, 2, 60, +100, 60,103, 13, 0, 18, 2, 11, 10, 32, 52, 9, 13, 0, 11, 2, 11, 11, 26, 50, + 22, 60,104, 13, 0, 18, 2, 11, 12, 32, 52, 9, 13, 0, 11, 2, 11, 13, 26, 50, + 2, 60,105, 60,114, 0, 0, 0, 0, 1, 0, 0, 0, 84, 0, 0, 0, 5,115,101, +108,102, 0, 0, 0, 0, 14, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, + 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,116,121,112,101, 0, + 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 4, +114,101,116, 0, 2, 0, 0, 0, 4,100,105,109, 0, 2, 0, 0, 0, 6,101,114, +114,111,114, 0, 2, 0, 0, 0, 53, 35,105,110,118, 97,108,105,100, 32,112, 97, +114, 97,109,101,116,101,114, 58, 32, 99, 97,110,110,111,116, 32,114,101,116,117, +114,110, 32, 97,110, 32, 97,114,114, 97,121, 32,111,102, 32,118, 97,108,117,101, +115, 0, 2, 0, 0, 0, 8,114,101,103,116,121,112,101, 0, 2, 0, 0, 0, 10, + 95,117,115,101,114,100, 97,116, 97, 0, 2, 0, 0, 0, 6,118,111,105,100, 42, + 0, 2, 0, 0, 0, 9, 95, 99,115,116,114,105,110,103, 0, 2, 0, 0, 0, 6, + 99,104, 97,114, 42, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, + 0,117, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, 97,116,105,111,110, 46,108, +117, 97, 0, 0, 0, 0,172, 6, 3, 60,118, 15, 2, 13, 1, 11, 3, 42, 2, 0, + 1, 60,119, 15, 2, 13, 1, 11, 4, 42, 13, 0, 18, 6, 42, 11, 7, 42, 2, 0, + 1, 60,120, 15, 2, 13, 1, 11, 8, 42, 13, 0, 18, 9, 42, 11, 7, 42, 2, 0, + 1, 60,121, 15, 2, 13, 1, 11, 10, 42, 13, 0, 18, 11, 42, 11, 7, 42, 2, 0, + 1, 60,122, 15, 2, 13, 1, 11, 12, 42, 13, 0, 18, 13, 42, 11, 7, 42, 2, 0, + 1, 60,123, 15, 2, 13, 1, 11, 14, 42, 13, 0, 18, 15, 42, 11, 7, 42, 2, 0, + 1, 60,124, 15, 2, 13, 1, 11, 16, 42, 13, 0, 18, 17, 42, 11, 7, 42, 2, 0, + 1, 60,125, 15, 2, 13, 1, 11, 18, 42, 13, 0, 18, 19, 42, 11, 7, 42, 2, 0, + 1, 60,126, 15, 2, 13, 1, 11, 20, 42, 13, 2, 42, 2, 0, 1, 60,127, 0, 0, + 0, 0, 3, 0, 0, 0,117, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0,117, + 0, 0, 0, 6,105,100,101,110,116, 0, 0, 0, 0,117, 0, 0, 0, 6, 99,108, +111,115,101, 0, 0, 0, 0, 21, 2, 0, 0, 0, 6,105,100,101,110,116, 0, 2, + 0, 0, 0, 6, 99,108,111,115,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, + 0, 2, 0, 0, 0, 13, 68,101, 99,108, 97,114, 97,116,105,111,110,123, 0, 2, + 0, 0, 0, 10, 32,109,111,100, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,115, +101,108,102, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 3, 39, 44, + 0, 2, 0, 0, 0, 10, 32,116,121,112,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, + 5,116,121,112,101, 0, 2, 0, 0, 0, 10, 32,112,116,114, 32, 32, 61, 32, 39, + 0, 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 10, 32,110, 97,109,101, + 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 10, + 32,100,105,109, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4,100,105,109, 0, 2, + 0, 0, 0, 10, 32,100,101,102, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4,100, +101,102, 0, 2, 0, 0, 0, 10, 32,114,101,116, 32, 32, 61, 32, 39, 0, 2, 0, + 0, 0, 4,114,101,116, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 8,100, +101, 99,108,116, 97,103, 0, 4, 0, 0, 0,130, 0, 0, 0, 17, 64,100,101, 99, +108, 97,114, 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0, 56, 10, 1, 60, +131, 13, 0, 11, 1, 13, 0, 11, 2, 15, 3, 13, 0, 18, 4, 15, 5, 13, 0, 18, + 6, 11, 7, 2, 1, 2, 2, 2, 2, 27, 1, 27, 2, 5, 4, 60,132, 15, 8, 13, + 0, 18, 1, 13, 0, 18, 2, 2, 0, 2, 60,133, 0, 0, 0, 0, 1, 0, 0, 0, +130, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 9, 2, 0, 0, 0, 5,115, +101,108,102, 0, 2, 0, 0, 0, 6,105,116,121,112,101, 0, 2, 0, 0, 0, 4, +116, 97,103, 0, 2, 0, 0, 0, 7,116, 97,103,118, 97,114, 0, 2, 0, 0, 0, + 5,116,121,112,101, 0, 2, 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, + 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, + 0, 0, 0, 8,100,101, 99,108,116, 97,103, 0, 2, 0, 0, 0, 13,111,117,116, + 99,104,101, 99,107,116,121,112,101, 0, 4, 0, 0, 0,136, 0, 0, 0, 17, 64, +100,101, 99,108, 97,114, 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0, 83, + 6, 2, 60,137, 4, 1, 60,138, 13, 0, 18, 4, 11, 5, 31, 52, 14, 60,139, 11, + 6, 23, 2, 60,140, 7, 0, 23, 3, 50, 25, 60,142, 13, 0, 18, 1, 23, 2, 60, +143, 13, 0, 18, 2, 11, 5, 31, 46, 2, 7, 0, 23, 3, 60,144, 60,145, 11, 7, + 13, 1, 42, 11, 8, 42, 13, 2, 42, 11, 8, 42, 13, 3, 42, 11, 9, 42, 1, 4, + 60,146, 0, 0, 0, 0, 4, 0, 0, 0,136, 0, 0, 0, 5,115,101,108,102, 0, + 0, 0, 0,136, 0, 0, 0, 5,110, 97,114,103, 0, 0, 0, 0,137, 0, 0, 0, + 4,116, 97,103, 0, 0, 0, 0,137, 0, 0, 0, 4,100,101,102, 0, 0, 0, 0, + 10, 2, 0, 0, 0, 5,110, 97,114,103, 0, 2, 0, 0, 0, 4,116, 97,103, 0, + 2, 0, 0, 0, 4,100,101,102, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, + 0, 0, 0, 4,100,105,109, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 16,116, +111,108,117, 97, 95,116, 97,103, 95,116, 97, 98,108,101, 0, 2, 0, 0, 0, 14, +116,111,108,117, 97, 95,105,115,116,121,112,101, 40, 0, 2, 0, 0, 0, 2, 44, + 0, 2, 0, 0, 0, 2, 41, 0, 2, 0, 0, 0, 8,100,101, 99,108, 97,114,101, + 0, 4, 0, 0, 0,149, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, 97,116,105, +111,110, 46,108,117, 97, 0, 0, 0, 1, 84, 15, 2, 60,150, 11, 2, 60,151, 13, + 0, 18, 1, 11, 2, 31, 52, 4, 11, 4, 23, 2, 60,152, 15, 5, 11, 6, 13, 0, + 18, 7, 13, 0, 18, 8, 13, 2, 2, 0, 4, 60,153, 13, 0, 18, 9, 11, 2, 31, + 48, 12, 15, 10, 13, 0, 18, 9, 2, 1, 1, 4, 0, 32, 52, 11, 60,154, 15, 5, + 11, 4, 2, 0, 1, 50, 2, 60,155, 60,156, 15, 5, 13, 0, 18, 11, 2, 0, 1, + 60,157, 13, 0, 18, 9, 11, 2, 31, 52, 76, 60,158, 15, 10, 13, 0, 18, 9, 2, + 1, 1, 4, 0, 31, 52, 17, 60,159, 15, 5, 11, 12, 13, 0, 18, 9, 11, 13, 2, + 0, 3, 50, 41, 60,161, 15, 5, 11, 14, 13, 0, 18, 7, 13, 0, 18, 8, 13, 2, + 11, 15, 60,162, 11, 16, 13, 0, 18, 9, 11, 17, 13, 0, 18, 8, 13, 2, 11, 18, + 2, 0, 11, 60,163, 50,161, 60,165, 15, 20, 13, 0, 18, 8, 2, 1, 1, 60,166, + 15, 5, 11, 21, 2, 0, 1, 60,167, 13, 3, 44, 48, 5, 13, 2, 11, 2, 32, 52, + 7, 15, 5, 11, 4, 2, 0, 1, 60,168, 15, 5, 11, 22, 13, 0, 18, 7, 13, 0, + 18, 8, 2, 0, 3, 60,169, 13, 3, 44, 52, 11, 60,170, 15, 5, 11, 4, 2, 0, + 1, 50, 2, 60,171, 60,172, 15, 5, 11, 23, 2, 0, 1, 60,173, 7, 0, 60,174, + 13, 0, 18, 24, 11, 2, 31, 52, 6, 13, 0, 18, 24, 23, 4, 60,175, 13, 3, 52, + 24, 60,176, 15, 5, 11, 25, 13, 3, 42, 11, 26, 13, 1, 11, 27, 13, 4, 11, 18, + 2, 0, 6, 50, 19, 60,178, 15, 5, 11, 28, 13, 1, 11, 27, 13, 4, 11, 18, 2, + 0, 5, 60,179, 5, 2, 60,180, 60,181, 0, 0, 0, 0, 7, 0, 0, 0,149, 0, + 0, 0, 5,115,101,108,102, 0, 0, 0, 0,149, 0, 0, 0, 5,110, 97,114,103, + 0, 0, 0, 0,150, 0, 0, 0, 4,112,116,114, 0, 0, 0, 0,165, 0, 0, 0, + 2,116, 0, 0, 0, 0,173, 0, 0, 0, 4,100,101,102, 0, 0, 0, 0,179, 0, + 0, 0, 0, 0, 0, 0,179, 0, 0, 0, 0, 0, 0, 0, 29, 2, 0, 0, 0, 5, +110, 97,114,103, 0, 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 1, 0, + 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 2, 42, 0, 2, 0, 0, + 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 2, 32, 0, 2, 0, 0, 0, + 4,109,111,100, 0, 2, 0, 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 4, +100,105,109, 0, 2, 0, 0, 0, 9,116,111,110,117,109, 98,101,114, 0, 2, 0, + 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 2, 91, 0, 2, 0, 0, 0, 3, + 93, 59, 0, 2, 0, 0, 0, 5, 32, 61, 32, 40, 0, 2, 0, 0, 0, 3, 42, 41, + 0, 2, 0, 0, 0, 8,109, 97,108,108,111, 99, 40, 0, 2, 0, 0, 0, 9, 42, +115,105,122,101,111,102, 40, 0, 2, 0, 0, 0, 4, 41, 41, 59, 0, 2, 0, 0, + 0, 2,116, 0, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, + 0, 4, 32, 61, 32, 0, 2, 0, 0, 0, 3, 40, 40, 0, 2, 0, 0, 0, 3, 41, + 32, 0, 2, 0, 0, 0, 4,100,101,102, 0, 2, 0, 0, 0, 10,116,111,108,117, + 97, 95,103,101,116, 0, 2, 0, 0, 0, 2, 40, 0, 2, 0, 0, 0, 2, 44, 0, + 2, 0, 0, 0, 19,116,111,108,117, 97, 95,103,101,116,117,115,101,114,116,121, +112,101, 40, 0, 2, 0, 0, 0, 9,103,101,116, 97,114,114, 97,121, 0, 4, 0, + 0, 0,184, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, 97,116,105,111,110, 46, +108,117, 97, 0, 0, 0, 1, 78, 13, 2, 60,185, 13, 0, 18, 2, 11, 3, 31, 51, + 1, 59, 60,186, 15, 4, 11, 5, 2, 0, 1, 60,187, 13, 0, 18, 6, 11, 3, 31, + 46, 2, 7, 0, 60,188, 15, 4, 11, 7, 13, 1, 11, 8, 13, 0, 18, 9, 11, 8, + 13, 0, 18, 2, 11, 8, 13, 2, 11, 10, 2, 0, 9, 60,189, 15, 4, 11, 11, 2, + 0, 1, 60,190, 15, 4, 11, 12, 2, 0, 1, 60,191, 15, 4, 11, 13, 2, 0, 1, + 60,192, 15, 4, 11, 14, 2, 0, 1, 60,193, 15, 4, 11, 15, 13, 1, 11, 16, 2, + 0, 3, 60,194, 15, 4, 11, 17, 13, 0, 18, 2, 42, 11, 18, 42, 2, 0, 1, 60, +195, 15, 20, 13, 0, 18, 21, 2, 1, 1, 60,196, 11, 3, 60,197, 13, 0, 18, 22, + 11, 3, 31, 52, 4, 11, 23, 23, 4, 60,198, 15, 4, 11, 24, 13, 0, 18, 25, 11, + 26, 42, 2, 0, 2, 60,199, 13, 3, 44, 48, 5, 13, 4, 11, 3, 32, 52, 7, 15, + 4, 11, 23, 2, 0, 1, 60,200, 15, 4, 11, 27, 13, 0, 18, 28, 13, 0, 18, 21, + 2, 0, 3, 60,201, 13, 3, 44, 52, 11, 60,202, 15, 4, 11, 23, 2, 0, 1, 50, + 2, 60,203, 60,204, 15, 4, 11, 29, 2, 0, 1, 60,205, 7, 0, 60,206, 13, 0, + 18, 6, 11, 3, 31, 52, 6, 13, 0, 18, 6, 23, 5, 60,207, 13, 3, 52, 21, 60, +208, 15, 4, 11, 30, 13, 3, 42, 11, 31, 42, 13, 5, 11, 32, 2, 0, 3, 50, 15, + 60,210, 15, 4, 11, 33, 13, 5, 11, 32, 2, 0, 3, 60,211, 60,212, 15, 4, 11, + 34, 2, 0, 1, 60,213, 15, 4, 11, 35, 2, 0, 1, 5, 4, 50, 2, 60,214, 60, +215, 0, 0, 0, 0, 10, 0, 0, 0,184, 0, 0, 0, 5,115,101,108,102, 0, 0, + 0, 0,184, 0, 0, 0, 5,110, 97,114,103, 0, 0, 0, 0,187, 0, 0, 0, 4, +100,101,102, 0, 0, 0, 0,195, 0, 0, 0, 2,116, 0, 0, 0, 0,196, 0, 0, + 0, 4,112,116,114, 0, 0, 0, 0,205, 0, 0, 0, 4,100,101,102, 0, 0, 0, + 0,213, 0, 0, 0, 0, 0, 0, 0,213, 0, 0, 0, 0, 0, 0, 0,213, 0, 0, + 0, 0, 0, 0, 0,213, 0, 0, 0, 0, 0, 0, 0, 36, 2, 0, 0, 0, 5,110, + 97,114,103, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 4,100, +105,109, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, + 0, 2, 0, 0, 0, 4, 32, 32,123, 0, 2, 0, 0, 0, 4,100,101,102, 0, 2, + 0, 0, 0, 27, 32, 32, 32,105,102, 32, 40, 33,116,111,108,117, 97, 95, 97,114, +114, 97,121,105,115,116,121,112,101, 40, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, + 0, 0, 4,116, 97,103, 0, 2, 0, 0, 0, 3, 41, 41, 0, 2, 0, 0, 0, 16, + 32, 32, 32, 32,103,111,116,111, 32,101,114,114,111,114, 59, 0, 2, 0, 0, 0, + 9, 32, 32, 32,101,108,115,101, 10, 0, 2, 0, 0, 0, 5, 32, 32, 32,123, 0, + 2, 0, 0, 0, 11, 32, 32, 32, 32,105,110,116, 32,105, 59, 0, 2, 0, 0, 0, + 34, 32, 32, 32, 32,108,117, 97, 95, 79, 98,106,101, 99,116, 32,108,111, 32, 61, + 32,108,117, 97, 95,103,101,116,112, 97,114, 97,109, 40, 0, 2, 0, 0, 0, 3, + 41, 59, 0, 2, 0, 0, 0, 16, 32, 32, 32, 32,102,111,114, 40,105, 61, 48, 59, + 32,105, 60, 0, 2, 0, 0, 0, 6, 59,105, 43, 43, 41, 0, 2, 0, 0, 0, 2, +116, 0, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, 0, 5, +116,121,112,101, 0, 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 2, 42, + 0, 2, 0, 0, 0, 4, 32, 32, 32, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, + 2, 0, 0, 0, 7, 91,105, 93, 32, 61, 32, 0, 2, 0, 0, 0, 3, 40, 40, 0, + 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 3, 41, 32, 0, 2, 0, 0, + 0, 15,116,111,108,117, 97, 95,103,101,116,102,105,101,108,100, 0, 2, 0, 0, + 0, 9, 40,108,111, 44,105, 43, 49, 44, 0, 2, 0, 0, 0, 4, 41, 41, 59, 0, + 2, 0, 0, 0, 31,116,111,108,117, 97, 95,103,101,116,102,105,101,108,100,117, +115,101,114,116,121,112,101, 40,108,111, 44,105, 43, 49, 44, 0, 2, 0, 0, 0, + 5, 32, 32, 32,125, 0, 2, 0, 0, 0, 4, 32, 32,125, 0, 2, 0, 0, 0, 9, +115,101,116, 97,114,114, 97,121, 0, 4, 0, 0, 0,218, 0, 0, 0, 17, 64,100, +101, 99,108, 97,114, 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 1, 42, 9, + 2, 60,219, 13, 0, 18, 2, 11, 3, 31, 51, 1, 23, 60,220, 15, 4, 11, 5, 2, + 0, 1, 60,221, 15, 4, 11, 6, 2, 0, 1, 60,222, 15, 4, 11, 7, 13, 1, 11, + 8, 2, 0, 3, 60,223, 15, 4, 11, 9, 13, 0, 18, 2, 42, 11, 10, 42, 2, 0, + 1, 60,224, 15, 12, 13, 0, 18, 13, 2, 1, 1, 60,225, 13, 2, 11, 14, 32, 52, + 23, 60,226, 15, 4, 11, 15, 13, 2, 42, 11, 16, 42, 13, 0, 18, 17, 11, 18, 2, + 0, 3, 50,175, 60,227, 13, 2, 52, 23, 60,228, 15, 4, 11, 15, 13, 2, 42, 11, + 19, 42, 13, 0, 18, 17, 11, 18, 2, 0, 3, 50,146, 60,230, 13, 0, 18, 20, 11, + 3, 32, 52,110, 60,231, 15, 4, 11, 21, 2, 0, 1, 60,232, 15, 4, 11, 22, 2, + 0, 1, 60,233, 15, 4, 11, 23, 13, 0, 18, 13, 11, 24, 13, 0, 18, 17, 11, 18, + 2, 0, 5, 60,234, 15, 4, 11, 25, 2, 0, 1, 60,235, 15, 4, 11, 26, 13, 0, + 18, 17, 11, 27, 13, 0, 18, 13, 11, 28, 2, 0, 5, 60,236, 15, 4, 11, 29, 2, + 0, 1, 60,237, 15, 4, 11, 30, 13, 0, 18, 31, 11, 32, 13, 0, 18, 31, 11, 8, + 2, 0, 5, 60,238, 15, 4, 11, 33, 2, 0, 1, 50, 23, 60,242, 15, 4, 11, 34, + 13, 0, 18, 17, 11, 35, 13, 0, 18, 31, 11, 8, 2, 0, 5, 60,243, 60,244, 60, +245, 15, 4, 11, 36, 2, 0, 1, 5, 1, 50, 2, 60,246, 60,247, 0, 0, 0, 0, + 4, 0, 0, 0,218, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0,218, 0, 0, + 0, 5,110, 97,114,103, 0, 0, 0, 0,224, 0, 0, 0, 2,116, 0, 0, 0, 0, +245, 0, 0, 0, 0, 0, 0, 0, 37, 2, 0, 0, 0, 5,110, 97,114,103, 0, 2, + 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 4,100,105,109, 0, 2, 0, + 0, 0, 1, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, + 4, 32, 32,123, 0, 2, 0, 0, 0, 10, 32, 32, 32,105,110,116, 32,105, 59, 0, + 2, 0, 0, 0, 33, 32, 32, 32,108,117, 97, 95, 79, 98,106,101, 99,116, 32,108, +111, 32, 61, 32,108,117, 97, 95,103,101,116,112, 97,114, 97,109, 40, 0, 2, 0, + 0, 0, 3, 41, 59, 0, 2, 0, 0, 0, 15, 32, 32, 32,102,111,114, 40,105, 61, + 48, 59, 32,105, 60, 0, 2, 0, 0, 0, 6, 59,105, 43, 43, 41, 0, 2, 0, 0, + 0, 2,116, 0, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, + 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 7,110,117,109, 98,101,114, 0, 2, + 0, 0, 0, 19, 32, 32, 32,116,111,108,117, 97, 95,112,117,115,104,102,105,101, +108,100, 0, 2, 0, 0, 0, 17, 40,108,111, 44,105, 43, 49, 44, 40,100,111,117, + 98,108,101, 41, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 6, + 91,105, 93, 41, 59, 0, 2, 0, 0, 0, 9, 40,108,111, 44,105, 43, 49, 44, 0, + 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 5, 32, 32, 32,123, 0, 2, + 0, 0, 0, 20, 35,105,102,100,101,102, 32, 95, 95, 99,112,108,117,115,112,108, +117,115, 10, 0, 2, 0, 0, 0, 29, 32, 32, 32, 32,118,111,105,100, 42, 32,116, +111,108,117, 97, 73, 95, 99,108,111,110,101, 32, 61, 32,110,101,119, 0, 2, 0, + 0, 0, 2, 40, 0, 2, 0, 0, 0, 7, 35,101,108,115,101, 10, 0, 2, 0, 0, + 0, 45, 32, 32, 32, 32,118,111,105,100, 42, 32,116,111,108,117, 97, 73, 95, 99, +108,111,110,101, 32, 61, 32,116,111,108,117, 97, 95, 99,111,112,121, 40, 40,118, +111,105,100, 42, 41, 38, 0, 2, 0, 0, 0, 12, 91,105, 93, 44,115,105,122,101, +111,102, 40, 0, 2, 0, 0, 0, 4, 41, 41, 59, 0, 2, 0, 0, 0, 8, 35,101, +110,100,105,102, 10, 0, 2, 0, 0, 0, 63, 32, 32, 32, 32,116,111,108,117, 97, + 95,112,117,115,104,102,105,101,108,100,117,115,101,114,116,121,112,101, 40,108, +111, 44,105, 43, 49, 44,116,111,108,117, 97, 95,100,111, 99,108,111,110,101, 40, +116,111,108,117, 97, 73, 95, 99,108,111,110,101, 44, 0, 2, 0, 0, 0, 4,116, + 97,103, 0, 2, 0, 0, 0, 3, 41, 44, 0, 2, 0, 0, 0, 5, 32, 32, 32,125, + 0, 2, 0, 0, 0, 42, 32, 32, 32,116,111,108,117, 97, 95,112,117,115,104,102, +105,101,108,100,117,115,101,114,116,121,112,101, 40,108,111, 44,105, 43, 49, 44, + 40,118,111,105,100, 42, 41, 0, 2, 0, 0, 0, 5, 91,105, 93, 44, 0, 2, 0, + 0, 0, 4, 32, 32,125, 0, 2, 0, 0, 0, 10,102,114,101,101, 97,114,114, 97, +121, 0, 4, 0, 0, 0,250, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, 97,116, +105,111,110, 46,108,117, 97, 0, 0, 0, 0, 49, 5, 1, 60,251, 13, 0, 18, 1, + 11, 2, 31, 48, 12, 15, 3, 13, 0, 18, 1, 2, 1, 1, 4, 0, 32, 52, 17, 60, +252, 15, 4, 11, 5, 13, 0, 18, 6, 11, 7, 2, 0, 3, 50, 2, 60,253, 60,254, + 0, 0, 0, 0, 1, 0, 0, 0,250, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, + 0, 8, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 4,100,105,109, + 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 9,116,111,110,117,109, 98,101,114, + 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 8, 32, 32, +102,114,101,101, 40, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, + 3, 41, 59, 0, 2, 0, 0, 0, 8,112, 97,115,115,112, 97,114, 0, 4, 0, 0, + 1, 1, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, 97,116,105,111,110, 46,108, +117, 97, 0, 0, 0, 0, 79, 4, 1, 59, 1, 2, 13, 0, 18, 1, 11, 2, 32, 52, + 17, 59, 1, 3, 15, 3, 11, 4, 13, 0, 18, 5, 42, 2, 0, 1, 50, 44, 59, 1, + 4, 13, 0, 18, 6, 11, 4, 32, 52, 17, 59, 1, 5, 15, 3, 11, 2, 13, 0, 18, + 5, 42, 2, 0, 1, 50, 15, 59, 1, 7, 15, 3, 13, 0, 18, 5, 2, 0, 1, 59, + 1, 8, 59, 1, 9, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 5,115,101, +108,102, 0, 0, 0, 0, 7, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, + 0, 4,112,116,114, 0, 2, 0, 0, 0, 2, 38, 0, 2, 0, 0, 0, 7,111,117, +116,112,117,116, 0, 2, 0, 0, 0, 2, 42, 0, 2, 0, 0, 0, 5,110, 97,109, +101, 0, 2, 0, 0, 0, 4,114,101,116, 0, 2, 0, 0, 0, 9,114,101,116,118, + 97,108,117,101, 0, 4, 0, 0, 1, 12, 0, 0, 0, 17, 64,100,101, 99,108, 97, +114, 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0,133, 6, 1, 59, 1, 13, + 13, 0, 18, 1, 11, 2, 31, 52,112, 59, 1, 14, 15, 4, 13, 0, 18, 5, 2, 1, + 1, 59, 1, 15, 13, 1, 11, 6, 32, 52, 26, 59, 1, 16, 15, 7, 11, 8, 13, 1, + 42, 11, 9, 42, 13, 0, 18, 10, 42, 11, 11, 42, 2, 0, 1, 50, 60, 59, 1, 17, + 13, 1, 52, 26, 59, 1, 18, 15, 7, 11, 8, 13, 1, 42, 11, 12, 42, 13, 0, 18, + 10, 42, 11, 11, 42, 2, 0, 1, 50, 27, 59, 1, 20, 15, 7, 11, 13, 13, 0, 18, + 10, 42, 11, 14, 42, 13, 0, 18, 15, 11, 11, 2, 0, 3, 59, 1, 21, 5, 1, 50, + 3, 59, 1, 22, 59, 1, 23, 0, 0, 0, 0, 3, 0, 0, 1, 12, 0, 0, 0, 5, +115,101,108,102, 0, 0, 0, 1, 14, 0, 0, 0, 2,116, 0, 0, 0, 1, 21, 0, + 0, 0, 0, 0, 0, 0, 16, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, + 0, 4,114,101,116, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 2,116, 0, 2, + 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, 0, 5,116,121,112, +101, 0, 2, 0, 0, 0, 7,110,117,109, 98,101,114, 0, 2, 0, 0, 0, 7,111, +117,116,112,117,116, 0, 2, 0, 0, 0, 14, 32, 32, 32,116,111,108,117, 97, 95, +112,117,115,104, 0, 2, 0, 0, 0, 10, 40, 40,100,111,117, 98,108,101, 41, 0, + 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 3, 41, 59, 0, 2, 0, + 0, 0, 2, 40, 0, 2, 0, 0, 0, 30, 32, 32, 32,116,111,108,117, 97, 95,112, +117,115,104,117,115,101,114,116,121,112,101, 40, 40,118,111,105,100, 42, 41, 0, + 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 4,116, 97,103, 0, 2, 0, 0, 0, + 13, 95, 68,101, 99,108, 97,114, 97,116,105,111,110, 0, 4, 0, 0, 1, 26, 0, + 0, 0, 17, 64,100,101, 99,108, 97,114, 97,116,105,111,110, 46,108,117, 97, 0, + 0, 0, 0,136, 8, 1, 59, 1, 27, 13, 0, 18, 1, 48, 7, 13, 0, 18, 1, 11, + 2, 31, 52, 60, 59, 1, 28, 15, 4, 13, 0, 18, 1, 11, 5, 2, 1, 2, 59, 1, + 29, 13, 0, 11, 1, 13, 1, 7, 1, 16, 26, 59, 1, 30, 13, 0, 11, 6, 15, 7, + 13, 1, 7, 2, 16, 46, 5, 13, 1, 7, 1, 16, 11, 8, 11, 2, 2, 1, 3, 26, + 5, 1, 50, 3, 59, 1, 31, 59, 1, 32, 13, 0, 11, 9, 15, 10, 26, 59, 1, 33, + 15, 11, 13, 0, 15, 12, 2, 0, 2, 59, 1, 34, 13, 0, 20, 13, 2, 0, 1, 59, + 1, 35, 13, 0, 20, 14, 2, 0, 1, 59, 1, 36, 13, 0, 1, 1, 59, 1, 37, 0, + 0, 0, 0, 3, 0, 0, 1, 26, 0, 0, 0, 2,116, 0, 0, 0, 1, 28, 0, 0, + 0, 2,110, 0, 0, 0, 1, 30, 0, 0, 0, 0, 0, 0, 0, 15, 2, 0, 0, 0, + 2,116, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 1, 0, 2, + 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 6,115,112,108,105,116, 0, 2, 0, 0, + 0, 2, 64, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 5, +103,115,117, 98, 0, 2, 0, 0, 0, 7, 37, 91, 46, 45, 37, 93, 0, 2, 0, 0, + 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 17, 99,108, 97,115,115, 68,101, + 99,108, 97,114, 97,116,105,111,110, 0, 2, 0, 0, 0, 7,115,101,116,116, 97, +103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, + 0, 10, 99,104,101, 99,107,110, 97,109,101, 0, 2, 0, 0, 0, 10, 99,104,101, + 99,107,116,121,112,101, 0, 2, 0, 0, 0, 12, 68,101, 99,108, 97,114, 97,116, +105,111,110, 0, 4, 0, 0, 1, 42, 0, 0, 0, 17, 64,100,101, 99,108, 97,114, + 97,116,105,111,110, 46,108,117, 97, 0, 0, 0, 3,164, 20, 2, 59, 1, 44, 15, + 2, 13, 0, 11, 3, 11, 4, 2, 1, 3, 23, 0, 59, 1, 46, 13, 1, 11, 5, 32, + 52, 44, 59, 1, 48, 13, 0, 11, 6, 32, 46, 5, 13, 0, 11, 7, 32, 52, 22, 59, + 1, 49, 15, 8, 22, 2, 11, 9, 11, 7, 11, 1, 13, 1, 30, 1, 3, 2, 1, 50, + 3, 59, 1, 50, 50, 3, 59, 1, 51, 59, 1, 54, 15, 11, 13, 0, 11, 12, 2, 1, + 2, 59, 1, 55, 13, 2, 18, 13, 7, 2, 32, 52,126, 59, 1, 56, 13, 1, 11, 14, + 32, 52, 15, 59, 1, 57, 15, 15, 11, 16, 13, 0, 42, 2, 0, 1, 50, 3, 59, 1, + 58, 59, 1, 59, 15, 11, 13, 2, 7, 1, 16, 11, 18, 2, 1, 2, 59, 1, 60, 15, + 8, 22, 6, 59, 1, 61, 11, 19, 13, 2, 7, 2, 16, 11, 20, 59, 1, 62, 11, 21, + 11, 22, 59, 1, 63, 11, 23, 11, 9, 59, 1, 64, 13, 3, 13, 3, 18, 13, 16, 11, + 24, 59, 1, 65, 15, 25, 13, 3, 7, 1, 13, 3, 18, 13, 7, 1, 38, 2, 1, 3, + 11, 1, 59, 1, 66, 13, 1, 30, 5, 59, 1, 67, 3, 4, 1, 5, 1, 50, 3, 59, + 1, 68, 59, 1, 71, 15, 11, 13, 0, 11, 26, 2, 1, 2, 23, 2, 59, 1, 72, 13, + 2, 18, 13, 7, 2, 32, 52,126, 59, 1, 73, 13, 1, 11, 14, 32, 52, 15, 59, 1, + 74, 15, 15, 11, 16, 13, 0, 42, 2, 0, 1, 50, 3, 59, 1, 75, 59, 1, 76, 15, + 11, 13, 2, 7, 1, 16, 11, 18, 2, 1, 2, 59, 1, 77, 15, 8, 22, 6, 59, 1, + 78, 11, 19, 13, 2, 7, 2, 16, 11, 20, 59, 1, 79, 11, 21, 11, 22, 59, 1, 80, + 11, 21, 11, 9, 59, 1, 81, 13, 3, 13, 3, 18, 13, 16, 11, 24, 59, 1, 82, 15, + 25, 13, 3, 7, 1, 13, 3, 18, 13, 7, 1, 38, 2, 1, 3, 11, 1, 59, 1, 83, + 13, 1, 30, 5, 59, 1, 84, 3, 4, 1, 5, 1, 50, 3, 59, 1, 85, 59, 1, 88, + 15, 11, 13, 0, 11, 23, 2, 1, 2, 23, 2, 59, 1, 89, 13, 2, 18, 13, 7, 2, + 32, 52, 91, 59, 1, 90, 15, 11, 13, 2, 7, 1, 16, 11, 18, 2, 1, 2, 59, 1, + 91, 15, 8, 22, 5, 59, 1, 92, 11, 19, 13, 2, 7, 2, 16, 11, 20, 59, 1, 93, + 11, 23, 11, 9, 59, 1, 94, 13, 3, 13, 3, 18, 13, 16, 11, 24, 59, 1, 95, 15, + 25, 13, 3, 7, 1, 13, 3, 18, 13, 7, 1, 38, 2, 1, 3, 11, 1, 59, 1, 96, + 13, 1, 30, 4, 59, 1, 97, 3, 4, 1, 5, 1, 50, 3, 59, 1, 98, 59, 1,101, + 15, 2, 13, 0, 11, 28, 11, 29, 2, 1, 3, 59, 1,102, 15, 11, 13, 3, 11, 30, + 2, 1, 2, 23, 2, 59, 1,103, 13, 2, 18, 31, 7, 2, 32, 52,113, 59, 1,104, + 13, 2, 7, 2, 15, 32, 13, 2, 7, 2, 16, 11, 33, 11, 30, 2, 1, 3, 26, 59, + 1,105, 15, 11, 13, 2, 7, 1, 16, 11, 18, 2, 1, 2, 59, 1,106, 15, 8, 22, + 5, 59, 1,107, 11, 19, 13, 2, 7, 2, 16, 11, 20, 59, 1,108, 11, 21, 11, 9, + 59, 1,109, 13, 4, 13, 4, 18, 31, 16, 11, 24, 59, 1,110, 15, 25, 13, 4, 7, + 1, 13, 4, 18, 31, 7, 1, 38, 2, 1, 3, 11, 1, 59, 1,111, 13, 1, 30, 4, + 59, 1,112, 3, 5, 1, 5, 1, 50, 3, 59, 1,113, 59, 1,115, 13, 1, 11, 5, + 32, 52,129, 59, 1,117, 15, 11, 13, 0, 11, 18, 2, 1, 2, 23, 2, 59, 1,118, + 4, 0, 59, 1,119, 15, 35, 13, 2, 13, 2, 18, 31, 16, 2, 1, 1, 52, 6, 11, + 6, 23, 4, 50, 21, 13, 2, 13, 2, 18, 31, 16, 23, 4, 13, 2, 11, 31, 13, 2, + 18, 31, 7, 1, 38, 26, 59, 1,120, 15, 8, 22, 4, 59, 1,121, 11, 19, 13, 4, + 11, 9, 59, 1,122, 13, 2, 13, 2, 18, 31, 16, 11, 24, 59, 1,123, 15, 25, 13, + 2, 7, 1, 13, 2, 18, 31, 7, 1, 38, 2, 1, 3, 11, 1, 59, 1,124, 13, 1, + 30, 3, 59, 1,125, 3, 5, 1, 5, 1, 50,130, 59, 1,130, 15, 11, 13, 0, 11, + 18, 2, 1, 2, 23, 2, 59, 1,131, 13, 2, 13, 2, 18, 31, 16, 59, 1,132, 4, + 1, 59, 1,133, 13, 2, 18, 31, 7, 1, 35, 52, 38, 59, 1,134, 13, 2, 13, 2, + 18, 31, 7, 1, 38, 16, 23, 5, 59, 1,135, 15, 25, 13, 2, 7, 1, 13, 2, 18, + 31, 7, 2, 38, 2, 1, 3, 23, 6, 50, 3, 59, 1,136, 59, 1,137, 15, 8, 22, + 4, 59, 1,138, 11, 19, 13, 4, 11, 9, 59, 1,139, 13, 5, 11, 24, 59, 1,140, + 13, 6, 11, 1, 59, 1,141, 13, 1, 30, 3, 59, 1,142, 3, 7, 1, 5, 3, 59, + 1,143, 59, 1,145, 0, 0, 0, 0, 20, 0, 0, 1, 42, 0, 0, 0, 2,115, 0, + 0, 0, 1, 42, 0, 0, 0, 5,107,105,110,100, 0, 0, 0, 1, 54, 0, 0, 0, + 2,116, 0, 0, 0, 1, 59, 0, 0, 0, 2,109, 0, 0, 0, 1, 67, 0, 0, 0, + 0, 0, 0, 1, 76, 0, 0, 0, 2,109, 0, 0, 0, 1, 84, 0, 0, 0, 0, 0, + 0, 1, 90, 0, 0, 0, 2,109, 0, 0, 0, 1, 97, 0, 0, 0, 0, 0, 0, 1, +101, 0, 0, 0, 3,115, 49, 0, 0, 0, 1,105, 0, 0, 0, 2,109, 0, 0, 0, + 1,112, 0, 0, 0, 0, 0, 0, 1,118, 0, 0, 0, 2,118, 0, 0, 0, 1,125, + 0, 0, 0, 0, 0, 0, 1,131, 0, 0, 0, 2,118, 0, 0, 0, 1,132, 0, 0, + 0, 3,116,112, 0, 0, 0, 1,132, 0, 0, 0, 3,109,100, 0, 0, 0, 1,142, + 0, 0, 0, 0, 0, 0, 1,142, 0, 0, 0, 0, 0, 0, 1,142, 0, 0, 0, 0, + 0, 0, 0, 38, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 5,107,105,110,100, + 0, 2, 0, 0, 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, 8, 37,115, 42, 61, + 37,115, 42, 0, 2, 0, 0, 0, 2, 61, 0, 2, 0, 0, 0, 4,118, 97,114, 0, + 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 5,118,111,105,100, 0, 2, 0, 0, 0, + 13, 95, 68,101, 99,108, 97,114, 97,116,105,111,110, 0, 2, 0, 0, 0, 5,116, +121,112,101, 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6,115,112,108,105, +116, 0, 2, 0, 0, 0, 7, 37, 42, 37,115, 42, 38, 0, 2, 0, 0, 0, 2,110, + 0, 2, 0, 0, 0, 5,102,117,110, 99, 0, 2, 0, 0, 0, 6,101,114,114,111, +114, 0, 2, 0, 0, 0, 32, 35,105,110,118, 97,108,105,100, 32,102,117,110, 99, +116,105,111,110, 32,114,101,116,117,114,110, 32,116,121,112,101, 58, 32, 0, 2, + 0, 0, 0, 2,109, 0, 2, 0, 0, 0, 6, 37,115, 37,115, 42, 0, 2, 0, 0, + 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, + 2, 42, 0, 2, 0, 0, 0, 4,114,101,116, 0, 2, 0, 0, 0, 2, 38, 0, 2, + 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 7, 99,111,110, 99, 97,116, 0, + 2, 0, 0, 0, 8, 37, 42, 37,115, 42, 37, 42, 0, 2, 0, 0, 0, 3,115, 49, + 0, 2, 0, 0, 0, 7, 40, 37, 98, 91, 93, 41, 0, 4, 0, 0, 1,101, 0, 0, + 0, 17, 64,100,101, 99,108, 97,114, 97,116,105,111,110, 46,108,117, 97, 0, 0, + 0, 0, 17, 5, 1, 59, 1,101, 15, 1, 13, 0, 11, 2, 11, 3, 3, 1, 3, 0, + 0, 0, 0, 1, 0, 0, 1,101, 0, 0, 0, 2,110, 0, 0, 0, 0, 4, 2, 0, + 0, 0, 2,110, 0, 2, 0, 0, 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, 3, + 37, 42, 0, 2, 0, 0, 0, 2, 1, 0, 2, 0, 0, 0, 3, 37, 42, 0, 2, 0, + 0, 0, 2,110, 0, 2, 0, 0, 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, 2, + 1, 0, 2, 0, 0, 0, 2,118, 0, 2, 0, 0, 0, 7,105,115,116,121,112,101, + 0, 2, 0, 0, 0, 3,116,112, 0, 2, 0, 0, 0, 3,109,100, 0, +}; + +/* container.lo */ +static char B4[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 15, 64, 99,111,110,116, 97, +105,110,101,114, 46,108,117, 97, 0, 0, 0, 0,162, 5, 0, 60, 17, 60, 18, 22, + 2, 60, 19, 11, 1, 4, 0, 11, 2, 60, 20, 15, 3, 30, 1, 60, 21, 25, 0, 60, + 22, 15, 4, 15, 0, 15, 5, 2, 0, 2, 60, 25, 15, 0, 11, 6, 11, 7, 26, 60, + 36, 15, 0, 11, 8, 11, 9, 26, 60, 48, 11, 11, 25, 10, 60, 58, 11, 13, 25, 12, + 60, 63, 11, 15, 25, 14, 60, 68, 11, 17, 25, 16, 60, 73, 11, 19, 25, 18, 60, 78, + 11, 21, 25, 20, 60, 83, 11, 23, 25, 22, 60, 88, 15, 24, 11, 25, 11, 26, 26, 60, + 95, 15, 24, 11, 27, 11, 28, 26, 60,101, 15, 24, 11, 29, 11, 30, 26, 60,110, 15, + 24, 11, 31, 11, 32, 26, 60,129, 15, 24, 11, 33, 11, 34, 26, 60,147, 15, 24, 11, + 35, 11, 36, 26, 59, 1, 49, 15, 24, 11, 37, 11, 38, 26, 0, 0, 0, 0, 0, 0, + 0, 0, 39, 2, 0, 0, 0, 15, 99,108, 97,115,115, 67,111,110,116, 97,105,110, +101,114, 0, 2, 0, 0, 0, 5, 99,117,114,114, 0, 2, 0, 0, 0, 6, 95, 98, + 97,115,101, 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, 70,101, 97,116,117,114, +101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116, +111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 8,100,101, 99,108,116, 97, +103, 0, 4, 0, 0, 0, 25, 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110,101, +114, 46,108,117, 97, 0, 0, 0, 0, 59, 4, 1, 60, 26, 15, 0, 13, 0, 2, 0, + 1, 60, 27, 7, 1, 50, 23, 60, 29, 13, 0, 13, 1, 16, 20, 3, 2, 0, 1, 60, + 30, 13, 1, 7, 1, 37, 23, 1, 60, 31, 60, 28, 13, 0, 13, 1, 16, 54, 32, 60, + 32, 15, 4, 2, 0, 0, 60, 33, 0, 0, 0, 0, 2, 0, 0, 0, 25, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 27, 0, 0, 0, 2,105, 0, 0, 0, 0, 5, + 2, 0, 0, 0, 5,112,117,115,104, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, + 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 8,100,101, 99,108,116, 97,103, 0, + 2, 0, 0, 0, 4,112,111,112, 0, 2, 0, 0, 0, 8,115,117,112, 99,111,100, +101, 0, 4, 0, 0, 0, 36, 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110,101, +114, 46,108,117, 97, 0, 0, 0, 0, 59, 4, 1, 60, 37, 15, 0, 13, 0, 2, 0, + 1, 60, 38, 7, 1, 50, 23, 60, 40, 13, 0, 13, 1, 16, 20, 3, 2, 0, 1, 60, + 41, 13, 1, 7, 1, 37, 23, 1, 60, 42, 60, 39, 13, 0, 13, 1, 16, 54, 32, 60, + 43, 15, 4, 2, 0, 0, 60, 44, 0, 0, 0, 0, 2, 0, 0, 0, 36, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 38, 0, 0, 0, 2,105, 0, 0, 0, 0, 5, + 2, 0, 0, 0, 5,112,117,115,104, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, + 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 8,115,117,112, 99,111,100,101, 0, + 2, 0, 0, 0, 4,112,111,112, 0, 2, 0, 0, 0, 11, 95, 67,111,110,116, 97, +105,110,101,114, 0, 4, 0, 0, 0, 48, 0, 0, 0, 15, 64, 99,111,110,116, 97, +105,110,101,114, 46,108,117, 97, 0, 0, 0, 0, 64, 6, 1, 60, 49, 13, 0, 11, + 1, 15, 2, 26, 60, 50, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60, 51, 13, 0, 11, + 5, 7, 0, 26, 60, 52, 13, 0, 11, 6, 22, 1, 11, 5, 7, 0, 30, 0, 26, 60, + 53, 13, 0, 11, 7, 22, 0, 26, 60, 54, 13, 0, 1, 1, 60, 55, 0, 0, 0, 0, + 1, 0, 0, 0, 48, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 8, 2, 0, + 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, + 0, 0, 0, 15, 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, 0, 2, + 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, + 97, 95,116, 97,103, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 9,116,121, +112,101,100,101,102,115, 0, 2, 0, 0, 0, 7,108,110, 97,109,101,115, 0, 2, + 0, 0, 0, 5,112,117,115,104, 0, 4, 0, 0, 0, 58, 0, 0, 0, 15, 64, 99, +111,110,116, 97,105,110,101,114, 46,108,117, 97, 0, 0, 0, 0, 14, 4, 1, 60, + 59, 15, 1, 11, 2, 13, 0, 26, 60, 60, 0, 0, 0, 0, 1, 0, 0, 0, 58, 0, + 0, 0, 2,116, 0, 0, 0, 0, 3, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, + 15, 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, + 5, 99,117,114,114, 0, 2, 0, 0, 0, 4,112,111,112, 0, 4, 0, 0, 0, 63, + 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110,101,114, 46,108,117, 97, 0, 0, + 0, 0, 18, 3, 0, 60, 64, 15, 0, 11, 1, 15, 0, 18, 1, 18, 2, 26, 60, 65, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 15, 99,108, 97,115,115, 67, +111,110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, 5, 99,117,114,114, 0, 2, + 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, 0, 0, 0, 7, 97,112,112,101, +110,100, 0, 4, 0, 0, 0, 68, 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110, +101,114, 46,108,117, 97, 0, 0, 0, 0, 18, 4, 1, 60, 69, 15, 1, 18, 2, 20, + 3, 13, 0, 3, 1, 2, 60, 70, 0, 0, 0, 0, 1, 0, 0, 0, 68, 0, 0, 0, + 2,116, 0, 0, 0, 0, 4, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 15, 99, +108, 97,115,115, 67,111,110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, 5, 99, +117,114,114, 0, 2, 0, 0, 0, 7, 97,112,112,101,110,100, 0, 2, 0, 0, 0, + 14, 97,112,112,101,110,100,116,121,112,101,100,101,102, 0, 4, 0, 0, 0, 73, + 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110,101,114, 46,108,117, 97, 0, 0, + 0, 0, 18, 4, 1, 60, 74, 15, 1, 18, 2, 20, 3, 13, 0, 3, 1, 2, 60, 75, + 0, 0, 0, 0, 1, 0, 0, 0, 73, 0, 0, 0, 2,116, 0, 0, 0, 0, 4, 2, + 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 15, 99,108, 97,115,115, 67,111,110,116, + 97,105,110,101,114, 0, 2, 0, 0, 0, 5, 99,117,114,114, 0, 2, 0, 0, 0, + 14, 97,112,112,101,110,100,116,121,112,101,100,101,102, 0, 2, 0, 0, 0, 12, +102,105,110,100,116,121,112,101,100,101,102, 0, 4, 0, 0, 0, 78, 0, 0, 0, + 15, 64, 99,111,110,116, 97,105,110,101,114, 46,108,117, 97, 0, 0, 0, 0, 18, + 4, 1, 60, 79, 15, 1, 18, 2, 20, 3, 13, 0, 3, 1, 2, 60, 80, 0, 0, 0, + 0, 1, 0, 0, 0, 78, 0, 0, 0, 5,116,121,112,101, 0, 0, 0, 0, 4, 2, + 0, 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 15, 99,108, 97,115,115, 67, +111,110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, 5, 99,117,114,114, 0, 2, + 0, 0, 0, 12,102,105,110,100,116,121,112,101,100,101,102, 0, 2, 0, 0, 0, + 10,105,115,116,121,112,101,100,101,102, 0, 4, 0, 0, 0, 83, 0, 0, 0, 15, + 64, 99,111,110,116, 97,105,110,101,114, 46,108,117, 97, 0, 0, 0, 0, 18, 4, + 1, 60, 84, 15, 1, 18, 2, 20, 3, 13, 0, 3, 1, 2, 60, 85, 0, 0, 0, 0, + 1, 0, 0, 0, 83, 0, 0, 0, 5,116,121,112,101, 0, 0, 0, 0, 4, 2, 0, + 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 15, 99,108, 97,115,115, 67,111, +110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, 5, 99,117,114,114, 0, 2, 0, + 0, 0, 10,105,115,116,121,112,101,100,101,102, 0, 2, 0, 0, 0, 15, 99,108, + 97,115,115, 67,111,110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, 7, 97,112, +112,101,110,100, 0, 4, 0, 0, 0, 88, 0, 0, 0, 15, 64, 99,111,110,116, 97, +105,110,101,114, 46,108,117, 97, 0, 0, 0, 0, 39, 6, 2, 60, 89, 13, 0, 11, + 2, 13, 0, 18, 2, 7, 1, 37, 26, 60, 90, 13, 0, 13, 0, 18, 2, 13, 1, 26, + 60, 91, 13, 1, 11, 3, 13, 0, 26, 60, 92, 0, 0, 0, 0, 2, 0, 0, 0, 88, + 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 88, 0, 0, 0, 2,116, 0, 0, + 0, 0, 4, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, + 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, + 0, 0, 0, 14, 97,112,112,101,110,100,116,121,112,101,100,101,102, 0, 4, 0, + 0, 0, 95, 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110,101,114, 46,108,117, + 97, 0, 0, 0, 0, 38, 6, 2, 60, 96, 13, 0, 18, 2, 11, 3, 13, 0, 18, 2, + 18, 3, 7, 1, 37, 26, 60, 97, 13, 0, 18, 2, 13, 0, 18, 2, 18, 3, 13, 1, + 26, 60, 98, 0, 0, 0, 0, 2, 0, 0, 0, 95, 0, 0, 0, 5,115,101,108,102, + 0, 0, 0, 0, 95, 0, 0, 0, 2,116, 0, 0, 0, 0, 4, 2, 0, 0, 0, 2, +116, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 9,116,121,112, +101,100,101,102,115, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 9,111,118, +101,114,108,111, 97,100, 0, 4, 0, 0, 0,101, 0, 0, 0, 15, 64, 99,111,110, +116, 97,105,110,101,114, 46,108,117, 97, 0, 0, 0, 0, 67, 6, 2, 60,102, 13, + 0, 18, 2, 13, 1, 16, 44, 52, 13, 60,103, 13, 0, 18, 2, 13, 1, 7, 0, 26, + 50, 21, 60,105, 13, 0, 18, 2, 13, 1, 13, 0, 18, 2, 13, 1, 16, 7, 1, 37, + 26, 60,106, 60,107, 15, 3, 11, 4, 13, 0, 18, 2, 13, 1, 16, 3, 2, 2, 60, +108, 0, 0, 0, 0, 2, 0, 0, 0,101, 0, 0, 0, 5,115,101,108,102, 0, 0, + 0, 0,101, 0, 0, 0, 6,108,110, 97,109,101, 0, 0, 0, 0, 5, 2, 0, 0, + 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, + 0, 0, 7,108,110, 97,109,101,115, 0, 2, 0, 0, 0, 7,102,111,114,109, 97, +116, 0, 2, 0, 0, 0, 5, 37, 48, 50,100, 0, 2, 0, 0, 0, 12,102,105,110, +100,116,121,112,101,100,101,102, 0, 4, 0, 0, 0,110, 0, 0, 0, 15, 64, 99, +111,110,116, 97,105,110,101,114, 46,108,117, 97, 0, 0, 0, 0,142, 10, 2, 60, +111, 13, 0, 50,117, 60,113, 13, 2, 18, 3, 52, 97, 60,114, 7, 1, 50, 76, 60, +116, 13, 2, 18, 3, 13, 3, 16, 18, 5, 13, 1, 32, 52, 47, 60,117, 13, 2, 18, + 3, 13, 3, 16, 18, 8, 13, 2, 18, 3, 13, 3, 16, 18, 0, 60,118, 15, 11, 13, + 5, 2, 2, 1, 60,119, 13, 6, 11, 12, 42, 13, 4, 42, 13, 7, 1, 8, 5, 4, + 50, 2, 60,120, 60,121, 13, 3, 7, 1, 37, 23, 3, 60,122, 60,115, 13, 2, 18, + 3, 13, 3, 16, 54, 87, 5, 1, 50, 2, 60,123, 60,124, 13, 2, 18, 13, 23, 2, + 60,125, 60,112, 13, 2, 54,123, 60,126, 11, 14, 13, 1, 1, 3, 60,127, 0, 0, + 0, 0, 13, 0, 0, 0,110, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0,110, + 0, 0, 0, 5,116,121,112,101, 0, 0, 0, 0,111, 0, 0, 0, 4,101,110,118, + 0, 0, 0, 0,114, 0, 0, 0, 2,105, 0, 0, 0, 0,117, 0, 0, 0, 5,109, +111,100, 49, 0, 0, 0, 0,117, 0, 0, 0, 6,116,121,112,101, 49, 0, 0, 0, + 0,118, 0, 0, 0, 5,109,111,100, 50, 0, 0, 0, 0,118, 0, 0, 0, 6,116, +121,112,101, 50, 0, 0, 0, 0,119, 0, 0, 0, 0, 0, 0, 0,119, 0, 0, 0, + 0, 0, 0, 0,119, 0, 0, 0, 0, 0, 0, 0,119, 0, 0, 0, 0, 0, 0, 0, +122, 0, 0, 0, 0, 0, 0, 0, 15, 2, 0, 0, 0, 5,116,121,112,101, 0, 2, + 0, 0, 0, 4,101,110,118, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, + 0, 0, 9,116,121,112,101,100,101,102,115, 0, 2, 0, 0, 0, 2,105, 0, 2, + 0, 0, 0, 6,117,116,121,112,101, 0, 2, 0, 0, 0, 5,109,111,100, 49, 0, + 2, 0, 0, 0, 6,116,121,112,101, 49, 0, 2, 0, 0, 0, 4,109,111,100, 0, + 2, 0, 0, 0, 5,109,111,100, 50, 0, 2, 0, 0, 0, 6,116,121,112,101, 50, + 0, 2, 0, 0, 0, 12,102,105,110,100,116,121,112,101,100,101,102, 0, 2, 0, + 0, 0, 2, 32, 0, 2, 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, 0, 0, + 0, 1, 0, 2, 0, 0, 0, 10,105,115,116,121,112,101,100,101,102, 0, 4, 0, + 0, 0,129, 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110,101,114, 46,108,117, + 97, 0, 0, 0, 0,101, 6, 2, 60,130, 13, 0, 50, 78, 60,132, 13, 2, 18, 3, + 52, 58, 60,133, 7, 1, 50, 37, 60,135, 13, 2, 18, 3, 13, 3, 16, 18, 5, 13, + 1, 32, 52, 8, 60,136, 7, 1, 1, 4, 50, 2, 60,137, 60,138, 13, 3, 7, 1, + 37, 23, 3, 60,139, 60,134, 13, 2, 18, 3, 13, 3, 16, 54, 48, 5, 1, 50, 2, + 60,140, 60,141, 13, 2, 18, 6, 23, 2, 60,142, 60,131, 13, 2, 54, 84, 60,143, + 4, 0, 1, 3, 60,144, 0, 0, 0, 0, 5, 0, 0, 0,129, 0, 0, 0, 5,115, +101,108,102, 0, 0, 0, 0,129, 0, 0, 0, 5,116,121,112,101, 0, 0, 0, 0, +130, 0, 0, 0, 4,101,110,118, 0, 0, 0, 0,133, 0, 0, 0, 2,105, 0, 0, + 0, 0,139, 0, 0, 0, 0, 0, 0, 0, 7, 2, 0, 0, 0, 5,116,121,112,101, + 0, 2, 0, 0, 0, 4,101,110,118, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, + 2, 0, 0, 0, 9,116,121,112,101,100,101,102,115, 0, 2, 0, 0, 0, 2,105, + 0, 2, 0, 0, 0, 6,117,116,121,112,101, 0, 2, 0, 0, 0, 7,112, 97,114, +101,110,116, 0, 2, 0, 0, 0, 8,100,111,112, 97,114,115,101, 0, 4, 0, 0, + 0,147, 0, 0, 0, 15, 64, 99,111,110,116, 97,105,110,101,114, 46,108,117, 97, + 0, 0, 0, 4, 55, 13, 2, 60,151, 15, 5, 13, 1, 11, 6, 2, 4, 2, 60,152, + 13, 2, 52, 42, 60,153, 15, 8, 13, 1, 13, 2, 13, 3, 2, 1, 3, 25, 7, 60, +154, 15, 9, 13, 4, 13, 5, 2, 0, 2, 60,155, 15, 8, 13, 1, 13, 3, 7, 1, + 37, 3, 6, 2, 50, 2, 60,156, 5, 4, 60,157, 60,161, 15, 5, 13, 1, 11, 10, + 2, 3, 2, 60,162, 13, 2, 52, 40, 60,163, 15, 8, 13, 1, 13, 2, 13, 3, 2, + 1, 3, 25, 7, 60,164, 15, 11, 13, 4, 2, 0, 1, 60,165, 15, 8, 13, 1, 13, + 3, 7, 1, 37, 3, 5, 2, 50, 2, 60,166, 5, 3, 60,167, 60,171, 15, 5, 13, + 1, 11, 12, 2, 3, 2, 60,172, 13, 2, 52, 40, 60,173, 15, 8, 13, 1, 13, 2, + 13, 3, 2, 1, 3, 25, 7, 60,174, 15, 13, 13, 4, 2, 0, 1, 60,175, 15, 8, + 13, 1, 13, 3, 7, 1, 37, 3, 5, 2, 50, 2, 60,176, 5, 3, 60,177, 60,180, + 15, 5, 13, 1, 11, 14, 2, 4, 2, 60,181, 13, 2, 52, 52, 60,182, 15, 8, 13, + 1, 13, 2, 13, 3, 2, 1, 3, 25, 7, 60,183, 15, 13, 13, 4, 2, 0, 1, 60, +184, 15, 15, 11, 16, 13, 5, 42, 2, 0, 1, 60,185, 15, 8, 13, 1, 13, 3, 7, + 1, 37, 3, 6, 2, 50, 2, 60,186, 5, 4, 60,187, 60,191, 15, 5, 13, 1, 11, + 21, 2, 6, 2, 60,192, 13, 2, 52, 46, 60,193, 15, 8, 13, 1, 13, 2, 13, 3, + 2, 1, 3, 25, 7, 60,194, 15, 22, 13, 4, 13, 5, 13, 6, 13, 7, 2, 0, 4, + 60,195, 15, 8, 13, 1, 13, 3, 7, 1, 37, 3, 8, 2, 50, 2, 60,196, 5, 6, + 60,197, 60,201, 15, 5, 13, 1, 11, 23, 2, 5, 2, 60,202, 13, 2, 44, 52, 23, + 60,204, 15, 5, 13, 1, 11, 24, 2, 5, 2, 23, 6, 23, 5, 23, 4, 23, 3, 23, + 2, 50, 2, 60,205, 60,206, 13, 2, 52, 44, 60,207, 15, 8, 13, 1, 13, 2, 13, + 3, 2, 1, 3, 25, 7, 60,208, 15, 25, 13, 4, 13, 5, 13, 6, 2, 0, 3, 60, +209, 15, 8, 13, 1, 13, 3, 7, 1, 37, 3, 7, 2, 50, 2, 60,210, 5, 5, 60, +211, 60,215, 15, 5, 13, 1, 11, 26, 2, 5, 2, 60,216, 13, 2, 44, 52, 23, 60, +218, 15, 5, 13, 1, 11, 27, 2, 5, 2, 23, 6, 23, 5, 23, 4, 23, 3, 23, 2, + 50, 2, 60,219, 60,220, 13, 2, 52, 44, 60,221, 15, 8, 13, 1, 13, 2, 13, 3, + 2, 1, 3, 25, 7, 60,222, 15, 25, 13, 4, 13, 5, 13, 6, 2, 0, 3, 60,223, + 15, 8, 13, 1, 13, 3, 7, 1, 37, 3, 7, 2, 50, 2, 60,224, 5, 5, 60,225, + 60,229, 15, 5, 13, 1, 11, 29, 2, 5, 2, 60,230, 13, 2, 44, 52, 59, 60,231, + 15, 5, 13, 1, 11, 30, 2, 5, 2, 23, 6, 23, 5, 23, 4, 23, 3, 23, 2, 60, +232, 13, 2, 44, 52, 27, 60,233, 11, 31, 23, 5, 60,234, 15, 5, 13, 1, 11, 32, + 2, 4, 2, 23, 4, 23, 6, 23, 3, 23, 2, 50, 2, 60,235, 50, 2, 60,236, 60, +237, 13, 2, 52, 80, 60,238, 13, 5, 11, 31, 31, 52, 25, 60,239, 4, 1, 60,240, + 15, 5, 13, 5, 11, 33, 2, 3, 2, 23, 5, 23, 8, 23, 7, 5, 2, 50, 2, 60, +241, 60,242, 15, 8, 13, 1, 13, 2, 13, 3, 2, 1, 3, 25, 7, 60,243, 15, 34, + 13, 4, 13, 5, 13, 6, 2, 0, 3, 60,244, 15, 8, 13, 1, 13, 3, 7, 1, 37, + 3, 7, 2, 50, 2, 60,245, 5, 5, 60,246, 60,250, 15, 5, 13, 1, 11, 36, 2, + 3, 2, 60,251, 13, 2, 52, 40, 60,252, 15, 8, 13, 1, 13, 2, 13, 3, 2, 1, + 3, 25, 7, 60,253, 15, 15, 13, 4, 2, 0, 1, 60,254, 15, 8, 13, 1, 13, 3, + 7, 1, 37, 3, 5, 2, 50, 2, 60,255, 5, 3, 59, 1, 0, 59, 1, 4, 15, 5, + 13, 1, 11, 37, 2, 3, 2, 59, 1, 5, 13, 2, 52, 43, 59, 1, 6, 15, 8, 13, + 1, 13, 2, 13, 3, 2, 1, 3, 25, 7, 59, 1, 7, 15, 38, 13, 4, 2, 0, 1, + 59, 1, 8, 15, 8, 13, 1, 13, 3, 7, 1, 37, 3, 5, 2, 50, 3, 59, 1, 9, + 5, 3, 59, 1, 10, 59, 1, 14, 15, 5, 13, 1, 11, 39, 2, 3, 2, 59, 1, 15, + 13, 2, 52, 43, 59, 1, 16, 15, 8, 13, 1, 13, 2, 13, 3, 2, 1, 3, 25, 7, + 59, 1, 17, 15, 40, 13, 4, 2, 0, 1, 59, 1, 18, 15, 8, 13, 1, 13, 3, 7, + 1, 37, 3, 5, 2, 50, 3, 59, 1, 19, 5, 3, 59, 1, 20, 59, 1, 24, 15, 5, + 13, 1, 11, 42, 2, 3, 2, 59, 1, 25, 13, 2, 52, 36, 59, 1, 26, 15, 43, 15, + 8, 13, 4, 7, 2, 9, 2, 2, 1, 3, 2, 0, 1, 59, 1, 27, 15, 8, 13, 1, + 13, 3, 7, 1, 37, 3, 5, 2, 50, 3, 59, 1, 28, 5, 3, 59, 1, 29, 59, 1, + 33, 15, 5, 13, 1, 11, 45, 2, 3, 2, 59, 1, 34, 13, 2, 52, 27, 59, 1, 35, + 15, 46, 13, 4, 2, 0, 1, 59, 1, 36, 15, 8, 13, 1, 13, 3, 7, 1, 37, 3, + 5, 2, 50, 3, 59, 1, 37, 5, 3, 59, 1, 38, 59, 1, 41, 15, 47, 13, 1, 11, + 48, 11, 31, 2, 1, 3, 11, 31, 31, 52, 19, 59, 1, 42, 13, 1, 25, 7, 59, 1, + 43, 15, 49, 11, 50, 2, 0, 1, 50, 10, 59, 1, 45, 11, 31, 1, 2, 59, 1, 46, + 59, 1, 47, 0, 0, 0, 0,106, 0, 0, 0,147, 0, 0, 0, 5,115,101,108,102, + 0, 0, 0, 0,147, 0, 0, 0, 2,115, 0, 0, 0, 0,151, 0, 0, 0, 2, 98, + 0, 0, 0, 0,151, 0, 0, 0, 2,101, 0, 0, 0, 0,151, 0, 0, 0, 5,110, + 97,109,101, 0, 0, 0, 0,151, 0, 0, 0, 5, 98,111,100,121, 0, 0, 0, 0, +156, 0, 0, 0, 0, 0, 0, 0,156, 0, 0, 0, 0, 0, 0, 0,156, 0, 0, 0, + 0, 0, 0, 0,156, 0, 0, 0, 0, 0, 0, 0,161, 0, 0, 0, 2, 98, 0, 0, + 0, 0,161, 0, 0, 0, 2,101, 0, 0, 0, 0,161, 0, 0, 0, 5,110, 97,109, +101, 0, 0, 0, 0,166, 0, 0, 0, 0, 0, 0, 0,166, 0, 0, 0, 0, 0, 0, + 0,166, 0, 0, 0, 0, 0, 0, 0,171, 0, 0, 0, 2, 98, 0, 0, 0, 0,171, + 0, 0, 0, 2,101, 0, 0, 0, 0,171, 0, 0, 0, 5, 98,111,100,121, 0, 0, + 0, 0,176, 0, 0, 0, 0, 0, 0, 0,176, 0, 0, 0, 0, 0, 0, 0,176, 0, + 0, 0, 0, 0, 0, 0,180, 0, 0, 0, 2, 98, 0, 0, 0, 0,180, 0, 0, 0, + 2,101, 0, 0, 0, 0,180, 0, 0, 0, 5, 98,111,100,121, 0, 0, 0, 0,180, + 0, 0, 0, 5,110, 97,109,101, 0, 0, 0, 0,186, 0, 0, 0, 0, 0, 0, 0, +186, 0, 0, 0, 0, 0, 0, 0,186, 0, 0, 0, 0, 0, 0, 0,186, 0, 0, 0, + 0, 0, 0, 0,191, 0, 0, 0, 2, 98, 0, 0, 0, 0,191, 0, 0, 0, 2,101, + 0, 0, 0, 0,191, 0, 0, 0, 5,100,101, 99,108, 0, 0, 0, 0,191, 0, 0, + 0, 5,107,105,110,100, 0, 0, 0, 0,191, 0, 0, 0, 4, 97,114,103, 0, 0, + 0, 0,191, 0, 0, 0, 6, 99,111,110,115,116, 0, 0, 0, 0,196, 0, 0, 0, + 0, 0, 0, 0,196, 0, 0, 0, 0, 0, 0, 0,196, 0, 0, 0, 0, 0, 0, 0, +196, 0, 0, 0, 0, 0, 0, 0,196, 0, 0, 0, 0, 0, 0, 0,196, 0, 0, 0, + 0, 0, 0, 0,201, 0, 0, 0, 2, 98, 0, 0, 0, 0,201, 0, 0, 0, 2,101, + 0, 0, 0, 0,201, 0, 0, 0, 5,100,101, 99,108, 0, 0, 0, 0,201, 0, 0, + 0, 4, 97,114,103, 0, 0, 0, 0,201, 0, 0, 0, 6, 99,111,110,115,116, 0, + 0, 0, 0,210, 0, 0, 0, 0, 0, 0, 0,210, 0, 0, 0, 0, 0, 0, 0,210, + 0, 0, 0, 0, 0, 0, 0,210, 0, 0, 0, 0, 0, 0, 0,210, 0, 0, 0, 0, + 0, 0, 0,215, 0, 0, 0, 2, 98, 0, 0, 0, 0,215, 0, 0, 0, 2,101, 0, + 0, 0, 0,215, 0, 0, 0, 5,100,101, 99,108, 0, 0, 0, 0,215, 0, 0, 0, + 4, 97,114,103, 0, 0, 0, 0,215, 0, 0, 0, 6, 99,111,110,115,116, 0, 0, + 0, 0,224, 0, 0, 0, 0, 0, 0, 0,224, 0, 0, 0, 0, 0, 0, 0,224, 0, + 0, 0, 0, 0, 0, 0,224, 0, 0, 0, 0, 0, 0, 0,224, 0, 0, 0, 0, 0, + 0, 0,229, 0, 0, 0, 2, 98, 0, 0, 0, 0,229, 0, 0, 0, 2,101, 0, 0, + 0, 0,229, 0, 0, 0, 5,110, 97,109,101, 0, 0, 0, 0,229, 0, 0, 0, 5, + 98, 97,115,101, 0, 0, 0, 0,229, 0, 0, 0, 5, 98,111,100,121, 0, 0, 0, + 0,239, 0, 0, 0, 2, 98, 0, 0, 0, 0,239, 0, 0, 0, 2,101, 0, 0, 0, + 0,240, 0, 0, 0, 0, 0, 0, 0,240, 0, 0, 0, 0, 0, 0, 0,245, 0, 0, + 0, 0, 0, 0, 0,245, 0, 0, 0, 0, 0, 0, 0,245, 0, 0, 0, 0, 0, 0, + 0,245, 0, 0, 0, 0, 0, 0, 0,245, 0, 0, 0, 0, 0, 0, 0,250, 0, 0, + 0, 2, 98, 0, 0, 0, 0,250, 0, 0, 0, 2,101, 0, 0, 0, 0,250, 0, 0, + 0, 6,116,121,112,101,115, 0, 0, 0, 0,255, 0, 0, 0, 0, 0, 0, 0,255, + 0, 0, 0, 0, 0, 0, 0,255, 0, 0, 0, 0, 0, 0, 1, 4, 0, 0, 0, 2, + 98, 0, 0, 0, 1, 4, 0, 0, 0, 2,101, 0, 0, 0, 1, 4, 0, 0, 0, 5, +100,101, 99,108, 0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 1, 9, 0, 0, 0, + 0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 1, 14, 0, 0, 0, 2, 98, 0, 0, + 0, 1, 14, 0, 0, 0, 2,101, 0, 0, 0, 1, 14, 0, 0, 0, 5,100,101, 99, +108, 0, 0, 0, 1, 19, 0, 0, 0, 0, 0, 0, 1, 19, 0, 0, 0, 0, 0, 0, + 1, 19, 0, 0, 0, 0, 0, 0, 1, 24, 0, 0, 0, 2, 98, 0, 0, 0, 1, 24, + 0, 0, 0, 2,101, 0, 0, 0, 1, 24, 0, 0, 0, 5, 99,111,100,101, 0, 0, + 0, 1, 28, 0, 0, 0, 0, 0, 0, 1, 28, 0, 0, 0, 0, 0, 0, 1, 28, 0, + 0, 0, 0, 0, 0, 1, 33, 0, 0, 0, 2, 98, 0, 0, 0, 1, 33, 0, 0, 0, + 2,101, 0, 0, 0, 1, 33, 0, 0, 0, 5,108,105,110,101, 0, 0, 0, 1, 37, + 0, 0, 0, 0, 0, 0, 1, 37, 0, 0, 0, 0, 0, 0, 1, 37, 0, 0, 0, 0, + 0, 0, 0, 51, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 2, 98, 0, 2, 0, + 0, 0, 2,101, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 5, + 98,111,100,121, 0, 2, 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, 0, + 0, 0, 41, 94, 37,115, 42,109,111,100,117,108,101, 37,115, 37,115, 42, 40, 91, + 95, 37,119, 93, 91, 95, 37,119, 93, 42, 41, 37,115, 42, 40, 37, 98,123,125, 41, + 37,115, 42, 0, 2, 0, 0, 0, 11, 95, 99,117,114,114, 95, 99,111,100,101, 0, + 2, 0, 0, 0, 7,115,116,114,115,117, 98, 0, 2, 0, 0, 0, 7, 77,111,100, +117,108,101, 0, 2, 0, 0, 0, 34, 94, 37,115, 42, 35,100,101,102,105,110,101, + 37,115, 37,115, 42, 40, 91, 94, 37,115, 93, 42, 41, 91, 94, 10, 93, 42, 10, 37, +115, 42, 0, 2, 0, 0, 0, 7, 68,101,102,105,110,101, 0, 2, 0, 0, 0, 28, + 94, 37,115, 42,101,110,117,109, 91, 94,123, 93, 42, 40, 37, 98,123,125, 41, 37, +115, 42, 59, 63, 37,115, 42, 0, 2, 0, 0, 0, 10, 69,110,117,109,101,114, 97, +116,101, 0, 2, 0, 0, 0, 55, 94, 37,115, 42,116,121,112,101,100,101,102, 37, +115, 37,115, 42,101,110,117,109, 91, 94,123, 93, 42, 40, 37, 98,123,125, 41, 37, +115, 42, 40, 91, 37,119, 95, 93, 91, 94, 37,115, 93, 42, 41, 37,115, 42, 59, 37, +115, 42, 0, 2, 0, 0, 0, 8, 84,121,112,101,100,101,102, 0, 2, 0, 0, 0, + 5,105,110,116, 32, 0, 2, 0, 0, 0, 5,100,101, 99,108, 0, 2, 0, 0, 0, + 5,107,105,110,100, 0, 2, 0, 0, 0, 4, 97,114,103, 0, 2, 0, 0, 0, 6, + 99,111,110,115,116, 0, 2, 0, 0, 0, 78, 94, 37,115, 42, 40, 91, 95, 37,119, + 93, 91, 95, 37,119, 37,115, 37, 42, 38, 93, 42,111,112,101,114, 97,116,111,114, + 41, 37,115, 42, 40, 91, 94, 37,115, 93, 91, 94, 37,115, 93, 42, 41, 37,115, 42, + 40, 37, 98, 40, 41, 41, 37,115, 42, 40, 99, 63,111, 63,110, 63,115, 63,116, 63, + 41, 37,115, 42, 59, 37,115, 42, 0, 2, 0, 0, 0, 9, 79,112,101,114, 97,116, +111,114, 0, 2, 0, 0, 0, 71, 94, 37,115, 42, 40, 91,126, 95, 37,119, 93, 91, + 95, 64, 37,119, 37,115, 37, 42, 38, 93, 42, 91, 95, 37,119, 93, 41, 37,115, 42, + 40, 37, 98, 40, 41, 41, 37,115, 42, 40, 99, 63,111, 63,110, 63,115, 63,116, 63, + 41, 37,115, 42, 61, 63, 37,115, 42, 48, 63, 37,115, 42, 59, 37,115, 42, 0, 2, + 0, 0, 0, 43, 94, 37,115, 42, 40, 91, 95, 37,119, 93, 41, 37,115, 42, 40, 37, + 98, 40, 41, 41, 37,115, 42, 40, 99, 63,111, 63,110, 63,115, 63,116, 63, 41, 37, +115, 42, 59, 37,115, 42, 0, 2, 0, 0, 0, 9, 70,117,110, 99,116,105,111,110, + 0, 2, 0, 0, 0, 64, 94, 37,115, 42, 40, 91,126, 95, 37,119, 93, 91, 95, 64, + 37,119, 37,115, 37, 42, 38, 93, 42, 91, 95, 37,119, 93, 41, 37,115, 42, 40, 37, + 98, 40, 41, 41, 37,115, 42, 40, 99, 63,111, 63,110, 63,115, 63,116, 63, 41, 37, +115, 42, 37, 98,123,125, 37,115, 42, 0, 2, 0, 0, 0, 46, 94, 37,115, 42, 40, + 91, 95, 37,119, 93, 41, 37,115, 42, 40, 37, 98, 40, 41, 41, 37,115, 42, 40, 99, + 63,111, 63,110, 63,115, 63,116, 63, 41, 37,115, 42, 37, 98,123,125, 37,115, 42, + 0, 2, 0, 0, 0, 5, 98, 97,115,101, 0, 2, 0, 0, 0, 49, 94, 37,115, 42, + 99,108, 97,115,115, 37,115, 42, 40, 91, 95, 37,119, 93, 91, 95, 37,119, 93, 42, + 41, 37,115, 42, 40, 46, 45, 41, 37,115, 42, 40, 37, 98,123,125, 41, 37,115, 42, + 59, 37,115, 42, 0, 2, 0, 0, 0, 50, 94, 37,115, 42,115,116,114,117, 99,116, + 37,115, 42, 40, 91, 95, 37,119, 93, 91, 95, 37,119, 93, 42, 41, 37,115, 42, 40, + 46, 45, 41, 37,115, 42, 40, 37, 98,123,125, 41, 37,115, 42, 59, 37,115, 42, 0, + 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 66, 94, 37,115, 42,116,121,112,101,100, +101,102, 37,115, 37,115, 42,115,116,114,117, 99,116, 37,115, 37,115, 42, 91, 95, + 37,119, 93, 42, 37,115, 42, 40, 37, 98,123,125, 41, 37,115, 42, 40, 91, 95, 37, +119, 93, 91, 95, 37,119, 93, 42, 41, 37,115, 42, 59, 37,115, 42, 0, 2, 0, 0, + 0, 17, 46, 45, 40, 91, 95, 37,119, 93, 91, 95, 37,119, 93, 42, 41, 36, 0, 2, + 0, 0, 0, 6, 67,108, 97,115,115, 0, 2, 0, 0, 0, 6,116,121,112,101,115, + 0, 2, 0, 0, 0, 28, 94, 37,115, 42,116,121,112,101,100,101,102, 37,115, 37, +115, 42, 40, 46, 45, 41, 37,115, 42, 59, 37,115, 42, 0, 2, 0, 0, 0, 40, 94, + 37,115, 42, 40, 91, 95, 37,119, 93, 91, 95, 64, 37,115, 37,119, 37,100, 37, 42, + 38, 93, 42, 91, 95, 37,119, 37,100, 93, 41, 37,115, 42, 59, 37,115, 42, 0, 2, + 0, 0, 0, 9, 86, 97,114,105, 97, 98,108,101, 0, 2, 0, 0, 0, 43, 94, 37, +115, 42, 40, 91, 95, 37,119, 93, 91, 93, 91, 95, 64, 37,115, 37,119, 37,100, 37, + 42, 38, 93, 42, 91, 93, 95, 37,119, 37,100, 93, 41, 37,115, 42, 59, 37,115, 42, + 0, 2, 0, 0, 0, 6, 65,114,114, 97,121, 0, 2, 0, 0, 0, 5, 99,111,100, +101, 0, 2, 0, 0, 0, 11, 94, 37,115, 42, 40, 37, 98, 1, 2, 41, 0, 2, 0, + 0, 0, 5, 67,111,100,101, 0, 2, 0, 0, 0, 5,108,105,110,101, 0, 2, 0, + 0, 0, 12, 94, 37,115, 42, 37, 36, 40, 46, 45, 10, 41, 0, 2, 0, 0, 0, 9, + 86,101,114, 98, 97,116,105,109, 0, 2, 0, 0, 0, 5,103,115,117, 98, 0, 2, + 0, 0, 0, 6, 37,115, 37,115, 42, 0, 2, 0, 0, 0, 6,101,114,114,111,114, + 0, 2, 0, 0, 0, 13, 35,112, 97,114,115,101, 32,101,114,114,111,114, 0, 2, + 0, 0, 0, 6,112, 97,114,115,101, 0, 4, 0, 0, 1, 49, 0, 0, 0, 15, 64, + 99,111,110,116, 97,105,110,101,114, 46,108,117, 97, 0, 0, 0, 0, 35, 5, 2, + 50, 17, 59, 1, 51, 13, 0, 20, 3, 13, 1, 2, 1, 2, 23, 1, 59, 1, 52, 59, + 1, 50, 13, 1, 11, 1, 31, 54, 27, 59, 1, 53, 0, 0, 0, 0, 2, 0, 0, 1, + 49, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 1, 49, 0, 0, 0, 2,115, 0, + 0, 0, 0, 4, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, + 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8,100,111,112, 97,114,115,101, 0, + +}; + +/* package.lo */ +static char B5[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 13, 64,112, 97, 99,107, 97, +103,101, 46,108,117, 97, 0, 0, 0, 0,102, 5, 0, 60, 20, 22, 2, 60, 21, 11, + 1, 15, 2, 11, 3, 60, 22, 11, 4, 30, 1, 60, 23, 25, 0, 60, 24, 15, 5, 15, + 0, 15, 6, 2, 0, 2, 60, 27, 15, 0, 11, 7, 11, 8, 26, 60, 36, 15, 0, 11, + 9, 11, 10, 26, 60, 60, 15, 0, 11, 11, 11, 12, 26, 60,100, 15, 0, 11, 13, 11, + 14, 26, 60,119, 15, 0, 11, 15, 11, 16, 26, 60,132, 15, 0, 11, 17, 11, 18, 26, + 60,146, 11, 20, 25, 19, 60,155, 11, 22, 25, 21, 0, 0, 0, 0, 0, 0, 0, 0, + 23, 2, 0, 0, 0, 13, 99,108, 97,115,115, 80, 97, 99,107, 97,103,101, 0, 2, + 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 15, 99,108, 97,115,115, + 67,111,110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, 5,116,121,112,101, 0, + 2, 0, 0, 0, 8,112, 97, 99,107, 97,103,101, 0, 2, 0, 0, 0, 7,115,101, +116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, + 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, 27, 0, 0, 0, 13, + 64,112, 97, 99,107, 97,103,101, 46,108,117, 97, 0, 0, 0, 0, 61, 6, 1, 60, + 28, 15, 0, 11, 1, 13, 0, 18, 3, 42, 2, 0, 1, 60, 29, 7, 1, 50, 27, 60, + 31, 13, 0, 13, 1, 16, 20, 0, 11, 5, 11, 5, 2, 0, 3, 60, 32, 13, 1, 7, + 1, 37, 23, 1, 60, 33, 60, 30, 13, 0, 13, 1, 16, 54, 36, 60, 34, 0, 0, 0, + 0, 2, 0, 0, 0, 27, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 29, 0, + 0, 0, 2,105, 0, 0, 0, 0, 6, 2, 0, 0, 0, 6,112,114,105,110,116, 0, + 2, 0, 0, 0, 10, 80, 97, 99,107, 97,103,101, 58, 32, 0, 2, 0, 0, 0, 5, +115,101,108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 2, +105, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 11,112,114,101,112,114,111, 99, +101,115,115, 0, 4, 0, 0, 0, 36, 0, 0, 0, 13, 64,112, 97, 99,107, 97,103, +101, 46,108,117, 97, 0, 0, 0, 1, 83, 7, 1, 60, 38, 13, 0, 11, 1, 11, 2, + 13, 0, 18, 1, 42, 26, 60, 40, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 4, + 11, 5, 2, 1, 3, 26, 60, 41, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 6, + 11, 7, 2, 1, 3, 26, 60, 42, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 8, + 11, 9, 2, 1, 3, 26, 60, 43, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 10, + 11, 5, 2, 1, 3, 26, 60, 44, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 7, + 11, 6, 2, 1, 3, 26, 60, 45, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 9, + 11, 8, 2, 1, 3, 26, 60, 46, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 11, + 11, 12, 2, 1, 3, 26, 60, 47, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 13, + 11, 14, 2, 1, 3, 26, 60, 48, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 15, + 11, 14, 2, 1, 3, 26, 60, 49, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 16, + 11, 14, 2, 1, 3, 26, 60, 50, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 17, + 11, 5, 2, 1, 3, 26, 60, 51, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 18, + 11, 19, 2, 1, 3, 26, 60, 52, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 18, + 11, 19, 2, 1, 3, 26, 60, 53, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 20, + 11, 21, 2, 1, 3, 26, 60, 55, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 22, + 11, 7, 2, 1, 3, 26, 60, 56, 13, 0, 11, 1, 15, 3, 13, 0, 18, 1, 11, 23, + 11, 9, 2, 1, 3, 26, 60, 57, 0, 0, 0, 0, 1, 0, 0, 0, 36, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 24, 2, 0, 0, 0, 5,115,101,108,102, 0, + 2, 0, 0, 0, 5, 99,111,100,101, 0, 2, 0, 0, 0, 2, 32, 0, 2, 0, 0, + 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, 10, 40, 47, 47, 91, 94, 10, 93, 42, + 41, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 4, 47, 37, 42, 0, 2, 0, 0, + 0, 2, 1, 0, 2, 0, 0, 0, 4, 37, 42, 47, 0, 2, 0, 0, 0, 2, 2, 0, + 2, 0, 0, 0, 5, 37, 98, 1, 2, 0, 2, 0, 0, 0, 8, 37,115, 42, 64, 37, +115, 42, 0, 2, 0, 0, 0, 2, 64, 0, 2, 0, 0, 0, 14, 37,115, 63,105,110, +108,105,110,101, 40, 37,115, 41, 0, 2, 0, 0, 0, 3, 37, 49, 0, 2, 0, 0, + 0, 14, 37,115, 63,101,120,116,101,114,110, 40, 37,115, 41, 0, 2, 0, 0, 0, + 15, 37,115, 63,118,105,114,116,117, 97,108, 40, 37,115, 41, 0, 2, 0, 0, 0, + 8,112,117, 98,108,105, 99, 58, 0, 2, 0, 0, 0, 18, 40, 91, 94, 37,119, 95, + 93, 41,118,111,105,100, 37,115, 42, 37, 42, 0, 2, 0, 0, 0, 13, 37, 49, 95, +117,115,101,114,100, 97,116, 97, 32, 0, 2, 0, 0, 0, 18, 40, 91, 94, 37,119, + 95, 93, 41, 99,104, 97,114, 37,115, 42, 37, 42, 0, 2, 0, 0, 0, 12, 37, 49, + 95, 99,115,116,114,105,110,103, 32, 0, 2, 0, 0, 0, 5, 37, 36, 37, 91, 0, + 2, 0, 0, 0, 5, 37, 36, 37, 93, 0, 2, 0, 0, 0, 9,112,114,101, 97,109, + 98,108,101, 0, 4, 0, 0, 0, 60, 0, 0, 0, 13, 64,112, 97, 99,107, 97,103, +101, 46,108,117, 97, 0, 0, 0, 1, 79, 5, 1, 60, 61, 15, 0, 11, 1, 2, 0, + 1, 60, 62, 15, 0, 11, 2, 13, 0, 18, 4, 42, 11, 5, 42, 2, 0, 1, 60, 63, + 15, 0, 11, 6, 15, 7, 42, 11, 8, 42, 15, 9, 2, 1, 0, 42, 11, 10, 42, 2, + 0, 1, 60, 64, 15, 0, 11, 11, 2, 0, 1, 60, 66, 15, 12, 18, 13, 44, 52, 54, + 60, 67, 15, 0, 11, 14, 2, 0, 1, 60, 68, 15, 0, 11, 15, 13, 0, 18, 4, 42, + 11, 16, 42, 2, 0, 1, 60, 69, 15, 0, 11, 17, 13, 0, 18, 4, 42, 11, 18, 42, + 2, 0, 1, 60, 70, 15, 0, 11, 5, 2, 0, 1, 50, 2, 60, 71, 60, 73, 15, 12, + 18, 19, 52, 46, 60, 74, 15, 0, 11, 20, 2, 0, 1, 60, 75, 15, 0, 11, 21, 2, + 0, 1, 60, 76, 15, 0, 11, 22, 13, 0, 18, 4, 42, 11, 23, 42, 2, 0, 1, 60, + 77, 15, 0, 11, 24, 2, 0, 1, 50, 2, 60, 78, 60, 79, 15, 0, 11, 25, 2, 0, + 1, 60, 80, 7, 1, 50, 23, 60, 82, 13, 0, 13, 1, 16, 20, 27, 2, 0, 1, 60, + 83, 13, 1, 7, 1, 37, 23, 1, 60, 84, 60, 81, 13, 0, 13, 1, 16, 54, 32, 60, + 85, 15, 0, 11, 5, 2, 0, 1, 60, 86, 15, 0, 11, 28, 2, 0, 1, 60, 87, 13, + 0, 20, 29, 2, 0, 1, 60, 88, 15, 0, 11, 5, 2, 0, 1, 60, 89, 15, 0, 11, + 30, 2, 0, 1, 60, 90, 15, 0, 11, 31, 2, 0, 1, 60, 91, 15, 0, 11, 32, 2, + 0, 1, 60, 92, 15, 33, 15, 34, 11, 35, 2, 0, 2, 60, 93, 15, 33, 15, 36, 11, + 37, 2, 0, 2, 60, 94, 15, 38, 11, 39, 2, 0, 1, 60, 95, 15, 38, 11, 5, 2, + 0, 1, 60, 96, 0, 0, 0, 0, 2, 0, 0, 0, 60, 0, 0, 0, 5,115,101,108, +102, 0, 0, 0, 0, 80, 0, 0, 0, 2,105, 0, 0, 0, 0, 40, 2, 0, 0, 0, + 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 4, 47, 42, 10, 0, 2, 0, 0, + 0, 17, 42, 42, 32, 76,117, 97, 32, 98,105,110,100,105,110,103, 58, 32, 0, 2, + 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, + 0, 0, 0, 2, 10, 0, 2, 0, 0, 0, 31, 42, 42, 32, 71,101,110,101,114, 97, +116,101,100, 32, 97,117,116,111,109, 97,116,105, 99, 97,108,108,121, 32, 98,121, + 32, 0, 2, 0, 0, 0, 14, 84, 79, 76, 85, 65, 95, 86, 69, 82, 83, 73, 79, 78, + 0, 2, 0, 0, 0, 5, 32,111,110, 32, 0, 2, 0, 0, 0, 5,100, 97,116,101, + 0, 2, 0, 0, 0, 3, 46, 10, 0, 2, 0, 0, 0, 5, 42, 47, 10, 10, 0, 2, + 0, 0, 0, 6,102,108, 97,103,115, 0, 2, 0, 0, 0, 2,104, 0, 2, 0, 0, + 0, 24, 47, 42, 32, 69,120,112,111,114,116,101,100, 32,102,117,110, 99,116,105, +111,110, 32, 42, 47, 0, 2, 0, 0, 0, 12,105,110,116, 32, 32,116,111,108,117, + 97, 95, 0, 2, 0, 0, 0, 14, 95,111,112,101,110, 32, 40,118,111,105,100, 41, + 59, 0, 2, 0, 0, 0, 12,118,111,105,100, 32,116,111,108,117, 97, 95, 0, 2, + 0, 0, 0, 15, 95, 99,108,111,115,101, 32, 40,118,111,105,100, 41, 59, 0, 2, + 0, 0, 0, 2, 97, 0, 2, 0, 0, 0, 45, 47, 42, 32, 65,117,116,111,109, 97, +116,105, 99, 32,105,110,105,116,105, 97,108,105,122, 97,116,105,111,110, 32,102, +111,114, 32, 67, 43, 43, 32, 99,111,100,101, 32, 42, 47, 10, 0, 2, 0, 0, 0, + 20, 35,105,102,100,101,102, 32, 95, 95, 99,112,108,117,115,112,108,117,115, 10, + 0, 2, 0, 0, 0, 26,115,116, 97,116,105, 99, 32,105,110,116, 32,100,117,109, +109,121, 32, 61, 32,116,111,108,117, 97, 95, 0, 2, 0, 0, 0, 10, 95,111,112, +101,110, 32, 40, 41, 59, 0, 2, 0, 0, 0, 9, 35,101,110,100,105,102, 10, 10, + 0, 2, 0, 0, 0, 21, 35,105,110, 99,108,117,100,101, 32, 34,116,111,108,117, + 97, 46,104, 34, 10, 10, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 9,112, +114,101, 97,109, 98,108,101, 0, 2, 0, 0, 0, 20, 47, 42, 32,116, 97,103, 32, +118, 97,114,105, 97, 98,108,101,115, 32, 42, 47, 0, 2, 0, 0, 0, 8,100,101, + 99,108,116, 97,103, 0, 2, 0, 0, 0, 51, 47, 42, 32,102,117,110, 99,116,105, +111,110, 32,116,111, 32,114,101,103,105,115,116,101,114, 32,116,121,112,101, 32, + 97,110,100, 32,105,110,105,116,105, 97,108,105,122,101, 32,116, 97,103, 32, 42, + 47, 0, 2, 0, 0, 0, 35,115,116, 97,116,105, 99, 32,118,111,105,100, 32,116, +111,108,117, 97, 73, 95,105,110,105,116, 95,116, 97,103, 32, 40,118,111,105,100, + 41, 0, 2, 0, 0, 0, 2,123, 0, 2, 0, 0, 0, 8,102,111,114,101, 97, 99, +104, 0, 2, 0, 0, 0, 10, 95,117,115,101,114,116,121,112,101, 0, 4, 0, 0, + 0, 92, 0, 0, 0, 13, 64,112, 97, 99,107, 97,103,101, 46,108,117, 97, 0, 0, + 0, 0, 16, 6, 2, 60, 92, 15, 2, 11, 3, 13, 1, 11, 4, 2, 0, 3, 0, 0, + 0, 0, 2, 0, 0, 0, 92, 0, 0, 0, 2,110, 0, 0, 0, 0, 92, 0, 0, 0, + 2,118, 0, 0, 0, 0, 5, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 2,118, + 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 18, 32,116, +111,108,117, 97, 95,117,115,101,114,116,121,112,101, 40, 34, 0, 2, 0, 0, 0, + 4, 34, 41, 59, 0, 2, 0, 0, 0, 10, 95,116, 97,103,110, 97,109,101,115, 0, + 4, 0, 0, 0, 93, 0, 0, 0, 13, 64,112, 97, 99,107, 97,103,101, 46,108,117, + 97, 0, 0, 0, 0, 21, 7, 2, 60, 93, 15, 2, 11, 3, 13, 1, 11, 4, 13, 0, + 42, 11, 5, 2, 0, 4, 0, 0, 0, 0, 2, 0, 0, 0, 93, 0, 0, 0, 2,110, + 0, 0, 0, 0, 93, 0, 0, 0, 2,118, 0, 0, 0, 0, 6, 2, 0, 0, 0, 2, +110, 0, 2, 0, 0, 0, 2,118, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, + 0, 2, 0, 0, 0, 16, 32,116,111,108,117, 97, 95,115,101,116,116, 97,103, 40, + 34, 0, 2, 0, 0, 0, 4, 34, 44, 38, 0, 2, 0, 0, 0, 3, 41, 59, 0, 2, + 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, + 0, 0, 9,114,101,103,105,115,116,101,114, 0, 4, 0, 0, 0,100, 0, 0, 0, + 13, 64,112, 97, 99,107, 97,103,101, 46,108,117, 97, 0, 0, 0, 0,132, 4, 1, + 60,101, 15, 0, 11, 1, 2, 0, 1, 60,102, 15, 0, 11, 2, 13, 0, 18, 4, 42, + 11, 5, 42, 2, 0, 1, 60,103, 15, 0, 11, 6, 2, 0, 1, 60,104, 15, 0, 11, + 7, 2, 0, 1, 60,105, 15, 0, 11, 8, 2, 0, 1, 60,106, 15, 0, 11, 9, 2, + 0, 1, 60,107, 7, 1, 50, 23, 60,109, 13, 0, 13, 1, 16, 20, 11, 2, 0, 1, + 60,110, 13, 1, 7, 1, 37, 23, 1, 60,111, 60,108, 13, 0, 13, 1, 16, 54, 32, + 60,112, 15, 0, 11, 12, 2, 0, 1, 60,113, 15, 0, 11, 13, 2, 0, 1, 60,114, + 15, 0, 11, 14, 2, 0, 1, 60,115, 0, 0, 0, 0, 2, 0, 0, 0,100, 0, 0, + 0, 5,115,101,108,102, 0, 0, 0, 0,107, 0, 0, 0, 2,105, 0, 0, 0, 0, + 15, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 20, 47, 42, + 32, 79,112,101,110, 32,102,117,110, 99,116,105,111,110, 32, 42, 47, 0, 2, 0, + 0, 0, 11,105,110,116, 32,116,111,108,117, 97, 95, 0, 2, 0, 0, 0, 5,115, +101,108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 13, 95, +111,112,101,110, 32, 40,118,111,105,100, 41, 0, 2, 0, 0, 0, 2,123, 0, 2, + 0, 0, 0, 15, 32,116,111,108,117, 97, 95,111,112,101,110, 40, 41, 59, 0, 2, + 0, 0, 0, 19, 32,108,117, 97, 95, 98,101,103,105,110, 98,108,111, 99,107, 40, + 41, 59, 0, 2, 0, 0, 0, 20, 32,116,111,108,117, 97, 73, 95,105,110,105,116, + 95,116, 97,103, 40, 41, 59, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 9, +114,101,103,105,115,116,101,114, 0, 2, 0, 0, 0, 17, 32,108,117, 97, 95,101, +110,100, 98,108,111, 99,107, 40, 41, 59, 0, 2, 0, 0, 0, 11, 32,114,101,116, +117,114,110, 32, 49, 59, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 11,117, +110,114,101,103,105,115,116,101,114, 0, 4, 0, 0, 0,119, 0, 0, 0, 13, 64, +112, 97, 99,107, 97,103,101, 46,108,117, 97, 0, 0, 0, 0, 87, 4, 1, 60,120, + 15, 0, 11, 1, 2, 0, 1, 60,121, 15, 0, 11, 2, 13, 0, 18, 4, 42, 11, 5, + 42, 2, 0, 1, 60,122, 15, 0, 11, 6, 2, 0, 1, 60,123, 7, 1, 50, 23, 60, +125, 13, 0, 13, 1, 16, 20, 8, 2, 0, 1, 60,126, 13, 1, 7, 1, 37, 23, 1, + 60,127, 60,124, 13, 0, 13, 1, 16, 54, 32, 60,128, 15, 0, 11, 9, 2, 0, 1, + 60,129, 0, 0, 0, 0, 2, 0, 0, 0,119, 0, 0, 0, 5,115,101,108,102, 0, + 0, 0, 0,123, 0, 0, 0, 2,105, 0, 0, 0, 0, 10, 2, 0, 0, 0, 7,111, +117,116,112,117,116, 0, 2, 0, 0, 0, 21, 47, 42, 32, 67,108,111,115,101, 32, +102,117,110, 99,116,105,111,110, 32, 42, 47, 0, 2, 0, 0, 0, 12,118,111,105, +100, 32,116,111,108,117, 97, 95, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, + 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 14, 95, 99,108,111,115,101, + 32, 40,118,111,105,100, 41, 0, 2, 0, 0, 0, 2,123, 0, 2, 0, 0, 0, 2, +105, 0, 2, 0, 0, 0, 11,117,110,114,101,103,105,115,116,101,114, 0, 2, 0, + 0, 0, 2,125, 0, 2, 0, 0, 0, 7,104,101, 97,100,101,114, 0, 4, 0, 0, + 0,132, 0, 0, 0, 13, 64,112, 97, 99,107, 97,103,101, 46,108,117, 97, 0, 0, + 0, 0,127, 4, 1, 60,133, 15, 0, 11, 1, 2, 0, 1, 15, 0, 11, 2, 13, 0, + 18, 4, 42, 11, 5, 42, 2, 0, 1, 60,134, 15, 0, 11, 6, 15, 7, 42, 11, 8, + 42, 15, 9, 2, 1, 0, 42, 11, 10, 42, 2, 0, 1, 60,135, 15, 0, 11, 11, 2, + 0, 1, 60,137, 15, 12, 18, 13, 44, 52, 54, 60,138, 15, 0, 11, 14, 2, 0, 1, + 60,139, 15, 0, 11, 15, 13, 0, 18, 4, 42, 11, 16, 42, 2, 0, 1, 60,140, 15, + 0, 11, 17, 13, 0, 18, 4, 42, 11, 18, 42, 2, 0, 1, 60,141, 15, 0, 11, 5, + 2, 0, 1, 50, 2, 60,142, 60,143, 0, 0, 0, 0, 1, 0, 0, 0,132, 0, 0, + 0, 5,115,101,108,102, 0, 0, 0, 0, 19, 2, 0, 0, 0, 7,111,117,116,112, +117,116, 0, 2, 0, 0, 0, 4, 47, 42, 10, 0, 2, 0, 0, 0, 17, 42, 42, 32, + 76,117, 97, 32, 98,105,110,100,105,110,103, 58, 32, 0, 2, 0, 0, 0, 5,115, +101,108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 2, 10, + 0, 2, 0, 0, 0, 31, 42, 42, 32, 71,101,110,101,114, 97,116,101,100, 32, 97, +117,116,111,109, 97,116,105, 99, 97,108,108,121, 32, 98,121, 32, 0, 2, 0, 0, + 0, 14, 84, 79, 76, 85, 65, 95, 86, 69, 82, 83, 73, 79, 78, 0, 2, 0, 0, 0, + 5, 32,111,110, 32, 0, 2, 0, 0, 0, 5,100, 97,116,101, 0, 2, 0, 0, 0, + 3, 46, 10, 0, 2, 0, 0, 0, 5, 42, 47, 10, 10, 0, 2, 0, 0, 0, 6,102, +108, 97,103,115, 0, 2, 0, 0, 0, 2,104, 0, 2, 0, 0, 0, 24, 47, 42, 32, + 69,120,112,111,114,116,101,100, 32,102,117,110, 99,116,105,111,110, 32, 42, 47, + 0, 2, 0, 0, 0, 12,105,110,116, 32, 32,116,111,108,117, 97, 95, 0, 2, 0, + 0, 0, 14, 95,111,112,101,110, 32, 40,118,111,105,100, 41, 59, 0, 2, 0, 0, + 0, 12,118,111,105,100, 32,116,111,108,117, 97, 95, 0, 2, 0, 0, 0, 15, 95, + 99,108,111,115,101, 32, 40,118,111,105,100, 41, 59, 0, 2, 0, 0, 0, 9, 95, + 80, 97, 99,107, 97,103,101, 0, 4, 0, 0, 0,146, 0, 0, 0, 13, 64,112, 97, + 99,107, 97,103,101, 46,108,117, 97, 0, 0, 0, 0, 31, 4, 1, 60,147, 13, 0, + 11, 1, 15, 2, 26, 60,148, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60,149, 13, 0, + 1, 1, 60,150, 0, 0, 0, 0, 1, 0, 0, 0,146, 0, 0, 0, 2,116, 0, 0, + 0, 0, 5, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, + 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, 80, 97, 99,107, 97,103,101, 0, 2, + 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, + 97, 95,116, 97,103, 0, 2, 0, 0, 0, 8, 80, 97, 99,107, 97,103,101, 0, 4, + 0, 0, 0,155, 0, 0, 0, 13, 64,112, 97, 99,107, 97,103,101, 46,108,117, 97, + 0, 0, 0, 0,114, 10, 1, 60,157, 15, 2, 11, 3, 2, 1, 1, 60,159, 4, 0, + 60,161, 15, 5, 13, 1, 11, 6, 11, 7, 60,169, 2, 2, 3, 23, 2, 23, 1, 60, +170, 13, 2, 7, 0, 32, 56, 28, 60,172, 15, 9, 15, 10, 22, 2, 11, 0, 13, 0, + 11, 1, 13, 1, 30, 1, 2, 1, 1, 2, 1, 1, 60,173, 15, 11, 13, 3, 2, 0, + 1, 60,174, 13, 3, 20, 12, 2, 0, 1, 60,175, 13, 3, 20, 13, 13, 3, 18, 1, + 2, 0, 2, 60,176, 15, 14, 2, 0, 0, 60,177, 13, 3, 1, 4, 60,178, 0, 0, + 0, 0, 4, 0, 0, 0,155, 0, 0, 0, 5,110, 97,109,101, 0, 0, 0, 0,157, + 0, 0, 0, 5, 99,111,100,101, 0, 0, 0, 0,159, 0, 0, 0, 7,110,115,117, + 98,115,116, 0, 0, 0, 0,172, 0, 0, 0, 2,116, 0, 0, 0, 0, 15, 2, 0, + 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 5, 99,111,100,101, 0, 2, 0, + 0, 0, 5,114,101, 97,100, 0, 2, 0, 0, 0, 3, 46, 42, 0, 2, 0, 0, 0, + 7,110,115,117, 98,115,116, 0, 2, 0, 0, 0, 5,103,115,117, 98, 0, 2, 0, + 0, 0, 13, 37, 36, 60, 40, 46, 45, 41, 62, 37,115, 42, 10, 0, 4, 0, 0, 0, +161, 0, 0, 0, 13, 64,112, 97, 99,107, 97,103,101, 46,108,117, 97, 0, 0, 0, + 0, 71, 6, 1, 60,162, 15, 3, 13, 0, 11, 4, 2, 2, 2, 60,163, 13, 1, 44, + 52, 20, 60,164, 15, 5, 11, 6, 13, 2, 42, 11, 7, 42, 13, 0, 42, 2, 0, 1, + 50, 2, 60,165, 60,166, 15, 9, 13, 1, 11, 10, 2, 1, 2, 60,167, 15, 11, 13, + 1, 2, 0, 1, 60,168, 13, 3, 1, 4, 60,169, 0, 0, 0, 0, 4, 0, 0, 0, +161, 0, 0, 0, 3,102,110, 0, 0, 0, 0,162, 0, 0, 0, 3,102,112, 0, 0, + 0, 0,162, 0, 0, 0, 4,109,115,103, 0, 0, 0, 0,166, 0, 0, 0, 2,115, + 0, 0, 0, 0, 12, 2, 0, 0, 0, 3,102,110, 0, 2, 0, 0, 0, 3,102,112, + 0, 2, 0, 0, 0, 4,109,115,103, 0, 2, 0, 0, 0, 9,111,112,101,110,102, +105,108,101, 0, 2, 0, 0, 0, 2,114, 0, 2, 0, 0, 0, 6,101,114,114,111, +114, 0, 2, 0, 0, 0, 2, 35, 0, 2, 0, 0, 0, 3, 58, 32, 0, 2, 0, 0, + 0, 2,115, 0, 2, 0, 0, 0, 5,114,101, 97,100, 0, 2, 0, 0, 0, 3, 46, + 42, 0, 2, 0, 0, 0, 10, 99,108,111,115,101,102,105,108,101, 0, 2, 0, 0, + 0, 2,116, 0, 2, 0, 0, 0, 9, 95, 80, 97, 99,107, 97,103,101, 0, 2, 0, + 0, 0, 11, 95, 67,111,110,116, 97,105,110,101,114, 0, 2, 0, 0, 0, 5,112, +117,115,104, 0, 2, 0, 0, 0, 11,112,114,101,112,114,111, 99,101,115,115, 0, + 2, 0, 0, 0, 6,112, 97,114,115,101, 0, 2, 0, 0, 0, 4,112,111,112, 0, + +}; + +/* module.lo */ +static char B6[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 12, 64,109,111,100,117,108, +101, 46,108,117, 97, 0, 0, 0, 0, 75, 5, 0, 60, 19, 22, 2, 60, 20, 11, 1, + 15, 2, 11, 3, 60, 21, 11, 4, 30, 1, 60, 22, 25, 0, 60, 23, 15, 5, 15, 0, + 15, 6, 2, 0, 2, 60, 26, 15, 0, 11, 7, 11, 8, 26, 60, 36, 15, 0, 11, 9, + 11, 10, 26, 60, 41, 15, 0, 11, 11, 11, 12, 26, 60, 53, 11, 14, 25, 13, 60, 62, + 11, 16, 25, 15, 0, 0, 0, 0, 0, 0, 0, 0, 17, 2, 0, 0, 0, 12, 99,108, + 97,115,115, 77,111,100,117,108,101, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, + 0, 2, 0, 0, 0, 15, 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, + 0, 2, 0, 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 7,109,111,100,117, +108,101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10, +116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 9,114,101,103,105,115, +116,101,114, 0, 4, 0, 0, 0, 26, 0, 0, 0, 12, 64,109,111,100,117,108,101, + 46,108,117, 97, 0, 0, 0, 0, 60, 4, 1, 60, 27, 15, 0, 11, 1, 13, 0, 18, + 3, 42, 11, 4, 42, 2, 0, 1, 60, 28, 7, 1, 50, 23, 60, 30, 13, 0, 13, 1, + 16, 20, 6, 2, 0, 1, 60, 31, 13, 1, 7, 1, 37, 23, 1, 60, 32, 60, 29, 13, + 0, 13, 1, 16, 54, 32, 60, 33, 0, 0, 0, 0, 2, 0, 0, 0, 26, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 28, 0, 0, 0, 2,105, 0, 0, 0, 0, 7, + 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 16, 32,116,111, +108,117, 97, 95,109,111,100,117,108,101, 40, 34, 0, 2, 0, 0, 0, 5,115,101, +108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 4, 34, 41, + 59, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 9,114,101,103,105,115,116, +101,114, 0, 2, 0, 0, 0, 11,117,110,114,101,103,105,115,116,101,114, 0, 4, + 0, 0, 0, 36, 0, 0, 0, 12, 64,109,111,100,117,108,101, 46,108,117, 97, 0, + 0, 0, 0, 22, 4, 1, 60, 37, 15, 0, 11, 1, 13, 0, 18, 3, 42, 11, 4, 42, + 2, 0, 1, 60, 38, 0, 0, 0, 0, 1, 0, 0, 0, 36, 0, 0, 0, 5,115,101, +108,102, 0, 0, 0, 0, 5, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, + 0, 0, 0, 32, 32,108,117, 97, 95,112,117,115,104,110,105,108, 40, 41, 59, 32, +108,117, 97, 95,115,101,116,103,108,111, 98, 97,108, 40, 34, 0, 2, 0, 0, 0, + 5,115,101,108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, + 4, 34, 41, 59, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, + 41, 0, 0, 0, 12, 64,109,111,100,117,108,101, 46,108,117, 97, 0, 0, 0, 0, + 97, 8, 3, 60, 42, 15, 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 43, 15, 2, 13, + 1, 11, 4, 42, 13, 0, 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 44, 7, 1, 50, + 30, 60, 46, 13, 0, 13, 3, 16, 20, 2, 13, 1, 11, 9, 42, 11, 10, 2, 0, 3, + 60, 47, 13, 3, 7, 1, 37, 23, 3, 60, 48, 60, 45, 13, 0, 13, 3, 16, 54, 39, + 60, 49, 15, 2, 13, 1, 11, 11, 42, 13, 2, 42, 2, 0, 1, 60, 50, 0, 0, 0, + 0, 4, 0, 0, 0, 41, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 41, 0, + 0, 0, 6,105,100,101,110,116, 0, 0, 0, 0, 41, 0, 0, 0, 6, 99,108,111, +115,101, 0, 0, 0, 0, 44, 0, 0, 0, 2,105, 0, 0, 0, 0, 12, 2, 0, 0, + 0, 6,105,100,101,110,116, 0, 2, 0, 0, 0, 6, 99,108,111,115,101, 0, 2, + 0, 0, 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, 8, 77,111,100,117,108, +101,123, 0, 2, 0, 0, 0, 10, 32,110, 97,109,101, 32, 61, 32, 39, 0, 2, 0, + 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, + 0, 0, 3, 39, 59, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 2, 32, 0, + 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 8, 95, + 77,111,100,117,108,101, 0, 4, 0, 0, 0, 53, 0, 0, 0, 12, 64,109,111,100, +117,108,101, 46,108,117, 97, 0, 0, 0, 0, 40, 4, 1, 60, 54, 13, 0, 11, 1, + 15, 2, 26, 60, 55, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60, 56, 15, 5, 13, 0, + 2, 0, 1, 60, 57, 13, 0, 1, 1, 60, 58, 0, 0, 0, 0, 1, 0, 0, 0, 53, + 0, 0, 0, 2,116, 0, 0, 0, 0, 6, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, + 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 12, 99,108, 97,115,115, 77,111, +100,117,108,101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, + 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 7, 97,112,112, +101,110,100, 0, 2, 0, 0, 0, 7, 77,111,100,117,108,101, 0, 4, 0, 0, 0, + 62, 0, 0, 0, 12, 64,109,111,100,117,108,101, 46,108,117, 97, 0, 0, 0, 0, + 75, 10, 2, 60, 63, 15, 3, 15, 4, 22, 1, 11, 5, 13, 0, 30, 0, 2, 1, 1, + 2, 1, 1, 60, 64, 15, 6, 13, 2, 2, 0, 1, 60, 65, 13, 2, 20, 7, 15, 8, + 13, 1, 7, 2, 15, 9, 13, 1, 2, 1, 1, 7, 1, 38, 2, 1, 3, 2, 0, 2, + 60, 66, 15, 10, 2, 0, 0, 60, 67, 13, 2, 1, 3, 60, 68, 0, 0, 0, 0, 3, + 0, 0, 0, 62, 0, 0, 0, 2,110, 0, 0, 0, 0, 62, 0, 0, 0, 2, 98, 0, + 0, 0, 0, 63, 0, 0, 0, 2,116, 0, 0, 0, 0, 11, 2, 0, 0, 0, 2,110, + 0, 2, 0, 0, 0, 2, 98, 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 8, + 95, 77,111,100,117,108,101, 0, 2, 0, 0, 0, 11, 95, 67,111,110,116, 97,105, +110,101,114, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 5,112, +117,115,104, 0, 2, 0, 0, 0, 6,112, 97,114,115,101, 0, 2, 0, 0, 0, 7, +115,116,114,115,117, 98, 0, 2, 0, 0, 0, 7,115,116,114,108,101,110, 0, 2, + 0, 0, 0, 4,112,111,112, 0, +}; + +/* class.lo */ +static char B7[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 11, 64, 99,108, 97,115,115, + 46,108,117, 97, 0, 0, 0, 0, 96, 9, 0, 60, 20, 22, 4, 60, 21, 11, 1, 15, + 2, 11, 3, 60, 22, 11, 4, 11, 5, 60, 23, 11, 6, 11, 7, 60, 24, 11, 6, 30, + 3, 60, 25, 25, 0, 60, 26, 15, 8, 15, 0, 15, 9, 2, 0, 2, 60, 30, 15, 0, + 11, 10, 11, 11, 26, 60, 40, 15, 0, 11, 12, 11, 13, 26, 60, 45, 15, 0, 11, 14, + 11, 15, 26, 60, 57, 15, 0, 11, 16, 11, 17, 26, 60, 70, 11, 19, 25, 18, 60, 79, + 11, 21, 25, 20, 0, 0, 0, 0, 0, 0, 0, 0, 22, 2, 0, 0, 0, 11, 99,108, + 97,115,115, 67,108, 97,115,115, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, + 2, 0, 0, 0, 15, 99,108, 97,115,115, 67,111,110,116, 97,105,110,101,114, 0, + 2, 0, 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 6, 99,108, 97,115,115, + 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, + 0, 5, 98, 97,115,101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, + 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 9,114, +101,103,105,115,116,101,114, 0, 4, 0, 0, 0, 30, 0, 0, 0, 11, 64, 99,108, + 97,115,115, 46,108,117, 97, 0, 0, 0, 0, 68, 4, 1, 60, 31, 15, 0, 11, 1, + 13, 0, 18, 3, 42, 11, 4, 42, 13, 0, 18, 5, 42, 11, 6, 42, 2, 0, 1, 60, + 32, 7, 1, 50, 23, 60, 34, 13, 0, 13, 1, 16, 20, 8, 2, 0, 1, 60, 35, 13, + 1, 7, 1, 37, 23, 1, 60, 36, 60, 33, 13, 0, 13, 1, 16, 54, 32, 60, 37, 0, + 0, 0, 0, 2, 0, 0, 0, 30, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, + 32, 0, 0, 0, 2,105, 0, 0, 0, 0, 9, 2, 0, 0, 0, 7,111,117,116,112, +117,116, 0, 2, 0, 0, 0, 16, 32,116,111,108,117, 97, 95, 99, 99,108, 97,115, +115, 40, 34, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,110, + 97,109,101, 0, 2, 0, 0, 0, 4, 34, 44, 34, 0, 2, 0, 0, 0, 5, 98, 97, +115,101, 0, 2, 0, 0, 0, 4, 34, 41, 59, 0, 2, 0, 0, 0, 2,105, 0, 2, + 0, 0, 0, 9,114,101,103,105,115,116,101,114, 0, 2, 0, 0, 0, 11,117,110, +114,101,103,105,115,116,101,114, 0, 4, 0, 0, 0, 40, 0, 0, 0, 11, 64, 99, +108, 97,115,115, 46,108,117, 97, 0, 0, 0, 0, 22, 4, 1, 60, 41, 15, 0, 11, + 1, 13, 0, 18, 3, 42, 11, 4, 42, 2, 0, 1, 60, 42, 0, 0, 0, 0, 1, 0, + 0, 0, 40, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 5, 2, 0, 0, 0, + 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 32, 32,108,117, 97, 95,112,117, +115,104,110,105,108, 40, 41, 59, 32,108,117, 97, 95,115,101,116,103,108,111, 98, + 97,108, 40, 34, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5, +110, 97,109,101, 0, 2, 0, 0, 0, 4, 34, 41, 59, 0, 2, 0, 0, 0, 8,100, +101, 99,108,116, 97,103, 0, 4, 0, 0, 0, 45, 0, 0, 0, 11, 64, 99,108, 97, +115,115, 46,108,117, 97, 0, 0, 0, 0,128, 8, 1, 60, 46, 13, 0, 11, 1, 13, + 0, 11, 2, 15, 3, 13, 0, 18, 4, 2, 2, 1, 27, 1, 27, 2, 5, 4, 15, 5, + 13, 0, 18, 1, 13, 0, 18, 2, 2, 0, 2, 60, 47, 13, 0, 11, 6, 13, 0, 11, + 7, 15, 3, 13, 0, 18, 4, 11, 8, 2, 2, 2, 27, 1, 27, 2, 5, 4, 60, 48, + 15, 3, 13, 0, 18, 10, 2, 2, 1, 15, 5, 13, 1, 13, 2, 2, 0, 2, 60, 49, + 7, 1, 50, 23, 60, 51, 13, 0, 13, 3, 16, 20, 5, 2, 0, 1, 60, 52, 13, 3, + 7, 1, 37, 23, 3, 60, 53, 60, 50, 13, 0, 13, 3, 16, 54, 32, 60, 54, 0, 0, + 0, 0, 4, 0, 0, 0, 45, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 48, + 0, 0, 0, 5,116,121,112,101, 0, 0, 0, 0, 48, 0, 0, 0, 4,116, 97,103, + 0, 0, 0, 0, 49, 0, 0, 0, 2,105, 0, 0, 0, 0, 12, 2, 0, 0, 0, 5, +115,101,108,102, 0, 2, 0, 0, 0, 6,105,116,121,112,101, 0, 2, 0, 0, 0, + 4,116, 97,103, 0, 2, 0, 0, 0, 7,116, 97,103,118, 97,114, 0, 2, 0, 0, + 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 8,100,101, 99,108,116, 97,103, 0, + 2, 0, 0, 0, 7, 99,105,116,121,112,101, 0, 2, 0, 0, 0, 5, 99,116, 97, +103, 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, 0, 0, 0, 5,116,121, +112,101, 0, 2, 0, 0, 0, 5, 98, 97,115,101, 0, 2, 0, 0, 0, 2,105, 0, + 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, 57, 0, 0, 0, 11, + 64, 99,108, 97,115,115, 46,108,117, 97, 0, 0, 0, 0,117, 8, 3, 60, 58, 15, + 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 59, 15, 2, 13, 1, 11, 4, 42, 13, 0, + 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 60, 15, 2, 13, 1, 11, 8, 42, 13, 0, + 18, 9, 42, 11, 10, 42, 2, 0, 1, 60, 61, 7, 1, 50, 30, 60, 63, 13, 0, 13, + 3, 16, 20, 2, 13, 1, 11, 12, 42, 11, 13, 2, 0, 3, 60, 64, 13, 3, 7, 1, + 37, 23, 3, 60, 65, 60, 62, 13, 0, 13, 3, 16, 54, 39, 60, 66, 15, 2, 13, 1, + 11, 14, 42, 13, 2, 42, 2, 0, 1, 60, 67, 0, 0, 0, 0, 4, 0, 0, 0, 57, + 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 57, 0, 0, 0, 6,105,100,101, +110,116, 0, 0, 0, 0, 57, 0, 0, 0, 6, 99,108,111,115,101, 0, 0, 0, 0, + 61, 0, 0, 0, 2,105, 0, 0, 0, 0, 15, 2, 0, 0, 0, 6,105,100,101,110, +116, 0, 2, 0, 0, 0, 6, 99,108,111,115,101, 0, 2, 0, 0, 0, 6,112,114, +105,110,116, 0, 2, 0, 0, 0, 7, 67,108, 97,115,115,123, 0, 2, 0, 0, 0, + 10, 32,110, 97,109,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,115,101,108,102, + 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 3, 39, 44, 0, 2, + 0, 0, 0, 10, 32, 98, 97,115,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5, 98, + 97,115,101, 0, 2, 0, 0, 0, 3, 39, 59, 0, 2, 0, 0, 0, 2,105, 0, 2, + 0, 0, 0, 2, 32, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 2,125, 0, + 2, 0, 0, 0, 7, 95, 67,108, 97,115,115, 0, 4, 0, 0, 0, 70, 0, 0, 0, + 11, 64, 99,108, 97,115,115, 46,108,117, 97, 0, 0, 0, 0, 40, 4, 1, 60, 71, + 13, 0, 11, 1, 15, 2, 26, 60, 72, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60, 73, + 15, 5, 13, 0, 2, 0, 1, 60, 74, 13, 0, 1, 1, 60, 75, 0, 0, 0, 0, 1, + 0, 0, 0, 70, 0, 0, 0, 2,116, 0, 0, 0, 0, 6, 2, 0, 0, 0, 2,116, + 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 11, 99,108, 97, +115,115, 67,108, 97,115,115, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, + 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 7, + 97,112,112,101,110,100, 0, 2, 0, 0, 0, 6, 67,108, 97,115,115, 0, 4, 0, + 0, 0, 79, 0, 0, 0, 11, 64, 99,108, 97,115,115, 46,108,117, 97, 0, 0, 0, + 0, 73, 11, 3, 60, 80, 15, 4, 15, 5, 22, 2, 11, 6, 13, 0, 11, 7, 13, 1, + 30, 1, 2, 1, 1, 2, 1, 1, 60, 81, 15, 8, 13, 3, 2, 0, 1, 60, 82, 13, + 3, 20, 9, 15, 10, 13, 2, 7, 2, 15, 11, 13, 2, 2, 1, 1, 7, 1, 38, 2, + 1, 3, 2, 0, 2, 60, 83, 15, 12, 2, 0, 0, 60, 84, 0, 0, 0, 0, 4, 0, + 0, 0, 79, 0, 0, 0, 2,110, 0, 0, 0, 0, 79, 0, 0, 0, 2,112, 0, 0, + 0, 0, 79, 0, 0, 0, 2, 98, 0, 0, 0, 0, 80, 0, 0, 0, 2, 99, 0, 0, + 0, 0, 13, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 2,112, 0, 2, 0, 0, + 0, 2, 98, 0, 2, 0, 0, 0, 2, 99, 0, 2, 0, 0, 0, 7, 95, 67,108, 97, +115,115, 0, 2, 0, 0, 0, 11, 95, 67,111,110,116, 97,105,110,101,114, 0, 2, + 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 5, 98, 97,115,101, 0, 2, + 0, 0, 0, 5,112,117,115,104, 0, 2, 0, 0, 0, 6,112, 97,114,115,101, 0, + 2, 0, 0, 0, 7,115,116,114,115,117, 98, 0, 2, 0, 0, 0, 7,115,116,114, +108,101,110, 0, 2, 0, 0, 0, 4,112,111,112, 0, +}; + +/* typedef.lo */ +static char B8[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 13, 64,116,121,112,101,100, +101,102, 46,108,117, 97, 0, 0, 0, 0, 52, 7, 0, 60, 24, 22, 3, 60, 25, 11, + 1, 11, 2, 11, 3, 60, 26, 11, 2, 11, 4, 60, 27, 11, 2, 30, 2, 60, 28, 25, + 0, 60, 31, 15, 0, 11, 5, 11, 6, 26, 60, 40, 11, 8, 25, 7, 60, 49, 11, 10, + 25, 9, 0, 0, 0, 0, 0, 0, 0, 0, 11, 2, 0, 0, 0, 13, 99,108, 97,115, +115, 84,121,112,101,100,101,102, 0, 2, 0, 0, 0, 6,117,116,121,112,101, 0, + 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 5, +116,121,112,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, + 31, 0, 0, 0, 13, 64,116,121,112,101,100,101,102, 46,108,117, 97, 0, 0, 0, + 0, 92, 6, 3, 60, 32, 15, 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 33, 15, 2, + 13, 1, 11, 4, 42, 13, 0, 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 34, 15, 2, + 13, 1, 11, 8, 42, 13, 0, 18, 9, 42, 11, 7, 42, 2, 0, 1, 60, 35, 15, 2, + 13, 1, 11, 10, 42, 13, 0, 18, 11, 42, 11, 7, 42, 2, 0, 1, 60, 36, 15, 2, + 13, 1, 11, 12, 42, 13, 2, 42, 2, 0, 1, 60, 37, 0, 0, 0, 0, 3, 0, 0, + 0, 31, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 31, 0, 0, 0, 6,105, +100,101,110,116, 0, 0, 0, 0, 31, 0, 0, 0, 6, 99,108,111,115,101, 0, 0, + 0, 0, 13, 2, 0, 0, 0, 6,105,100,101,110,116, 0, 2, 0, 0, 0, 6, 99, +108,111,115,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, + 9, 84,121,112,101,100,101,102,123, 0, 2, 0, 0, 0, 11, 32,117,116,121,112, +101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, + 6,117,116,121,112,101, 0, 2, 0, 0, 0, 3, 39, 44, 0, 2, 0, 0, 0, 9, + 32,109,111,100, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, + 0, 0, 10, 32,116,121,112,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,116,121, +112,101, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 9, 95, 84,121,112,101, +100,101,102, 0, 4, 0, 0, 0, 40, 0, 0, 0, 13, 64,116,121,112,101,100,101, +102, 46,108,117, 97, 0, 0, 0, 0, 40, 4, 1, 60, 41, 13, 0, 11, 1, 15, 2, + 26, 60, 42, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60, 43, 15, 5, 13, 0, 2, 0, + 1, 60, 44, 13, 0, 1, 1, 60, 45, 0, 0, 0, 0, 1, 0, 0, 0, 40, 0, 0, + 0, 2,116, 0, 0, 0, 0, 6, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6, + 95, 98, 97,115,101, 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, 84,121,112,101, +100,101,102, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, + 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 14, 97,112,112,101, +110,100,116,121,112,101,100,101,102, 0, 2, 0, 0, 0, 8, 84,121,112,101,100, +101,102, 0, 4, 0, 0, 0, 49, 0, 0, 0, 13, 64,116,121,112,101,100,101,102, + 46,108,117, 97, 0, 0, 0, 0,109, 14, 1, 60, 50, 15, 1, 13, 0, 11, 2, 2, + 1, 2, 52, 11, 60, 51, 15, 3, 11, 4, 2, 0, 1, 50, 2, 60, 52, 60, 53, 15, + 6, 15, 7, 13, 0, 11, 8, 11, 9, 2, 1, 3, 11, 9, 2, 1, 2, 60, 54, 15, + 10, 22, 3, 60, 55, 11, 11, 13, 1, 13, 1, 18, 12, 16, 11, 13, 60, 56, 13, 1, + 13, 1, 18, 12, 7, 1, 38, 16, 11, 14, 60, 57, 15, 15, 13, 1, 7, 1, 13, 1, + 18, 12, 7, 2, 38, 2, 1, 3, 30, 2, 60, 58, 3, 2, 1, 60, 59, 0, 0, 0, + 0, 2, 0, 0, 0, 49, 0, 0, 0, 2,115, 0, 0, 0, 0, 53, 0, 0, 0, 2, +116, 0, 0, 0, 0, 16, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 8,115,116, +114,102,105,110,100, 0, 2, 0, 0, 0, 6, 91, 37, 42, 38, 93, 0, 2, 0, 0, + 0, 12,116,111,108,117, 97, 95,101,114,114,111,114, 0, 2, 0, 0, 0, 62, 35, +105,110,118, 97,108,105,100, 32,116,121,112,101,100,101,102, 58, 32,112,111,105, +110,116,101,114,115, 32, 40, 97,110,100, 32,114,101,102,101,114,101,110, 99,101, +115, 41, 32, 97,114,101, 32,110,111,116, 32,115,117,112,112,111,114,116,101,100, + 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6,115,112,108,105,116, 0, 2, + 0, 0, 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, 6, 37,115, 37,115, 42, 0, + 2, 0, 0, 0, 2, 32, 0, 2, 0, 0, 0, 9, 95, 84,121,112,101,100,101,102, + 0, 2, 0, 0, 0, 6,117,116,121,112,101, 0, 2, 0, 0, 0, 2,110, 0, 2, + 0, 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, + 0, 0, 7, 99,111,110, 99, 97,116, 0, +}; + +/* define.lo */ +static char B9[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 12, 64,100,101,102,105,110, +101, 46,108,117, 97, 0, 0, 0, 0, 75, 5, 0, 60, 18, 22, 2, 60, 19, 11, 1, + 11, 2, 11, 3, 60, 20, 15, 4, 30, 1, 60, 21, 25, 0, 60, 22, 15, 5, 15, 0, + 15, 6, 2, 0, 2, 60, 25, 15, 0, 11, 7, 11, 8, 26, 60, 35, 15, 0, 11, 9, + 11, 10, 26, 60, 42, 15, 0, 11, 11, 11, 12, 26, 60, 51, 11, 14, 25, 13, 60, 65, + 11, 16, 25, 15, 0, 0, 0, 0, 0, 0, 0, 0, 17, 2, 0, 0, 0, 12, 99,108, + 97,115,115, 68,101,102,105,110,101, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, + 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, + 0, 13, 99,108, 97,115,115, 70,101, 97,116,117,114,101, 0, 2, 0, 0, 0, 7, +115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97, +103, 0, 2, 0, 0, 0, 9,114,101,103,105,115,116,101,114, 0, 4, 0, 0, 0, + 25, 0, 0, 0, 12, 64,100,101,102,105,110,101, 46,108,117, 97, 0, 0, 0, 0, + 80, 5, 1, 60, 26, 13, 0, 20, 2, 2, 1, 1, 60, 27, 13, 1, 52, 33, 60, 28, + 15, 3, 11, 4, 13, 1, 42, 11, 5, 42, 13, 0, 18, 6, 42, 11, 7, 42, 13, 0, + 18, 8, 42, 11, 9, 42, 2, 0, 1, 50, 27, 60, 30, 15, 3, 11, 10, 13, 0, 18, + 6, 42, 11, 7, 42, 13, 0, 18, 8, 42, 11, 9, 42, 2, 0, 1, 60, 31, 60, 32, + 0, 0, 0, 0, 2, 0, 0, 0, 25, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, + 0, 26, 0, 0, 0, 2,112, 0, 0, 0, 0, 11, 2, 0, 0, 0, 2,112, 0, 2, + 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 9,105,110,109,111,100,117, +108,101, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 18, + 32,116,111,108,117, 97, 95, 99,111,110,115,116, 97,110,116, 40, 34, 0, 2, 0, + 0, 0, 4, 34, 44, 34, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, + 0, 0, 3, 34, 44, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, + 3, 41, 59, 0, 2, 0, 0, 0, 23, 32,116,111,108,117, 97, 95, 99,111,110,115, +116, 97,110,116, 40, 78, 85, 76, 76, 44, 34, 0, 2, 0, 0, 0, 11,117,110,114, +101,103,105,115,116,101,114, 0, 4, 0, 0, 0, 35, 0, 0, 0, 12, 64,100,101, +102,105,110,101, 46,108,117, 97, 0, 0, 0, 0, 38, 4, 1, 60, 36, 13, 0, 20, + 1, 2, 1, 1, 44, 52, 19, 60, 37, 15, 2, 11, 3, 13, 0, 18, 4, 42, 11, 5, + 42, 2, 0, 1, 50, 2, 60, 38, 60, 39, 0, 0, 0, 0, 1, 0, 0, 0, 35, 0, + 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 6, 2, 0, 0, 0, 5,115,101,108, +102, 0, 2, 0, 0, 0, 9,105,110,109,111,100,117,108,101, 0, 2, 0, 0, 0, + 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 32, 32,108,117, 97, 95,112,117, +115,104,110,105,108, 40, 41, 59, 32,108,117, 97, 95,115,101,116,103,108,111, 98, + 97,108, 40, 34, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, + 4, 34, 41, 59, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, + 42, 0, 0, 0, 12, 64,100,101,102,105,110,101, 46,108,117, 97, 0, 0, 0, 0, + 72, 6, 3, 60, 43, 15, 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 44, 15, 2, 13, + 1, 11, 4, 42, 13, 0, 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 45, 15, 2, 13, + 1, 11, 8, 42, 13, 0, 18, 9, 42, 11, 7, 42, 2, 0, 1, 60, 46, 15, 2, 13, + 1, 11, 10, 42, 13, 2, 42, 2, 0, 1, 60, 47, 0, 0, 0, 0, 3, 0, 0, 0, + 42, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 42, 0, 0, 0, 6,105,100, +101,110,116, 0, 0, 0, 0, 42, 0, 0, 0, 6, 99,108,111,115,101, 0, 0, 0, + 0, 11, 2, 0, 0, 0, 6,105,100,101,110,116, 0, 2, 0, 0, 0, 6, 99,108, +111,115,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, 8, + 68,101,102,105,110,101,123, 0, 2, 0, 0, 0, 10, 32,110, 97,109,101, 32, 61, + 32, 39, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,110, 97, +109,101, 0, 2, 0, 0, 0, 3, 39, 44, 0, 2, 0, 0, 0, 11, 32,108,110, 97, +109,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, + 0, 0, 2,125, 0, 2, 0, 0, 0, 8, 95, 68,101,102,105,110,101, 0, 4, 0, + 0, 0, 51, 0, 0, 0, 12, 64,100,101,102,105,110,101, 46,108,117, 97, 0, 0, + 0, 0, 64, 4, 1, 60, 52, 13, 0, 11, 1, 15, 2, 26, 60, 53, 15, 3, 13, 0, + 15, 4, 2, 0, 2, 60, 55, 13, 0, 18, 5, 11, 6, 32, 52, 11, 60, 56, 15, 7, + 11, 8, 2, 0, 1, 50, 2, 60, 57, 60, 59, 15, 9, 13, 0, 2, 0, 1, 60, 60, + 13, 0, 1, 1, 60, 61, 0, 0, 0, 0, 1, 0, 0, 0, 51, 0, 0, 0, 2,116, + 0, 0, 0, 0, 10, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6, 95, 98, 97, +115,101, 0, 2, 0, 0, 0, 12, 99,108, 97,115,115, 68,101,102,105,110,101, 0, + 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108, +117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, + 0, 1, 0, 2, 0, 0, 0, 6,101,114,114,111,114, 0, 2, 0, 0, 0, 16, 35, +105,110,118, 97,108,105,100, 32,100,101,102,105,110,101, 0, 2, 0, 0, 0, 7, + 97,112,112,101,110,100, 0, 2, 0, 0, 0, 7, 68,101,102,105,110,101, 0, 4, + 0, 0, 0, 65, 0, 0, 0, 12, 64,100,101,102,105,110,101, 46,108,117, 97, 0, + 0, 0, 0, 54, 9, 1, 60, 66, 15, 2, 13, 0, 11, 3, 2, 1, 2, 60, 67, 15, + 4, 22, 2, 60, 68, 11, 5, 13, 1, 7, 1, 16, 11, 6, 60, 69, 13, 1, 7, 2, + 16, 46, 5, 13, 1, 7, 1, 16, 30, 1, 60, 70, 3, 2, 1, 60, 71, 0, 0, 0, + 0, 2, 0, 0, 0, 65, 0, 0, 0, 2,110, 0, 0, 0, 0, 66, 0, 0, 0, 2, +116, 0, 0, 0, 0, 7, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 2,116, 0, + 2, 0, 0, 0, 6,115,112,108,105,116, 0, 2, 0, 0, 0, 2, 64, 0, 2, 0, + 0, 0, 8, 95, 68,101,102,105,110,101, 0, 2, 0, 0, 0, 5,110, 97,109,101, + 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, +}; + +/* enumerate.lo */ +static char B10[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 15, 64,101,110,117,109,101, +114, 97,116,101, 46,108,117, 97, 0, 0, 0, 0, 69, 3, 0, 60, 19, 22, 1, 60, + 20, 11, 1, 15, 2, 30, 0, 60, 21, 25, 0, 60, 22, 15, 3, 15, 0, 15, 4, 2, + 0, 2, 60, 25, 15, 0, 11, 5, 11, 6, 26, 60, 42, 15, 0, 11, 7, 11, 8, 26, + 60, 53, 15, 0, 11, 9, 11, 10, 26, 60, 64, 11, 12, 25, 11, 60, 73, 11, 14, 25, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 15, 2, 0, 0, 0, 15, 99,108, 97,115,115, + 69,110,117,109,101,114, 97,116,101, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, + 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, 70,101, 97,116,117,114,101, 0, 2, + 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, + 97, 95,116, 97,103, 0, 2, 0, 0, 0, 9,114,101,103,105,115,116,101,114, 0, + 4, 0, 0, 0, 25, 0, 0, 0, 15, 64,101,110,117,109,101,114, 97,116,101, 46, +108,117, 97, 0, 0, 0, 0,179, 7, 1, 60, 26, 13, 0, 20, 2, 2, 1, 1, 46, + 7, 13, 0, 20, 3, 2, 1, 1, 60, 27, 7, 1, 50,141, 60, 29, 13, 1, 52, 93, + 60, 30, 13, 0, 20, 2, 2, 1, 1, 52, 43, 60, 31, 15, 5, 11, 6, 13, 1, 42, + 11, 7, 42, 13, 0, 18, 8, 13, 2, 16, 42, 11, 9, 42, 13, 1, 42, 11, 10, 42, + 13, 0, 13, 2, 16, 42, 11, 11, 42, 2, 0, 1, 50, 37, 60, 33, 15, 5, 11, 6, + 13, 1, 42, 11, 7, 42, 13, 0, 18, 8, 13, 2, 16, 42, 11, 9, 42, 13, 0, 13, + 2, 16, 42, 11, 11, 42, 2, 0, 1, 60, 34, 50, 31, 60, 36, 15, 5, 11, 12, 13, + 0, 18, 8, 13, 2, 16, 42, 11, 9, 42, 13, 0, 13, 2, 16, 42, 11, 11, 42, 2, + 0, 1, 60, 37, 60, 38, 13, 2, 7, 1, 37, 23, 2, 60, 39, 60, 28, 13, 0, 13, + 2, 16, 54,150, 60, 40, 0, 0, 0, 0, 3, 0, 0, 0, 25, 0, 0, 0, 5,115, +101,108,102, 0, 0, 0, 0, 26, 0, 0, 0, 2,112, 0, 0, 0, 0, 27, 0, 0, + 0, 2,105, 0, 0, 0, 0, 13, 2, 0, 0, 0, 2,112, 0, 2, 0, 0, 0, 5, +115,101,108,102, 0, 2, 0, 0, 0, 8,105,110, 99,108, 97,115,115, 0, 2, 0, + 0, 0, 9,105,110,109,111,100,117,108,101, 0, 2, 0, 0, 0, 2,105, 0, 2, + 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 18, 32,116,111,108, +117, 97, 95, 99,111,110,115,116, 97,110,116, 40, 34, 0, 2, 0, 0, 0, 4, 34, + 44, 34, 0, 2, 0, 0, 0, 7,108,110, 97,109,101,115, 0, 2, 0, 0, 0, 3, + 34, 44, 0, 2, 0, 0, 0, 3, 58, 58, 0, 2, 0, 0, 0, 3, 41, 59, 0, 2, + 0, 0, 0, 23, 32,116,111,108,117, 97, 95, 99,111,110,115,116, 97,110,116, 40, + 78, 85, 76, 76, 44, 34, 0, 2, 0, 0, 0, 11,117,110,114,101,103,105,115,116, +101,114, 0, 4, 0, 0, 0, 42, 0, 0, 0, 15, 64,101,110,117,109,101,114, 97, +116,101, 46,108,117, 97, 0, 0, 0, 0, 83, 6, 1, 60, 43, 13, 0, 20, 1, 2, + 1, 1, 4, 0, 32, 48, 10, 13, 0, 20, 2, 2, 1, 1, 4, 0, 32, 52, 50, 60, + 44, 7, 1, 50, 31, 60, 46, 15, 4, 11, 5, 13, 0, 18, 6, 13, 1, 16, 42, 11, + 7, 42, 2, 0, 1, 60, 47, 13, 1, 7, 1, 37, 23, 1, 60, 48, 60, 45, 13, 0, + 13, 1, 16, 54, 40, 5, 1, 50, 2, 60, 49, 60, 50, 0, 0, 0, 0, 3, 0, 0, + 0, 42, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 44, 0, 0, 0, 2,105, + 0, 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 8, 2, 0, 0, 0, 5,115,101, +108,102, 0, 2, 0, 0, 0, 8,105,110, 99,108, 97,115,115, 0, 2, 0, 0, 0, + 9,105,110,109,111,100,117,108,101, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, + 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 32, 32,108,117, 97, 95,112, +117,115,104,110,105,108, 40, 41, 59, 32,108,117, 97, 95,115,101,116,103,108,111, + 98, 97,108, 40, 34, 0, 2, 0, 0, 0, 7,108,110, 97,109,101,115, 0, 2, 0, + 0, 0, 4, 34, 41, 59, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, + 0, 0, 53, 0, 0, 0, 15, 64,101,110,117,109,101,114, 97,116,101, 46,108,117, + 97, 0, 0, 0, 0, 90, 8, 3, 60, 54, 15, 2, 13, 1, 11, 3, 42, 2, 0, 1, + 60, 55, 7, 1, 50, 43, 60, 57, 15, 2, 13, 1, 11, 6, 42, 13, 0, 13, 3, 16, + 42, 11, 7, 42, 13, 0, 18, 8, 13, 3, 16, 42, 11, 9, 42, 2, 0, 1, 60, 58, + 13, 3, 7, 1, 37, 23, 3, 60, 59, 60, 56, 13, 0, 13, 3, 16, 54, 52, 60, 60, + 15, 2, 13, 1, 11, 10, 42, 13, 2, 42, 2, 0, 1, 60, 61, 0, 0, 0, 0, 4, + 0, 0, 0, 53, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 53, 0, 0, 0, + 6,105,100,101,110,116, 0, 0, 0, 0, 53, 0, 0, 0, 6, 99,108,111,115,101, + 0, 0, 0, 0, 55, 0, 0, 0, 2,105, 0, 0, 0, 0, 11, 2, 0, 0, 0, 6, +105,100,101,110,116, 0, 2, 0, 0, 0, 6, 99,108,111,115,101, 0, 2, 0, 0, + 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, 11, 69,110,117,109,101,114, 97, +116,101,123, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 5,115,101,108,102, + 0, 2, 0, 0, 0, 3, 32, 39, 0, 2, 0, 0, 0, 3, 39, 40, 0, 2, 0, 0, + 0, 7,108,110, 97,109,101,115, 0, 2, 0, 0, 0, 3, 41, 44, 0, 2, 0, 0, + 0, 2,125, 0, 2, 0, 0, 0, 11, 95, 69,110,117,109,101,114, 97,116,101, 0, + 4, 0, 0, 0, 64, 0, 0, 0, 15, 64,101,110,117,109,101,114, 97,116,101, 46, +108,117, 97, 0, 0, 0, 0, 40, 4, 1, 60, 65, 13, 0, 11, 1, 15, 2, 26, 60, + 66, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60, 67, 15, 5, 13, 0, 2, 0, 1, 60, + 68, 13, 0, 1, 1, 60, 69, 0, 0, 0, 0, 1, 0, 0, 0, 64, 0, 0, 0, 2, +116, 0, 0, 0, 0, 6, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6, 95, 98, + 97,115,101, 0, 2, 0, 0, 0, 15, 99,108, 97,115,115, 69,110,117,109,101,114, + 97,116,101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, + 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 7, 97,112,112,101, +110,100, 0, 2, 0, 0, 0, 10, 69,110,117,109,101,114, 97,116,101, 0, 4, 0, + 0, 0, 73, 0, 0, 0, 15, 64,101,110,117,109,101,114, 97,116,101, 46,108,117, + 97, 0, 0, 0, 0,200, 9, 1, 60, 74, 15, 2, 15, 3, 13, 0, 7, 2, 9, 2, + 2, 1, 3, 11, 4, 2, 1, 2, 60, 75, 7, 1, 60, 76, 22, 1, 11, 7, 7, 0, + 30, 0, 50, 55, 60, 78, 15, 2, 13, 1, 13, 2, 16, 11, 9, 2, 1, 2, 60, 79, + 13, 3, 11, 7, 13, 3, 18, 7, 7, 1, 37, 26, 60, 80, 13, 3, 13, 3, 18, 7, + 13, 4, 7, 1, 16, 26, 60, 81, 13, 2, 7, 1, 37, 23, 2, 5, 1, 60, 82, 60, + 77, 13, 1, 13, 2, 16, 54, 64, 60, 84, 7, 1, 23, 2, 60, 85, 13, 3, 11, 10, + 22, 0, 26, 50, 60, 60, 87, 15, 2, 13, 3, 13, 2, 16, 11, 11, 2, 1, 2, 60, + 88, 13, 3, 13, 2, 13, 4, 7, 1, 16, 26, 60, 89, 13, 3, 18, 10, 13, 2, 13, + 4, 7, 2, 16, 46, 5, 13, 4, 7, 1, 16, 26, 60, 90, 13, 2, 7, 1, 37, 23, + 2, 5, 1, 60, 91, 60, 86, 13, 3, 13, 2, 16, 54, 69, 60, 92, 15, 12, 13, 3, + 3, 4, 1, 60, 93, 0, 0, 0, 0, 8, 0, 0, 0, 73, 0, 0, 0, 2, 98, 0, + 0, 0, 0, 74, 0, 0, 0, 2,116, 0, 0, 0, 0, 75, 0, 0, 0, 2,105, 0, + 0, 0, 0, 76, 0, 0, 0, 2,101, 0, 0, 0, 0, 78, 0, 0, 0, 3,116,116, + 0, 0, 0, 0, 81, 0, 0, 0, 0, 0, 0, 0, 87, 0, 0, 0, 2,116, 0, 0, + 0, 0, 90, 0, 0, 0, 0, 0, 0, 0, 13, 2, 0, 0, 0, 2, 98, 0, 2, 0, + 0, 0, 2,116, 0, 2, 0, 0, 0, 6,115,112,108,105,116, 0, 2, 0, 0, 0, + 7,115,116,114,115,117, 98, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 2, +105, 0, 2, 0, 0, 0, 2,101, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, + 3,116,116, 0, 2, 0, 0, 0, 2, 61, 0, 2, 0, 0, 0, 7,108,110, 97,109, +101,115, 0, 2, 0, 0, 0, 2, 64, 0, 2, 0, 0, 0, 11, 95, 69,110,117,109, +101,114, 97,116,101, 0, +}; + +/* variable.lo */ +static char B11[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 14, 64,118, 97,114,105, 97, + 98,108,101, 46,108,117, 97, 0, 0, 0, 0, 87, 3, 0, 60, 18, 22, 1, 60, 19, + 11, 1, 15, 2, 30, 0, 60, 20, 25, 0, 60, 22, 15, 3, 15, 0, 15, 4, 2, 0, + 2, 60, 25, 15, 0, 11, 5, 11, 6, 26, 60, 37, 15, 0, 11, 7, 11, 8, 26, 60, + 48, 15, 0, 11, 9, 11, 10, 26, 60,154, 15, 0, 11, 11, 11, 12, 26, 60,171, 15, + 0, 11, 13, 11, 14, 26, 60,179, 11, 16, 25, 15, 60,188, 11, 18, 25, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 19, 2, 0, 0, 0, 14, 99,108, 97,115,115, 86, 97,114, +105, 97, 98,108,101, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, + 0, 17, 99,108, 97,115,115, 68,101, 99,108, 97,114, 97,116,105,111,110, 0, 2, + 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, + 97, 95,116, 97,103, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, + 0, 25, 0, 0, 0, 14, 64,118, 97,114,105, 97, 98,108,101, 46,108,117, 97, 0, + 0, 0, 0,152, 6, 3, 60, 26, 15, 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 27, + 15, 2, 13, 1, 11, 4, 42, 13, 0, 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 28, + 15, 2, 13, 1, 11, 8, 42, 13, 0, 18, 9, 42, 11, 7, 42, 2, 0, 1, 60, 29, + 15, 2, 13, 1, 11, 10, 42, 13, 0, 18, 11, 42, 11, 7, 42, 2, 0, 1, 60, 30, + 15, 2, 13, 1, 11, 12, 42, 13, 0, 18, 13, 42, 11, 7, 42, 2, 0, 1, 60, 31, + 15, 2, 13, 1, 11, 14, 42, 13, 0, 18, 15, 42, 11, 7, 42, 2, 0, 1, 60, 32, + 15, 2, 13, 1, 11, 16, 42, 13, 0, 18, 17, 42, 11, 7, 42, 2, 0, 1, 60, 33, + 15, 2, 13, 1, 11, 18, 42, 13, 2, 42, 2, 0, 1, 60, 34, 0, 0, 0, 0, 3, + 0, 0, 0, 25, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 25, 0, 0, 0, + 6,105,100,101,110,116, 0, 0, 0, 0, 25, 0, 0, 0, 6, 99,108,111,115,101, + 0, 0, 0, 0, 19, 2, 0, 0, 0, 6,105,100,101,110,116, 0, 2, 0, 0, 0, + 6, 99,108,111,115,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 2, 0, + 0, 0, 10, 86, 97,114,105, 97, 98,108,101,123, 0, 2, 0, 0, 0, 10, 32,109, +111,100, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, + 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 3, 39, 44, 0, 2, 0, 0, 0, 10, + 32,116,121,112,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,116,121,112,101, 0, + 2, 0, 0, 0, 10, 32,112,116,114, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4, +112,116,114, 0, 2, 0, 0, 0, 10, 32,110, 97,109,101, 32, 61, 32, 39, 0, 2, + 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 10, 32,100,101,102, 32, 32, + 61, 32, 39, 0, 2, 0, 0, 0, 4,100,101,102, 0, 2, 0, 0, 0, 10, 32,114, +101,116, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4,114,101,116, 0, 2, 0, 0, + 0, 2,125, 0, 2, 0, 0, 0, 9,103,101,116,118, 97,108,117,101, 0, 4, 0, + 0, 0, 37, 0, 0, 0, 14, 64,118, 97,114,105, 97, 98,108,101, 46,108,117, 97, + 0, 0, 0, 0, 60, 5, 3, 60, 38, 13, 1, 48, 2, 13, 2, 52, 16, 60, 39, 13, + 1, 11, 2, 42, 13, 0, 18, 4, 42, 1, 3, 50, 29, 60, 40, 13, 1, 52, 13, 60, + 41, 11, 5, 13, 0, 18, 4, 42, 1, 3, 50, 10, 60, 43, 13, 0, 18, 4, 1, 3, + 60, 44, 60, 45, 0, 0, 0, 0, 3, 0, 0, 0, 37, 0, 0, 0, 5,115,101,108, +102, 0, 0, 0, 0, 37, 0, 0, 0, 6, 99,108, 97,115,115, 0, 0, 0, 0, 37, + 0, 0, 0, 7,115,116, 97,116,105, 99, 0, 0, 0, 0, 6, 2, 0, 0, 0, 6, + 99,108, 97,115,115, 0, 2, 0, 0, 0, 7,115,116, 97,116,105, 99, 0, 2, 0, + 0, 0, 3, 58, 58, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, + 5,110, 97,109,101, 0, 2, 0, 0, 0, 7,115,101,108,102, 45, 62, 0, 2, 0, + 0, 0, 8,115,117,112, 99,111,100,101, 0, 4, 0, 0, 0, 48, 0, 0, 0, 14, + 64,118, 97,114,105, 97, 98,108,101, 46,108,117, 97, 0, 0, 0, 3,189, 17, 1, + 60, 49, 13, 0, 20, 2, 2, 1, 1, 60, 52, 13, 1, 52, 21, 60, 53, 15, 3, 11, + 4, 13, 0, 18, 5, 11, 6, 13, 1, 11, 7, 2, 0, 5, 50, 17, 60, 55, 15, 3, + 11, 4, 13, 0, 18, 5, 11, 7, 2, 0, 3, 60, 56, 60, 57, 13, 0, 11, 8, 13, + 0, 20, 9, 11, 10, 2, 1, 2, 26, 60, 58, 15, 3, 11, 11, 13, 0, 18, 8, 11, + 12, 2, 0, 3, 60, 59, 15, 3, 11, 13, 2, 0, 1, 60, 62, 15, 16, 13, 0, 18, + 17, 11, 18, 2, 3, 2, 60, 63, 13, 1, 48, 5, 13, 4, 4, 0, 32, 52, 39, 60, + 64, 15, 3, 11, 19, 13, 1, 11, 20, 11, 21, 2, 0, 4, 60, 65, 15, 3, 11, 22, + 13, 1, 11, 23, 2, 0, 3, 60, 66, 15, 3, 11, 24, 2, 0, 1, 50, 35, 60, 67, + 13, 4, 52, 27, 60, 68, 13, 0, 11, 17, 15, 16, 13, 0, 18, 17, 11, 25, 2, 3, + 2, 27, 2, 23, 3, 23, 3, 5, 2, 50, 2, 60, 69, 60, 73, 13, 1, 48, 5, 13, + 4, 4, 0, 32, 52, 19, 60, 74, 15, 3, 11, 26, 13, 0, 18, 5, 42, 11, 27, 42, + 2, 0, 1, 50, 2, 60, 75, 60, 78, 15, 29, 13, 0, 18, 30, 2, 1, 1, 60, 79, + 13, 5, 11, 31, 32, 52, 32, 60, 80, 15, 3, 11, 32, 13, 5, 42, 11, 33, 42, 13, + 0, 20, 34, 13, 1, 13, 4, 2, 1, 3, 42, 11, 35, 42, 2, 0, 1, 50,124, 60, + 81, 13, 5, 52, 32, 60, 82, 15, 3, 11, 32, 13, 5, 42, 11, 22, 42, 13, 0, 20, + 34, 13, 1, 13, 4, 2, 1, 3, 42, 11, 35, 42, 2, 0, 1, 50, 86, 60, 84, 13, + 0, 18, 36, 11, 37, 32, 46, 7, 13, 0, 18, 36, 11, 38, 32, 52, 32, 60, 85, 15, + 3, 11, 39, 13, 0, 20, 34, 13, 1, 13, 4, 2, 1, 3, 42, 11, 40, 42, 13, 0, + 18, 41, 11, 35, 2, 0, 3, 50, 32, 60, 87, 15, 3, 11, 42, 13, 0, 20, 34, 13, + 1, 13, 4, 2, 1, 3, 42, 11, 40, 42, 13, 0, 18, 41, 11, 35, 2, 0, 3, 60, + 88, 60, 89, 60, 90, 15, 3, 11, 43, 2, 0, 1, 60, 91, 15, 3, 11, 44, 2, 0, + 1, 60, 94, 15, 16, 13, 0, 18, 17, 11, 45, 2, 1, 2, 44, 51, 2, 0, 60, 95, + 13, 1, 52, 21, 60, 96, 15, 3, 11, 46, 13, 0, 18, 5, 11, 6, 13, 1, 11, 7, + 2, 0, 5, 50, 17, 60, 98, 15, 3, 11, 46, 13, 0, 18, 5, 11, 7, 2, 0, 3, + 60, 99, 60,100, 13, 0, 11, 47, 13, 0, 20, 9, 11, 48, 2, 1, 2, 26, 60,101, + 15, 3, 11, 11, 13, 0, 18, 47, 11, 12, 2, 0, 3, 60,102, 15, 3, 11, 13, 2, + 0, 1, 60,105, 7, 1, 60,106, 13, 1, 48, 5, 13, 4, 4, 0, 32, 52, 65, 60, +107, 15, 3, 11, 19, 13, 1, 11, 20, 11, 21, 2, 0, 4, 60,108, 15, 3, 11, 22, + 13, 1, 11, 23, 2, 0, 3, 60,109, 15, 3, 11, 24, 2, 0, 1, 60,111, 15, 3, + 11, 26, 13, 0, 18, 5, 42, 11, 27, 42, 2, 0, 1, 60,112, 13, 6, 7, 1, 37, + 23, 6, 50, 44, 60,113, 13, 4, 52, 36, 60,114, 13, 0, 11, 17, 15, 16, 13, 0, + 18, 17, 11, 25, 2, 3, 2, 27, 2, 23, 3, 23, 3, 5, 2, 60,115, 13, 6, 7, + 1, 37, 23, 6, 50, 2, 60,116, 60,119, 15, 3, 11, 50, 13, 0, 20, 51, 13, 6, + 2, 1, 2, 42, 11, 52, 42, 2, 0, 1, 60,120, 15, 3, 11, 53, 2, 0, 1, 60, +123, 11, 38, 60,124, 13, 0, 18, 36, 11, 38, 31, 52, 4, 11, 20, 23, 7, 60,125, + 15, 3, 11, 19, 2, 0, 1, 60,126, 13, 1, 48, 2, 13, 4, 52, 19, 60,127, 15, + 3, 13, 1, 11, 54, 42, 13, 0, 18, 5, 42, 2, 0, 1, 50, 35, 60,128, 13, 1, + 52, 16, 60,129, 15, 3, 11, 55, 13, 0, 18, 5, 42, 2, 0, 1, 50, 13, 60,131, + 15, 3, 13, 0, 18, 5, 2, 0, 1, 60,132, 60,133, 15, 29, 13, 0, 18, 30, 2, + 1, 1, 60,134, 15, 3, 11, 56, 2, 0, 1, 60,135, 13, 8, 44, 48, 5, 13, 7, + 11, 38, 32, 52, 7, 15, 3, 11, 20, 2, 0, 1, 60,136, 15, 3, 11, 57, 13, 0, + 18, 17, 13, 0, 18, 30, 2, 0, 3, 60,137, 13, 8, 44, 52, 11, 60,138, 15, 3, + 11, 20, 2, 0, 1, 50, 2, 60,139, 60,140, 15, 3, 11, 58, 2, 0, 1, 60,141, + 7, 0, 60,142, 13, 0, 18, 59, 11, 38, 31, 52, 6, 13, 0, 18, 59, 23, 9, 60, +143, 13, 8, 52, 24, 60,144, 15, 3, 11, 60, 13, 8, 42, 11, 22, 13, 6, 11, 40, + 13, 9, 11, 61, 2, 0, 6, 50, 19, 60,146, 15, 3, 11, 62, 13, 6, 11, 40, 13, + 9, 11, 61, 2, 0, 5, 60,147, 60,148, 15, 3, 11, 43, 2, 0, 1, 60,149, 15, + 3, 11, 44, 2, 0, 1, 5, 4, 50, 2, 60,150, 60,152, 0, 0, 0, 0, 14, 0, + 0, 0, 48, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 49, 0, 0, 0, 6, + 99,108, 97,115,115, 0, 0, 0, 0, 62, 0, 0, 0, 2, 95, 0, 0, 0, 0, 62, + 0, 0, 0, 2, 95, 0, 0, 0, 0, 62, 0, 0, 0, 7,115,116, 97,116,105, 99, + 0, 0, 0, 0, 78, 0, 0, 0, 2,116, 0, 0, 0, 0,105, 0, 0, 0, 5,110, + 97,114,103, 0, 0, 0, 0,123, 0, 0, 0, 4,112,116,114, 0, 0, 0, 0,133, + 0, 0, 0, 2,116, 0, 0, 0, 0,141, 0, 0, 0, 4,100,101,102, 0, 0, 0, + 0,149, 0, 0, 0, 0, 0, 0, 0,149, 0, 0, 0, 0, 0, 0, 0,149, 0, 0, + 0, 0, 0, 0, 0,149, 0, 0, 0, 0, 0, 0, 0, 63, 2, 0, 0, 0, 6, 99, +108, 97,115,115, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8, +105,110, 99,108, 97,115,115, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, + 2, 0, 0, 0, 17, 47, 42, 32,103,101,116, 32,102,117,110, 99,116,105,111,110, + 58, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 11, 32,111,102, + 32, 99,108, 97,115,115, 32, 0, 2, 0, 0, 0, 4, 32, 42, 47, 0, 2, 0, 0, + 0, 9, 99,103,101,116,110, 97,109,101, 0, 2, 0, 0, 0, 10, 99,102,117,110, + 99,110, 97,109,101, 0, 2, 0, 0, 0, 11,116,111,108,117, 97, 73, 95,103,101, +116, 0, 2, 0, 0, 0, 12,115,116, 97,116,105, 99, 32,118,111,105,100, 0, 2, + 0, 0, 0, 7, 40,118,111,105,100, 41, 0, 2, 0, 0, 0, 2,123, 0, 2, 0, + 0, 0, 2, 95, 0, 2, 0, 0, 0, 7,115,116, 97,116,105, 99, 0, 2, 0, 0, + 0, 8,115,116,114,102,105,110,100, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, + 0, 0, 0, 13, 94, 37,115, 42, 40,115,116, 97,116,105, 99, 41, 0, 2, 0, 0, + 0, 2, 32, 0, 2, 0, 0, 0, 2, 42, 0, 2, 0, 0, 0, 8,115,101,108,102, + 32, 61, 32, 0, 2, 0, 0, 0, 2, 40, 0, 2, 0, 0, 0, 4, 42, 41, 32, 0, + 2, 0, 0, 0, 24,116,111,108,117, 97, 95,103,101,116,117,115,101,114,116,121, +112,101, 40, 49, 44, 48, 41, 59, 0, 2, 0, 0, 0, 20, 94, 37,115, 42,115,116, + 97,116,105, 99, 37,115, 37,115, 42, 40, 46, 42, 41, 0, 2, 0, 0, 0, 65, 32, + 32,105,102, 32, 40, 33,115,101,108,102, 41, 32,116,111,108,117, 97, 95,101,114, +114,111,114, 40, 34,105,110,118, 97,108,105,100, 32, 39,115,101,108,102, 39, 32, +105,110, 32, 97, 99, 99,101,115,115,105,110,103, 32,118, 97,114,105, 97, 98,108, +101, 32, 39, 0, 2, 0, 0, 0, 5, 39, 34, 41, 59, 0, 2, 0, 0, 0, 2,116, + 0, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, 0, 5,116, +121,112,101, 0, 2, 0, 0, 0, 7,110,117,109, 98,101,114, 0, 2, 0, 0, 0, + 13, 32, 32,116,111,108,117, 97, 95,112,117,115,104, 0, 2, 0, 0, 0, 10, 40, + 40,100,111,117, 98,108,101, 41, 0, 2, 0, 0, 0, 9,103,101,116,118, 97,108, +117,101, 0, 2, 0, 0, 0, 3, 41, 59, 0, 2, 0, 0, 0, 4,112,116,114, 0, + 2, 0, 0, 0, 2, 38, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 30, 32, 32, +116,111,108,117, 97, 95,112,117,115,104,117,115,101,114,116,121,112,101, 40, 40, +118,111,105,100, 42, 41, 38, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 4, +116, 97,103, 0, 2, 0, 0, 0, 29, 32, 32,116,111,108,117, 97, 95,112,117,115, +104,117,115,101,114,116,121,112,101, 40, 40,118,111,105,100, 42, 41, 0, 2, 0, + 0, 0, 2,125, 0, 2, 0, 0, 0, 2, 10, 0, 2, 0, 0, 0, 6, 99,111,110, +115,116, 0, 2, 0, 0, 0, 17, 47, 42, 32,115,101,116, 32,102,117,110, 99,116, +105,111,110, 58, 0, 2, 0, 0, 0, 9, 99,115,101,116,110, 97,109,101, 0, 2, + 0, 0, 0, 11,116,111,108,117, 97, 73, 95,115,101,116, 0, 2, 0, 0, 0, 5, +110, 97,114,103, 0, 2, 0, 0, 0, 8, 32, 32,105,102, 32, 40, 33, 0, 2, 0, + 0, 0, 13,111,117,116, 99,104,101, 99,107,116,121,112,101, 0, 2, 0, 0, 0, + 2, 41, 0, 2, 0, 0, 0, 58, 32, 32, 32,116,111,108,117, 97, 95,101,114,114, +111,114, 40, 34, 35,118,105,110,118, 97,108,105,100, 32,116,121,112,101, 32,105, +110, 32,118, 97,114,105, 97, 98,108,101, 32, 97,115,115,105,103,110,109,101,110, +116, 46, 34, 41, 59, 0, 2, 0, 0, 0, 3, 58, 58, 0, 2, 0, 0, 0, 7,115, +101,108,102, 45, 62, 0, 2, 0, 0, 0, 4, 32, 61, 32, 0, 2, 0, 0, 0, 3, + 40, 40, 0, 2, 0, 0, 0, 3, 41, 32, 0, 2, 0, 0, 0, 4,100,101,102, 0, + 2, 0, 0, 0, 10,116,111,108,117, 97, 95,103,101,116, 0, 2, 0, 0, 0, 4, + 41, 41, 59, 0, 2, 0, 0, 0, 19,116,111,108,117, 97, 95,103,101,116,117,115, +101,114,116,121,112,101, 40, 0, 2, 0, 0, 0, 9,114,101,103,105,115,116,101, +114, 0, 4, 0, 0, 0,154, 0, 0, 0, 14, 64,118, 97,114,105, 97, 98,108,101, + 46,108,117, 97, 0, 0, 0, 0,185, 5, 1, 60,155, 13, 0, 20, 2, 2, 1, 1, + 46, 7, 13, 0, 20, 3, 2, 1, 1, 60,156, 13, 1, 52, 84, 60,157, 13, 0, 18, + 4, 52, 41, 60,158, 15, 5, 11, 6, 13, 1, 42, 11, 7, 42, 13, 0, 18, 8, 42, + 11, 9, 42, 13, 0, 18, 10, 42, 11, 11, 42, 13, 0, 18, 4, 42, 11, 12, 42, 2, + 0, 1, 50, 33, 60,160, 15, 5, 11, 6, 13, 1, 42, 11, 7, 42, 13, 0, 18, 8, + 42, 11, 9, 42, 13, 0, 18, 10, 42, 11, 13, 42, 2, 0, 1, 60,161, 50, 72, 60, +163, 13, 0, 18, 4, 52, 35, 60,164, 15, 5, 11, 14, 13, 0, 18, 8, 42, 11, 9, + 42, 13, 0, 18, 10, 42, 11, 11, 42, 13, 0, 18, 4, 42, 11, 12, 42, 2, 0, 1, + 50, 27, 60,166, 15, 5, 11, 14, 13, 0, 18, 8, 42, 11, 9, 42, 13, 0, 18, 10, + 42, 11, 13, 42, 2, 0, 1, 60,167, 60,168, 60,169, 0, 0, 0, 0, 2, 0, 0, + 0,154, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0,155, 0, 0, 0, 7,112, + 97,114,101,110,116, 0, 0, 0, 0, 15, 2, 0, 0, 0, 7,112, 97,114,101,110, +116, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8,105,110, 99, +108, 97,115,115, 0, 2, 0, 0, 0, 9,105,110,109,111,100,117,108,101, 0, 2, + 0, 0, 0, 9, 99,115,101,116,110, 97,109,101, 0, 2, 0, 0, 0, 7,111,117, +116,112,117,116, 0, 2, 0, 0, 0, 18, 32,116,111,108,117, 97, 95,116, 97, 98, +108,101,118, 97,114, 40, 34, 0, 2, 0, 0, 0, 4, 34, 44, 34, 0, 2, 0, 0, + 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 3, 34, 44, 0, 2, 0, 0, 0, + 9, 99,103,101,116,110, 97,109,101, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, + 0, 3, 41, 59, 0, 2, 0, 0, 0, 8, 44, 78, 85, 76, 76, 41, 59, 0, 2, 0, + 0, 0, 19, 32,116,111,108,117, 97, 95,103,108,111, 98, 97,108,118, 97,114, 40, + 34, 0, 2, 0, 0, 0, 11,117,110,114,101,103,105,115,116,101,114, 0, 4, 0, + 0, 0,171, 0, 0, 0, 14, 64,118, 97,114,105, 97, 98,108,101, 46,108,117, 97, + 0, 0, 0, 0, 52, 4, 1, 60,172, 13, 0, 20, 1, 2, 1, 1, 4, 0, 32, 48, + 10, 13, 0, 20, 2, 2, 1, 1, 4, 0, 32, 52, 19, 60,173, 15, 3, 11, 4, 13, + 0, 18, 5, 42, 11, 6, 42, 2, 0, 1, 50, 2, 60,174, 60,175, 0, 0, 0, 0, + 1, 0, 0, 0,171, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 7, 2, 0, + 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8,105,110, 99,108, 97,115,115, + 0, 2, 0, 0, 0, 9,105,110,109,111,100,117,108,101, 0, 2, 0, 0, 0, 7, +111,117,116,112,117,116, 0, 2, 0, 0, 0, 35, 32,108,117, 97, 95,112,117,115, +104,110,105,108, 40, 41, 59, 32,108,117, 97, 95,114, 97,119,115,101,116,103,108, +111, 98, 97,108, 40, 34, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, + 0, 0, 4, 34, 41, 59, 0, 2, 0, 0, 0, 10, 95, 86, 97,114,105, 97, 98,108, +101, 0, 4, 0, 0, 0,179, 0, 0, 0, 14, 64,118, 97,114,105, 97, 98,108,101, + 46,108,117, 97, 0, 0, 0, 0, 40, 4, 1, 60,180, 13, 0, 11, 1, 15, 2, 26, + 60,181, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60,182, 15, 5, 13, 0, 2, 0, 1, + 60,183, 13, 0, 1, 1, 60,184, 0, 0, 0, 0, 1, 0, 0, 0,179, 0, 0, 0, + 2,116, 0, 0, 0, 0, 6, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6, 95, + 98, 97,115,101, 0, 2, 0, 0, 0, 14, 99,108, 97,115,115, 86, 97,114,105, 97, + 98,108,101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, + 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 7, 97,112,112,101, +110,100, 0, 2, 0, 0, 0, 9, 86, 97,114,105, 97, 98,108,101, 0, 4, 0, 0, + 0,188, 0, 0, 0, 14, 64,118, 97,114,105, 97, 98,108,101, 46,108,117, 97, 0, + 0, 0, 0, 21, 5, 1, 60,189, 15, 1, 15, 2, 13, 0, 11, 3, 2, 1, 2, 3, + 1, 1, 60,190, 0, 0, 0, 0, 1, 0, 0, 0,188, 0, 0, 0, 2,115, 0, 0, + 0, 0, 4, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 10, 95, 86, 97,114,105, + 97, 98,108,101, 0, 2, 0, 0, 0, 12, 68,101, 99,108, 97,114, 97,116,105,111, +110, 0, 2, 0, 0, 0, 4,118, 97,114, 0, +}; + +/* array.lo */ +static char B12[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 11, 64, 97,114,114, 97,121, + 46,108,117, 97, 0, 0, 0, 0, 87, 3, 0, 60, 18, 22, 1, 60, 19, 11, 1, 15, + 2, 30, 0, 60, 20, 25, 0, 60, 22, 15, 3, 15, 0, 15, 4, 2, 0, 2, 60, 25, + 15, 0, 11, 5, 11, 6, 26, 60, 38, 15, 0, 11, 7, 11, 8, 26, 60, 49, 15, 0, + 11, 9, 11, 10, 26, 60,167, 15, 0, 11, 11, 11, 12, 26, 60,184, 15, 0, 11, 13, + 11, 14, 26, 60,192, 11, 16, 25, 15, 60,201, 11, 18, 25, 17, 0, 0, 0, 0, 0, + 0, 0, 0, 19, 2, 0, 0, 0, 11, 99,108, 97,115,115, 65,114,114, 97,121, 0, + 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 17, 99,108, 97,115, +115, 68,101, 99,108, 97,114, 97,116,105,111,110, 0, 2, 0, 0, 0, 7,115,101, +116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, + 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, 25, 0, 0, 0, 11, + 64, 97,114,114, 97,121, 46,108,117, 97, 0, 0, 0, 0,172, 6, 3, 60, 26, 15, + 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 27, 15, 2, 13, 1, 11, 4, 42, 13, 0, + 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 28, 15, 2, 13, 1, 11, 8, 42, 13, 0, + 18, 9, 42, 11, 7, 42, 2, 0, 1, 60, 29, 15, 2, 13, 1, 11, 10, 42, 13, 0, + 18, 11, 42, 11, 7, 42, 2, 0, 1, 60, 30, 15, 2, 13, 1, 11, 12, 42, 13, 0, + 18, 13, 42, 11, 7, 42, 2, 0, 1, 60, 31, 15, 2, 13, 1, 11, 14, 42, 13, 0, + 18, 15, 42, 11, 7, 42, 2, 0, 1, 60, 32, 15, 2, 13, 1, 11, 16, 42, 13, 0, + 18, 17, 42, 11, 7, 42, 2, 0, 1, 60, 33, 15, 2, 13, 1, 11, 18, 42, 13, 0, + 18, 19, 42, 11, 7, 42, 2, 0, 1, 60, 34, 15, 2, 13, 1, 11, 20, 42, 13, 2, + 42, 2, 0, 1, 60, 35, 0, 0, 0, 0, 3, 0, 0, 0, 25, 0, 0, 0, 5,115, +101,108,102, 0, 0, 0, 0, 25, 0, 0, 0, 6,105,100,101,110,116, 0, 0, 0, + 0, 25, 0, 0, 0, 6, 99,108,111,115,101, 0, 0, 0, 0, 21, 2, 0, 0, 0, + 6,105,100,101,110,116, 0, 2, 0, 0, 0, 6, 99,108,111,115,101, 0, 2, 0, + 0, 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, 7, 65,114,114, 97,121,123, + 0, 2, 0, 0, 0, 10, 32,109,111,100, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, + 5,115,101,108,102, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 3, + 39, 44, 0, 2, 0, 0, 0, 10, 32,116,121,112,101, 32, 61, 32, 39, 0, 2, 0, + 0, 0, 5,116,121,112,101, 0, 2, 0, 0, 0, 10, 32,112,116,114, 32, 32, 61, + 32, 39, 0, 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 10, 32,110, 97, +109,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, + 0, 10, 32,100,101,102, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4,100,101,102, + 0, 2, 0, 0, 0, 10, 32,100,105,109, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, + 4,100,105,109, 0, 2, 0, 0, 0, 10, 32,114,101,116, 32, 32, 61, 32, 39, 0, + 2, 0, 0, 0, 4,114,101,116, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, + 9,103,101,116,118, 97,108,117,101, 0, 4, 0, 0, 0, 38, 0, 0, 0, 11, 64, + 97,114,114, 97,121, 46,108,117, 97, 0, 0, 0, 0, 69, 5, 3, 60, 39, 13, 1, + 48, 2, 13, 2, 52, 19, 60, 40, 13, 1, 11, 2, 42, 13, 0, 18, 4, 42, 11, 5, + 42, 1, 3, 50, 35, 60, 41, 13, 1, 52, 16, 60, 42, 11, 6, 13, 0, 18, 4, 42, + 11, 5, 42, 1, 3, 50, 13, 60, 44, 13, 0, 18, 4, 11, 5, 42, 1, 3, 60, 45, + 60, 46, 0, 0, 0, 0, 3, 0, 0, 0, 38, 0, 0, 0, 5,115,101,108,102, 0, + 0, 0, 0, 38, 0, 0, 0, 6, 99,108, 97,115,115, 0, 0, 0, 0, 38, 0, 0, + 0, 7,115,116, 97,116,105, 99, 0, 0, 0, 0, 7, 2, 0, 0, 0, 6, 99,108, + 97,115,115, 0, 2, 0, 0, 0, 7,115,116, 97,116,105, 99, 0, 2, 0, 0, 0, + 3, 58, 58, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,110, + 97,109,101, 0, 2, 0, 0, 0, 15, 91,116,111,108,117, 97, 73, 95,105,110,100, +101,120, 93, 0, 2, 0, 0, 0, 7,115,101,108,102, 45, 62, 0, 2, 0, 0, 0, + 8,115,117,112, 99,111,100,101, 0, 4, 0, 0, 0, 49, 0, 0, 0, 11, 64, 97, +114,114, 97,121, 46,108,117, 97, 0, 0, 0, 4, 21, 17, 1, 60, 50, 13, 0, 20, + 2, 2, 1, 1, 60, 53, 13, 1, 52, 21, 60, 54, 15, 3, 11, 4, 13, 0, 18, 5, + 11, 6, 13, 1, 11, 7, 2, 0, 5, 50, 17, 60, 56, 15, 3, 11, 4, 13, 0, 18, + 5, 11, 7, 2, 0, 3, 60, 57, 60, 58, 13, 0, 11, 8, 13, 0, 20, 9, 11, 10, + 2, 1, 2, 26, 60, 59, 15, 3, 11, 11, 13, 0, 18, 8, 11, 12, 2, 0, 3, 60, + 60, 15, 3, 11, 13, 2, 0, 1, 60, 63, 15, 3, 11, 14, 2, 0, 1, 60, 66, 15, + 17, 13, 0, 18, 18, 11, 19, 2, 3, 2, 60, 67, 13, 1, 48, 5, 13, 4, 4, 0, + 32, 52, 66, 60, 68, 15, 3, 11, 20, 13, 1, 11, 21, 11, 22, 2, 0, 4, 60, 69, + 15, 3, 11, 23, 2, 0, 1, 60, 70, 15, 3, 11, 24, 2, 0, 1, 60, 71, 15, 3, + 11, 25, 2, 0, 1, 60, 72, 15, 3, 11, 26, 13, 1, 11, 27, 2, 0, 3, 60, 73, + 15, 3, 11, 28, 2, 0, 1, 50, 35, 60, 74, 13, 4, 52, 27, 60, 75, 13, 0, 11, + 18, 15, 17, 13, 0, 18, 18, 11, 29, 2, 3, 2, 27, 2, 23, 3, 23, 3, 5, 2, + 50, 2, 60, 76, 60, 79, 15, 3, 11, 30, 2, 0, 1, 60, 80, 15, 3, 11, 31, 2, + 0, 1, 60, 81, 15, 3, 11, 32, 2, 0, 1, 60, 82, 15, 3, 11, 33, 13, 0, 18, + 34, 42, 11, 35, 42, 2, 0, 1, 60, 83, 15, 3, 11, 36, 2, 0, 1, 60, 86, 15, + 38, 13, 0, 18, 39, 2, 1, 1, 60, 87, 13, 5, 11, 40, 32, 52, 32, 60, 88, 15, + 3, 11, 41, 13, 5, 42, 11, 42, 42, 13, 0, 20, 43, 13, 1, 13, 4, 2, 1, 3, + 42, 11, 44, 42, 2, 0, 1, 50,124, 60, 89, 13, 5, 52, 32, 60, 90, 15, 3, 11, + 41, 13, 5, 42, 11, 26, 42, 13, 0, 20, 43, 13, 1, 13, 4, 2, 1, 3, 42, 11, + 44, 42, 2, 0, 1, 50, 86, 60, 92, 13, 0, 18, 45, 11, 46, 32, 46, 7, 13, 0, + 18, 45, 11, 47, 32, 52, 32, 60, 93, 15, 3, 11, 48, 13, 0, 20, 43, 13, 1, 13, + 4, 2, 1, 3, 42, 11, 49, 42, 13, 0, 18, 50, 11, 44, 2, 0, 3, 50, 32, 60, + 95, 15, 3, 11, 51, 13, 0, 20, 43, 13, 1, 13, 4, 2, 1, 3, 42, 11, 49, 42, + 13, 0, 18, 50, 11, 44, 2, 0, 3, 60, 96, 60, 97, 60, 98, 15, 3, 11, 52, 2, + 0, 1, 60, 99, 15, 3, 11, 53, 2, 0, 1, 60,102, 15, 17, 13, 0, 18, 18, 11, + 54, 2, 1, 2, 44, 51, 2, 33, 60,103, 13, 1, 52, 21, 60,104, 15, 3, 11, 55, + 13, 0, 18, 5, 11, 6, 13, 1, 11, 7, 2, 0, 5, 50, 17, 60,106, 15, 3, 11, + 55, 13, 0, 18, 5, 11, 7, 2, 0, 3, 60,107, 60,108, 13, 0, 11, 56, 13, 0, + 20, 9, 11, 57, 2, 1, 2, 26, 60,109, 15, 3, 11, 11, 13, 0, 18, 56, 11, 12, + 2, 0, 3, 60,110, 15, 3, 11, 13, 2, 0, 1, 60,113, 15, 3, 11, 14, 2, 0, + 1, 60,116, 15, 17, 13, 0, 18, 18, 11, 19, 2, 3, 2, 60,117, 13, 1, 48, 5, + 13, 8, 4, 0, 32, 52, 66, 60,118, 15, 3, 11, 20, 13, 1, 11, 21, 11, 22, 2, + 0, 4, 60,119, 15, 3, 11, 23, 2, 0, 1, 60,120, 15, 3, 11, 24, 2, 0, 1, + 60,121, 15, 3, 11, 25, 2, 0, 1, 60,122, 15, 3, 11, 26, 13, 1, 11, 27, 2, + 0, 3, 60,123, 15, 3, 11, 28, 2, 0, 1, 50, 35, 60,124, 13, 8, 52, 27, 60, +125, 13, 0, 11, 18, 15, 17, 13, 0, 18, 18, 11, 29, 2, 3, 2, 27, 2, 23, 7, + 23, 7, 5, 2, 50, 2, 60,126, 60,129, 15, 3, 11, 30, 2, 0, 1, 60,130, 15, + 3, 11, 31, 2, 0, 1, 60,131, 15, 3, 11, 32, 2, 0, 1, 60,132, 15, 3, 11, + 33, 13, 0, 18, 34, 42, 11, 35, 42, 2, 0, 1, 60,133, 15, 3, 11, 36, 2, 0, + 1, 60,136, 11, 47, 60,137, 13, 0, 18, 45, 11, 47, 31, 52, 4, 11, 21, 23, 9, + 60,138, 15, 3, 11, 20, 2, 0, 1, 60,139, 13, 1, 48, 2, 13, 8, 52, 22, 60, +140, 15, 3, 13, 1, 11, 58, 42, 13, 0, 18, 5, 42, 11, 59, 42, 2, 0, 1, 50, + 41, 60,141, 13, 1, 52, 19, 60,142, 15, 3, 11, 60, 13, 0, 18, 5, 42, 11, 59, + 42, 2, 0, 1, 50, 16, 60,144, 15, 3, 13, 0, 18, 5, 11, 59, 42, 2, 0, 1, + 60,145, 60,146, 15, 38, 13, 0, 18, 39, 2, 1, 1, 60,147, 15, 3, 11, 61, 2, + 0, 1, 60,148, 13, 10, 44, 48, 5, 13, 9, 11, 47, 32, 52, 7, 15, 3, 11, 21, + 2, 0, 1, 60,149, 15, 3, 11, 62, 13, 0, 18, 18, 13, 0, 18, 39, 2, 0, 3, + 60,150, 13, 10, 44, 52, 11, 60,151, 15, 3, 11, 21, 2, 0, 1, 50, 2, 60,152, + 60,153, 15, 3, 11, 63, 2, 0, 1, 60,154, 7, 0, 60,155, 13, 0, 18, 64, 11, + 47, 31, 52, 6, 13, 0, 18, 64, 23, 11, 60,156, 13, 10, 52, 20, 60,157, 15, 3, + 11, 65, 13, 10, 42, 11, 66, 13, 11, 11, 67, 2, 0, 4, 50, 15, 60,159, 15, 3, + 11, 68, 13, 11, 11, 67, 2, 0, 3, 60,160, 60,161, 15, 3, 11, 52, 2, 0, 1, + 60,162, 15, 3, 11, 53, 2, 0, 1, 5, 6, 50, 2, 60,163, 60,165, 0, 0, 0, + 0, 18, 0, 0, 0, 49, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 50, 0, + 0, 0, 6, 99,108, 97,115,115, 0, 0, 0, 0, 66, 0, 0, 0, 2, 95, 0, 0, + 0, 0, 66, 0, 0, 0, 2, 95, 0, 0, 0, 0, 66, 0, 0, 0, 7,115,116, 97, +116,105, 99, 0, 0, 0, 0, 86, 0, 0, 0, 2,116, 0, 0, 0, 0,116, 0, 0, + 0, 2, 95, 0, 0, 0, 0,116, 0, 0, 0, 2, 95, 0, 0, 0, 0,116, 0, 0, + 0, 7,115,116, 97,116,105, 99, 0, 0, 0, 0,136, 0, 0, 0, 4,112,116,114, + 0, 0, 0, 0,146, 0, 0, 0, 2,116, 0, 0, 0, 0,154, 0, 0, 0, 4,100, +101,102, 0, 0, 0, 0,162, 0, 0, 0, 0, 0, 0, 0,162, 0, 0, 0, 0, 0, + 0, 0,162, 0, 0, 0, 0, 0, 0, 0,162, 0, 0, 0, 0, 0, 0, 0,162, 0, + 0, 0, 0, 0, 0, 0,162, 0, 0, 0, 0, 0, 0, 0, 69, 2, 0, 0, 0, 6, + 99,108, 97,115,115, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, + 8,105,110, 99,108, 97,115,115, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, + 0, 2, 0, 0, 0, 17, 47, 42, 32,103,101,116, 32,102,117,110, 99,116,105,111, +110, 58, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 11, 32,111, +102, 32, 99,108, 97,115,115, 32, 0, 2, 0, 0, 0, 4, 32, 42, 47, 0, 2, 0, + 0, 0, 9, 99,103,101,116,110, 97,109,101, 0, 2, 0, 0, 0, 10, 99,102,117, +110, 99,110, 97,109,101, 0, 2, 0, 0, 0, 11,116,111,108,117, 97, 73, 95,103, +101,116, 0, 2, 0, 0, 0, 12,115,116, 97,116,105, 99, 32,118,111,105,100, 0, + 2, 0, 0, 0, 7, 40,118,111,105,100, 41, 0, 2, 0, 0, 0, 2,123, 0, 2, + 0, 0, 0, 19, 32,105,110,116, 32,116,111,108,117, 97, 73, 95,105,110,100,101, +120, 59, 0, 2, 0, 0, 0, 2, 95, 0, 2, 0, 0, 0, 7,115,116, 97,116,105, + 99, 0, 2, 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, 0, 0, 0, 4, +109,111,100, 0, 2, 0, 0, 0, 13, 94, 37,115, 42, 40,115,116, 97,116,105, 99, + 41, 0, 2, 0, 0, 0, 2, 32, 0, 2, 0, 0, 0, 2, 42, 0, 2, 0, 0, 0, + 6,115,101,108,102, 59, 0, 2, 0, 0, 0, 34, 32,108,117, 97, 95,112,117,115, +104,111, 98,106,101, 99,116, 40,108,117, 97, 95,103,101,116,112, 97,114, 97,109, + 40, 49, 41, 41, 59, 0, 2, 0, 0, 0, 26, 32,108,117, 97, 95,112,117,115,104, +115,116,114,105,110,103, 40, 34, 46,115,101,108,102, 34, 41, 59, 0, 2, 0, 0, + 0, 9, 32,115,101,108,102, 32, 61, 32, 0, 2, 0, 0, 0, 2, 40, 0, 2, 0, + 0, 0, 4, 42, 41, 32, 0, 2, 0, 0, 0, 36,108,117, 97, 95,103,101,116,117, +115,101,114,100, 97,116, 97, 40,108,117, 97, 95,114, 97,119,103,101,116,116, 97, + 98,108,101, 40, 41, 41, 59, 0, 2, 0, 0, 0, 20, 94, 37,115, 42,115,116, 97, +116,105, 99, 37,115, 37,115, 42, 40, 46, 42, 41, 0, 2, 0, 0, 0, 42, 32,105, +102, 32, 40, 33,116,111,108,117, 97, 95,105,115,116,121,112,101, 40, 50, 44,116, +111,108,117, 97, 95,116, 97,103, 95,110,117,109, 98,101,114, 44, 48, 41, 41, 0, + 2, 0, 0, 0, 50, 32, 32,116,111,108,117, 97, 95,101,114,114,111,114, 40, 34, +105,110,118, 97,108,105,100, 32,116,121,112,101, 32,105,110, 32, 97,114,114, 97, +121, 32,105,110,100,101,120,105,110,103, 46, 34, 41, 59, 0, 2, 0, 0, 0, 45, + 32,116,111,108,117, 97, 73, 95,105,110,100,101,120, 32, 61, 32, 40,105,110,116, + 41,116,111,108,117, 97, 95,103,101,116,110,117,109, 98,101,114, 40, 50, 44, 48, + 41, 45, 49, 59, 0, 2, 0, 0, 0, 38, 32,105,102, 32, 40,116,111,108,117, 97, + 73, 95,105,110,100,101,120, 60, 48, 32,124,124, 32,116,111,108,117, 97, 73, 95, +105,110,100,101,120, 62, 61, 0, 2, 0, 0, 0, 4,100,105,109, 0, 2, 0, 0, + 0, 2, 41, 0, 2, 0, 0, 0, 47, 32, 32,116,111,108,117, 97, 95,101,114,114, +111,114, 40, 34, 97,114,114, 97,121, 32,105,110,100,101,120,105,110,103, 32,111, +117,116, 32,111,102, 32,114, 97,110,103,101, 46, 34, 41, 59, 0, 2, 0, 0, 0, + 2,116, 0, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, 0, + 5,116,121,112,101, 0, 2, 0, 0, 0, 7,110,117,109, 98,101,114, 0, 2, 0, + 0, 0, 13, 32, 32,116,111,108,117, 97, 95,112,117,115,104, 0, 2, 0, 0, 0, + 10, 40, 40,100,111,117, 98,108,101, 41, 0, 2, 0, 0, 0, 9,103,101,116,118, + 97,108,117,101, 0, 2, 0, 0, 0, 3, 41, 59, 0, 2, 0, 0, 0, 4,112,116, +114, 0, 2, 0, 0, 0, 2, 38, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 30, + 32, 32,116,111,108,117, 97, 95,112,117,115,104,117,115,101,114,116,121,112,101, + 40, 40,118,111,105,100, 42, 41, 38, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, + 0, 4,116, 97,103, 0, 2, 0, 0, 0, 29, 32, 32,116,111,108,117, 97, 95,112, +117,115,104,117,115,101,114,116,121,112,101, 40, 40,118,111,105,100, 42, 41, 0, + 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 2, 10, 0, 2, 0, 0, 0, 6, 99, +111,110,115,116, 0, 2, 0, 0, 0, 17, 47, 42, 32,115,101,116, 32,102,117,110, + 99,116,105,111,110, 58, 0, 2, 0, 0, 0, 9, 99,115,101,116,110, 97,109,101, + 0, 2, 0, 0, 0, 11,116,111,108,117, 97, 73, 95,115,101,116, 0, 2, 0, 0, + 0, 3, 58, 58, 0, 2, 0, 0, 0, 15, 91,116,111,108,117, 97, 73, 95,105,110, +100,101,120, 93, 0, 2, 0, 0, 0, 7,115,101,108,102, 45, 62, 0, 2, 0, 0, + 0, 4, 32, 61, 32, 0, 2, 0, 0, 0, 3, 40, 40, 0, 2, 0, 0, 0, 3, 41, + 32, 0, 2, 0, 0, 0, 4,100,101,102, 0, 2, 0, 0, 0, 10,116,111,108,117, + 97, 95,103,101,116, 0, 2, 0, 0, 0, 4, 40, 51, 44, 0, 2, 0, 0, 0, 4, + 41, 41, 59, 0, 2, 0, 0, 0, 21,116,111,108,117, 97, 95,103,101,116,117,115, +101,114,116,121,112,101, 40, 51, 44, 0, 2, 0, 0, 0, 9,114,101,103,105,115, +116,101,114, 0, 4, 0, 0, 0,167, 0, 0, 0, 11, 64, 97,114,114, 97,121, 46, +108,117, 97, 0, 0, 0, 0,185, 5, 1, 60,168, 13, 0, 20, 2, 2, 1, 1, 46, + 7, 13, 0, 20, 3, 2, 1, 1, 60,169, 13, 1, 52, 84, 60,170, 13, 0, 18, 4, + 52, 41, 60,171, 15, 5, 11, 6, 13, 1, 42, 11, 7, 42, 13, 0, 18, 8, 42, 11, + 9, 42, 13, 0, 18, 10, 42, 11, 11, 42, 13, 0, 18, 4, 42, 11, 12, 42, 2, 0, + 1, 50, 33, 60,173, 15, 5, 11, 6, 13, 1, 42, 11, 7, 42, 13, 0, 18, 8, 42, + 11, 9, 42, 13, 0, 18, 10, 42, 11, 13, 42, 2, 0, 1, 60,174, 50, 72, 60,176, + 13, 0, 18, 4, 52, 35, 60,177, 15, 5, 11, 14, 13, 0, 18, 8, 42, 11, 9, 42, + 13, 0, 18, 10, 42, 11, 11, 42, 13, 0, 18, 4, 42, 11, 12, 42, 2, 0, 1, 50, + 27, 60,179, 15, 5, 11, 14, 13, 0, 18, 8, 42, 11, 9, 42, 13, 0, 18, 10, 42, + 11, 13, 42, 2, 0, 1, 60,180, 60,181, 60,182, 0, 0, 0, 0, 2, 0, 0, 0, +167, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0,168, 0, 0, 0, 7,112, 97, +114,101,110,116, 0, 0, 0, 0, 15, 2, 0, 0, 0, 7,112, 97,114,101,110,116, + 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8,105,110, 99,108, + 97,115,115, 0, 2, 0, 0, 0, 9,105,110,109,111,100,117,108,101, 0, 2, 0, + 0, 0, 9, 99,115,101,116,110, 97,109,101, 0, 2, 0, 0, 0, 7,111,117,116, +112,117,116, 0, 2, 0, 0, 0, 20, 32,116,111,108,117, 97, 95,116, 97, 98,108, +101, 97,114,114, 97,121, 40, 34, 0, 2, 0, 0, 0, 4, 34, 44, 34, 0, 2, 0, + 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 3, 34, 44, 0, 2, 0, 0, + 0, 9, 99,103,101,116,110, 97,109,101, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, + 0, 0, 3, 41, 59, 0, 2, 0, 0, 0, 8, 44, 78, 85, 76, 76, 41, 59, 0, 2, + 0, 0, 0, 21, 32,116,111,108,117, 97, 95,103,108,111, 98, 97,108, 97,114,114, + 97,121, 40, 34, 0, 2, 0, 0, 0, 11,117,110,114,101,103,105,115,116,101,114, + 0, 4, 0, 0, 0,184, 0, 0, 0, 11, 64, 97,114,114, 97,121, 46,108,117, 97, + 0, 0, 0, 0, 52, 4, 1, 60,185, 13, 0, 20, 1, 2, 1, 1, 4, 0, 32, 48, + 10, 13, 0, 20, 2, 2, 1, 1, 4, 0, 32, 52, 19, 60,186, 15, 3, 11, 4, 13, + 0, 18, 5, 42, 11, 6, 42, 2, 0, 1, 50, 2, 60,187, 60,188, 0, 0, 0, 0, + 1, 0, 0, 0,184, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 7, 2, 0, + 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8,105,110, 99,108, 97,115,115, + 0, 2, 0, 0, 0, 9,105,110,109,111,100,117,108,101, 0, 2, 0, 0, 0, 7, +111,117,116,112,117,116, 0, 2, 0, 0, 0, 32, 32,108,117, 97, 95,112,117,115, +104,110,105,108, 40, 41, 59, 32,108,117, 97, 95,115,101,116,103,108,111, 98, 97, +108, 40, 34, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 4, + 34, 41, 59, 0, 2, 0, 0, 0, 7, 95, 65,114,114, 97,121, 0, 4, 0, 0, 0, +192, 0, 0, 0, 11, 64, 97,114,114, 97,121, 46,108,117, 97, 0, 0, 0, 0, 40, + 4, 1, 60,193, 13, 0, 11, 1, 15, 2, 26, 60,194, 15, 3, 13, 0, 15, 4, 2, + 0, 2, 60,195, 15, 5, 13, 0, 2, 0, 1, 60,196, 13, 0, 1, 1, 60,197, 0, + 0, 0, 0, 1, 0, 0, 0,192, 0, 0, 0, 2,116, 0, 0, 0, 0, 6, 2, 0, + 0, 0, 2,116, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, + 11, 99,108, 97,115,115, 65,114,114, 97,121, 0, 2, 0, 0, 0, 7,115,101,116, +116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, + 0, 0, 0, 7, 97,112,112,101,110,100, 0, 2, 0, 0, 0, 6, 65,114,114, 97, +121, 0, 4, 0, 0, 0,201, 0, 0, 0, 11, 64, 97,114,114, 97,121, 46,108,117, + 97, 0, 0, 0, 0, 21, 5, 1, 60,202, 15, 1, 15, 2, 13, 0, 11, 3, 2, 1, + 2, 3, 1, 1, 60,203, 0, 0, 0, 0, 1, 0, 0, 0,201, 0, 0, 0, 2,115, + 0, 0, 0, 0, 4, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 7, 95, 65,114, +114, 97,121, 0, 2, 0, 0, 0, 12, 68,101, 99,108, 97,114, 97,116,105,111,110, + 0, 2, 0, 0, 0, 4,118, 97,114, 0, +}; + +/* function.lo */ +static char B13[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 14, 64,102,117,110, 99,116, +105,111,110, 46,108,117, 97, 0, 0, 0, 0,141, 15, 0, 60, 24, 22, 7, 60, 25, + 11, 1, 11, 2, 11, 3, 60, 26, 11, 2, 11, 4, 60, 27, 11, 2, 11, 5, 60, 28, + 11, 2, 11, 6, 60, 29, 22, 1, 11, 7, 7, 0, 30, 0, 11, 8, 60, 30, 11, 2, + 11, 9, 60, 31, 15, 10, 30, 6, 60, 32, 25, 0, 60, 33, 15, 11, 15, 0, 15, 12, + 2, 0, 2, 60, 36, 15, 0, 11, 13, 11, 14, 26, 60, 51, 15, 0, 11, 15, 11, 16, + 26, 60,232, 15, 0, 11, 17, 11, 18, 26, 60,242, 15, 0, 11, 19, 11, 20, 26, 60, +250, 15, 0, 11, 21, 11, 22, 26, 59, 1, 14, 15, 0, 11, 23, 11, 24, 26, 59, 1, + 21, 11, 26, 25, 25, 59, 1, 49, 11, 28, 25, 27, 0, 0, 0, 0, 0, 0, 0, 0, + 29, 2, 0, 0, 0, 14, 99,108, 97,115,115, 70,117,110, 99,116,105,111,110, 0, + 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 5, +116,121,112,101, 0, 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 5,110, + 97,109,101, 0, 2, 0, 0, 0, 5, 97,114,103,115, 0, 2, 0, 0, 0, 2,110, + 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, 0, 0, 0, 6, 95, 98, 97, +115,101, 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, 70,101, 97,116,117,114,101, + 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111, +108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 8,100,101, 99,108,116, 97,103, + 0, 4, 0, 0, 0, 36, 0, 0, 0, 14, 64,102,117,110, 99,116,105,111,110, 46, +108,117, 97, 0, 0, 0, 0,141, 10, 1, 60, 37, 13, 0, 20, 1, 2, 1, 1, 48, + 7, 13, 0, 18, 2, 11, 2, 32, 52, 21, 60, 38, 15, 3, 13, 0, 18, 4, 18, 5, + 13, 0, 18, 4, 18, 6, 2, 0, 2, 50, 2, 60, 39, 60, 40, 13, 0, 11, 7, 13, + 0, 11, 8, 15, 9, 13, 0, 18, 10, 15, 11, 13, 0, 18, 12, 11, 2, 2, 1, 2, + 2, 2, 2, 27, 1, 27, 2, 5, 4, 60, 41, 15, 3, 13, 0, 18, 7, 13, 0, 18, + 8, 2, 0, 2, 60, 42, 7, 1, 50, 25, 60, 44, 13, 0, 18, 14, 13, 1, 16, 20, + 3, 2, 0, 1, 60, 45, 13, 1, 7, 1, 37, 23, 1, 60, 46, 60, 43, 13, 0, 18, + 14, 13, 1, 16, 54, 36, 60, 47, 0, 0, 0, 0, 2, 0, 0, 0, 36, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 42, 0, 0, 0, 2,105, 0, 0, 0, 0, 15, + 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8,105,110, 99,108, 97, +115,115, 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, 0, 0, 0, 8,100, +101, 99,108,116, 97,103, 0, 2, 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, + 0, 0, 0, 7, 99,105,116,121,112,101, 0, 2, 0, 0, 0, 5, 99,116, 97,103, + 0, 2, 0, 0, 0, 6,105,116,121,112,101, 0, 2, 0, 0, 0, 4,116, 97,103, + 0, 2, 0, 0, 0, 7,116, 97,103,118, 97,114, 0, 2, 0, 0, 0, 5,116,121, +112,101, 0, 2, 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, 0, 0, 0, + 4,109,111,100, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 5, 97,114,103, +115, 0, 2, 0, 0, 0, 8,115,117,112, 99,111,100,101, 0, 4, 0, 0, 0, 51, + 0, 0, 0, 14, 64,102,117,110, 99,116,105,111,110, 46,108,117, 97, 0, 0, 0, + 6, 51, 15, 1, 60, 52, 13, 0, 20, 2, 2, 1, 1, 60, 53, 15, 5, 13, 0, 18, + 6, 11, 7, 2, 3, 2, 60, 55, 13, 1, 52, 21, 60, 56, 15, 8, 11, 9, 13, 0, + 18, 10, 11, 11, 13, 1, 11, 12, 2, 0, 5, 50, 17, 60, 58, 15, 8, 11, 13, 13, + 0, 18, 10, 11, 12, 2, 0, 3, 60, 59, 60, 60, 15, 8, 11, 14, 13, 0, 18, 15, + 11, 16, 2, 0, 3, 60, 61, 15, 8, 11, 17, 2, 0, 1, 60, 64, 15, 8, 11, 18, + 2, 0, 1, 60, 66, 4, 0, 60, 67, 13, 1, 52, 6, 7, 2, 23, 5, 50, 4, 7, + 1, 23, 5, 60, 68, 13, 1, 48, 7, 13, 0, 18, 10, 11, 20, 31, 48, 5, 13, 4, + 4, 0, 32, 52, 51, 60, 69, 13, 0, 18, 21, 11, 21, 32, 52, 19, 60, 70, 15, 8, + 11, 22, 13, 0, 18, 23, 18, 24, 11, 25, 2, 0, 3, 50, 19, 60, 72, 15, 8, 11, + 22, 13, 0, 18, 23, 18, 26, 11, 25, 2, 0, 3, 60, 73, 50, 2, 60, 74, 60, 76, + 13, 0, 18, 27, 7, 1, 16, 18, 28, 11, 29, 31, 52, 93, 60, 77, 7, 1, 50, 72, + 60, 79, 15, 31, 13, 0, 18, 27, 13, 6, 16, 18, 28, 2, 1, 1, 11, 32, 31, 52, + 29, 60, 80, 15, 8, 11, 33, 13, 0, 18, 27, 13, 6, 16, 20, 34, 13, 5, 2, 1, + 2, 42, 11, 35, 42, 2, 0, 1, 50, 2, 60, 81, 60, 82, 13, 5, 7, 1, 37, 23, + 5, 60, 83, 13, 6, 7, 1, 37, 23, 6, 60, 84, 60, 78, 13, 0, 18, 27, 13, 6, + 16, 54, 83, 5, 1, 50, 2, 60, 85, 60, 87, 15, 8, 11, 36, 13, 5, 42, 11, 37, + 42, 2, 0, 1, 60, 89, 15, 8, 11, 38, 2, 0, 1, 60, 92, 4, 0, 60, 93, 13, + 1, 52, 6, 7, 2, 23, 6, 50, 4, 7, 1, 23, 6, 60, 94, 13, 1, 48, 7, 13, + 0, 18, 10, 11, 20, 31, 48, 5, 13, 4, 4, 0, 32, 52, 47, 60, 95, 15, 8, 11, + 39, 13, 0, 18, 21, 13, 1, 11, 40, 11, 41, 2, 0, 5, 60, 96, 15, 8, 11, 42, + 13, 0, 18, 21, 13, 1, 11, 43, 2, 0, 4, 60, 97, 15, 8, 11, 44, 2, 0, 1, + 50, 35, 60, 98, 13, 4, 52, 27, 60, 99, 13, 0, 11, 6, 15, 5, 13, 0, 18, 6, + 11, 45, 2, 3, 2, 27, 2, 23, 3, 23, 3, 5, 2, 50, 2, 60,100, 60,102, 13, + 0, 18, 27, 7, 1, 16, 18, 28, 11, 29, 31, 52, 57, 60,103, 7, 1, 50, 36, 60, +105, 13, 0, 18, 27, 13, 7, 16, 20, 46, 13, 6, 2, 0, 2, 60,106, 13, 6, 7, + 1, 37, 23, 6, 60,107, 13, 7, 7, 1, 37, 23, 7, 60,108, 60,104, 13, 0, 18, + 27, 13, 7, 16, 54, 47, 5, 1, 50, 2, 60,109, 60,112, 13, 1, 48, 7, 13, 0, + 18, 10, 11, 20, 31, 48, 5, 13, 4, 4, 0, 32, 52, 19, 60,113, 15, 8, 11, 47, + 13, 0, 18, 10, 42, 11, 48, 42, 2, 0, 1, 50, 2, 60,114, 60,117, 13, 1, 52, + 6, 7, 2, 23, 6, 50, 4, 7, 1, 23, 6, 60,118, 13, 0, 18, 27, 7, 1, 16, + 18, 28, 11, 29, 31, 52, 57, 60,119, 7, 1, 50, 36, 60,121, 13, 0, 18, 27, 13, + 7, 16, 20, 49, 13, 6, 2, 0, 2, 60,122, 13, 6, 7, 1, 37, 23, 6, 60,123, + 13, 7, 7, 1, 37, 23, 7, 60,124, 60,120, 13, 0, 18, 27, 13, 7, 16, 54, 47, + 5, 1, 50, 2, 60,125, 60,128, 13, 1, 48, 7, 13, 0, 18, 10, 11, 50, 32, 52, + 12, 60,129, 15, 8, 11, 51, 2, 0, 1, 49, 2,252, 60,130, 13, 1, 48, 7, 13, + 0, 18, 10, 11, 52, 32, 52, 34, 60,131, 15, 8, 11, 53, 13, 0, 18, 27, 7, 1, + 16, 18, 10, 11, 54, 13, 0, 18, 27, 7, 2, 16, 18, 10, 11, 55, 2, 0, 5, 49, + 2,203, 60,133, 15, 8, 11, 56, 2, 0, 1, 60,134, 13, 0, 18, 28, 11, 57, 31, + 48, 7, 13, 0, 18, 28, 11, 29, 31, 52, 48, 60,135, 15, 8, 11, 58, 13, 0, 18, + 6, 13, 0, 18, 28, 13, 0, 18, 59, 11, 60, 2, 0, 5, 60,136, 15, 8, 11, 42, + 13, 0, 18, 6, 13, 0, 18, 28, 13, 0, 18, 59, 11, 61, 2, 0, 5, 50, 11, 60, +138, 15, 8, 11, 58, 2, 0, 1, 60,139, 60,140, 13, 1, 48, 7, 13, 0, 18, 10, + 11, 20, 32, 52, 15, 60,141, 15, 8, 11, 20, 13, 1, 11, 42, 2, 0, 3, 50, 70, + 60,142, 13, 1, 48, 2, 13, 4, 52, 21, 60,143, 15, 8, 13, 1, 11, 62, 42, 13, + 0, 18, 10, 42, 11, 42, 2, 0, 2, 50, 39, 60,144, 13, 1, 52, 18, 60,145, 15, + 8, 11, 63, 13, 0, 18, 10, 42, 11, 42, 2, 0, 2, 50, 15, 60,147, 15, 8, 13, + 0, 18, 10, 11, 42, 2, 0, 2, 60,148, 60,151, 7, 1, 50, 49, 60,153, 13, 0, + 18, 27, 13, 7, 16, 20, 64, 2, 0, 1, 60,154, 13, 7, 7, 1, 37, 23, 7, 60, +155, 13, 0, 18, 27, 13, 7, 16, 52, 11, 60,156, 15, 8, 11, 65, 2, 0, 1, 50, + 2, 60,157, 60,158, 60,152, 13, 0, 18, 27, 13, 7, 16, 54, 60, 60,160, 15, 8, + 11, 66, 2, 0, 1, 60,163, 13, 0, 18, 28, 11, 57, 31, 48, 7, 13, 0, 18, 28, + 11, 29, 31, 52,220, 60,164, 15, 31, 13, 0, 18, 28, 2, 1, 1, 60,165, 13, 8, + 11, 68, 32, 52, 17, 60,166, 15, 8, 11, 69, 13, 8, 42, 11, 70, 42, 2, 0, 1, + 50,179, 60,167, 13, 8, 52, 17, 60,168, 15, 8, 11, 69, 13, 8, 42, 11, 71, 42, + 2, 0, 1, 50,156, 60,170, 13, 0, 18, 59, 11, 57, 32, 52, 98, 60,171, 15, 8, + 11, 72, 2, 0, 1, 60,172, 15, 8, 11, 73, 2, 0, 1, 60,173, 15, 8, 11, 74, + 13, 0, 18, 28, 11, 71, 2, 0, 3, 60,174, 15, 8, 11, 75, 2, 0, 1, 60,175, + 15, 8, 11, 76, 13, 0, 18, 28, 11, 77, 2, 0, 3, 60,176, 15, 8, 11, 78, 2, + 0, 1, 60,177, 15, 8, 11, 79, 13, 0, 18, 26, 11, 80, 13, 0, 18, 26, 11, 66, + 2, 0, 5, 60,178, 15, 8, 11, 81, 2, 0, 1, 50, 45, 60,180, 13, 0, 18, 59, + 11, 82, 32, 52, 17, 60,181, 15, 8, 11, 83, 13, 0, 18, 26, 11, 66, 2, 0, 3, + 50, 17, 60,183, 15, 8, 11, 84, 13, 0, 18, 26, 11, 66, 2, 0, 3, 60,184, 60, +185, 5, 1, 50, 2, 60,186, 60,187, 7, 1, 50, 25, 60,189, 13, 0, 18, 27, 13, + 8, 16, 20, 85, 2, 0, 1, 60,190, 13, 8, 7, 1, 37, 23, 8, 60,191, 60,188, + 13, 0, 18, 27, 13, 8, 16, 54, 36, 60,192, 15, 8, 11, 86, 2, 0, 1, 60,195, + 13, 1, 52, 6, 7, 2, 23, 6, 50, 4, 7, 1, 23, 6, 60,196, 13, 0, 18, 27, + 7, 1, 16, 18, 28, 11, 29, 31, 52, 57, 60,197, 7, 1, 50, 36, 60,199, 13, 0, + 18, 27, 13, 9, 16, 20, 87, 13, 6, 2, 0, 2, 60,200, 13, 6, 7, 1, 37, 23, + 6, 60,201, 13, 9, 7, 1, 37, 23, 9, 60,202, 60,198, 13, 0, 18, 27, 13, 9, + 16, 54, 47, 5, 1, 50, 2, 60,203, 60,206, 13, 0, 18, 27, 7, 1, 16, 18, 28, + 11, 29, 31, 52, 46, 60,207, 7, 1, 50, 25, 60,209, 13, 0, 18, 27, 13, 9, 16, + 20, 88, 2, 0, 1, 60,210, 13, 9, 7, 1, 37, 23, 9, 60,211, 60,208, 13, 0, + 18, 27, 13, 9, 16, 54, 36, 5, 1, 50, 2, 60,212, 5, 2, 60,213, 60,215, 15, + 8, 11, 89, 2, 0, 1, 60,216, 15, 8, 11, 90, 2, 0, 1, 60,219, 15, 8, 11, + 91, 2, 0, 1, 60,220, 15, 93, 13, 0, 18, 15, 9, 2, 9, 1, 2, 1, 3, 7, + 1, 38, 60,221, 13, 7, 7, 0, 36, 52, 38, 60,222, 15, 8, 11, 39, 15, 93, 13, + 0, 18, 15, 7, 1, 9, 3, 2, 1, 3, 42, 15, 94, 11, 95, 13, 7, 2, 1, 2, + 42, 11, 96, 42, 2, 0, 1, 50, 19, 60,224, 15, 8, 11, 97, 13, 0, 18, 98, 42, + 11, 99, 42, 2, 0, 1, 60,225, 60,227, 15, 8, 11,100, 2, 0, 1, 60,228, 15, + 8, 11,101, 2, 0, 1, 60,229, 0, 0, 0, 0, 24, 0, 0, 0, 51, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0, 52, 0, 0, 0, 6, 99,108, 97,115,115, 0, + 0, 0, 0, 53, 0, 0, 0, 2, 95, 0, 0, 0, 0, 53, 0, 0, 0, 2, 95, 0, + 0, 0, 0, 53, 0, 0, 0, 7,115,116, 97,116,105, 99, 0, 0, 0, 0, 66, 0, + 0, 0, 5,110, 97,114,103, 0, 0, 0, 0, 77, 0, 0, 0, 2,105, 0, 0, 0, + 0, 84, 0, 0, 0, 0, 0, 0, 0, 92, 0, 0, 0, 5,110, 97,114,103, 0, 0, + 0, 0,103, 0, 0, 0, 2,105, 0, 0, 0, 0,108, 0, 0, 0, 0, 0, 0, 0, +119, 0, 0, 0, 2,105, 0, 0, 0, 0,124, 0, 0, 0, 0, 0, 0, 0,151, 0, + 0, 0, 2,105, 0, 0, 0, 0,164, 0, 0, 0, 2,116, 0, 0, 0, 0,185, 0, + 0, 0, 0, 0, 0, 0,187, 0, 0, 0, 2,105, 0, 0, 0, 0,197, 0, 0, 0, + 2,105, 0, 0, 0, 0,202, 0, 0, 0, 0, 0, 0, 0,207, 0, 0, 0, 2,105, + 0, 0, 0, 0,211, 0, 0, 0, 0, 0, 0, 0,212, 0, 0, 0, 0, 0, 0, 0, +212, 0, 0, 0, 0, 0, 0, 0,220, 0, 0, 0, 9,111,118,101,114,108,111, 97, +100, 0, 0, 0, 0,102, 2, 0, 0, 0, 6, 99,108, 97,115,115, 0, 2, 0, 0, + 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8,105,110, 99,108, 97,115,115, 0, + 2, 0, 0, 0, 2, 95, 0, 2, 0, 0, 0, 7,115,116, 97,116,105, 99, 0, 2, + 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, 0, 0, 0, 4,109,111,100, + 0, 2, 0, 0, 0, 13, 94, 37,115, 42, 40,115,116, 97,116,105, 99, 41, 0, 2, + 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 11, 47, 42, 32,109, +101,116,104,111,100, 58, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, + 0, 11, 32,111,102, 32, 99,108, 97,115,115, 32, 0, 2, 0, 0, 0, 4, 32, 42, + 47, 0, 2, 0, 0, 0, 13, 47, 42, 32,102,117,110, 99,116,105,111,110, 58, 0, + 2, 0, 0, 0, 12,115,116, 97,116,105, 99, 32,118,111,105,100, 0, 2, 0, 0, + 0, 6, 99,110, 97,109,101, 0, 2, 0, 0, 0, 7, 40,118,111,105,100, 41, 0, + 2, 0, 0, 0, 2,123, 0, 2, 0, 0, 0, 7, 32,105,102, 32, 40, 10, 0, 2, + 0, 0, 0, 5,110, 97,114,103, 0, 2, 0, 0, 0, 4,110,101,119, 0, 2, 0, + 0, 0, 6, 99,111,110,115,116, 0, 2, 0, 0, 0, 22, 32, 32, 32, 32, 32, 33, +116,111,108,117, 97, 95,105,115,116,121,112,101, 40, 49, 44, 0, 2, 0, 0, 0, + 7,112, 97,114,101,110,116, 0, 2, 0, 0, 0, 5, 99,116, 97,103, 0, 2, 0, + 0, 0, 8, 44, 48, 41, 32,124,124, 10, 0, 2, 0, 0, 0, 4,116, 97,103, 0, + 2, 0, 0, 0, 5, 97,114,103,115, 0, 2, 0, 0, 0, 5,116,121,112,101, 0, + 2, 0, 0, 0, 5,118,111,105,100, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, + 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, 0, 7,111, 98,106,101, 99, +116, 0, 2, 0, 0, 0, 7, 32, 32, 32, 32, 32, 33, 0, 2, 0, 0, 0, 13,111, +117,116, 99,104,101, 99,107,116,121,112,101, 0, 2, 0, 0, 0, 5, 32,124,124, + 10, 0, 2, 0, 0, 0, 21, 32, 32, 32, 32, 32, 33,116,111,108,117, 97, 95,105, +115,110,111,111, 98,106, 40, 0, 2, 0, 0, 0, 19, 41, 10, 32, 41, 10, 32, 32, +103,111,116,111, 32,101,114,114,111,114, 59, 0, 2, 0, 0, 0, 9, 32,101,108, +115,101, 10, 32,123, 0, 2, 0, 0, 0, 2, 32, 0, 2, 0, 0, 0, 2, 42, 0, + 2, 0, 0, 0, 8,115,101,108,102, 32, 61, 32, 0, 2, 0, 0, 0, 2, 40, 0, + 2, 0, 0, 0, 3, 42, 41, 0, 2, 0, 0, 0, 24,116,111,108,117, 97, 95,103, +101,116,117,115,101,114,116,121,112,101, 40, 49, 44, 48, 41, 59, 0, 2, 0, 0, + 0, 20, 94, 37,115, 42,115,116, 97,116,105, 99, 37,115, 37,115, 42, 40, 46, 42, + 41, 0, 2, 0, 0, 0, 8,100,101, 99,108, 97,114,101, 0, 2, 0, 0, 0, 55, + 32, 32,105,102, 32, 40, 33,115,101,108,102, 41, 32,116,111,108,117, 97, 95,101, +114,114,111,114, 40, 34,105,110,118, 97,108,105,100, 32, 39,115,101,108,102, 39, + 32,105,110, 32,102,117,110, 99,116,105,111,110, 32, 39, 0, 2, 0, 0, 0, 5, + 39, 34, 41, 59, 0, 2, 0, 0, 0, 9,103,101,116, 97,114,114, 97,121, 0, 2, + 0, 0, 0, 7,100,101,108,101,116,101, 0, 2, 0, 0, 0, 15, 32, 32,100,101, +108,101,116,101, 32,115,101,108,102, 59, 0, 2, 0, 0, 0, 12,111,112,101,114, + 97,116,111,114, 38, 91, 93, 0, 2, 0, 0, 0, 20, 32, 32,115,101,108,102, 45, + 62,111,112,101,114, 97,116,111,114, 91, 93, 40, 0, 2, 0, 0, 0, 5, 41, 32, + 61, 32, 0, 2, 0, 0, 0, 2, 59, 0, 2, 0, 0, 0, 4, 32, 32,123, 0, 2, + 0, 0, 0, 1, 0, 2, 0, 0, 0, 3, 32, 32, 0, 2, 0, 0, 0, 4,112,116, +114, 0, 2, 0, 0, 0, 14,116,111,108,117, 97, 73, 95,114,101,116, 32, 61, 32, + 0, 2, 0, 0, 0, 3, 41, 32, 0, 2, 0, 0, 0, 3, 58, 58, 0, 2, 0, 0, + 0, 7,115,101,108,102, 45, 62, 0, 2, 0, 0, 0, 8,112, 97,115,115,112, 97, +114, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 3, 41, 59, 0, 2, 0, 0, + 0, 2,116, 0, 2, 0, 0, 0, 7,110,117,109, 98,101,114, 0, 2, 0, 0, 0, + 14, 32, 32, 32,116,111,108,117, 97, 95,112,117,115,104, 0, 2, 0, 0, 0, 22, + 40, 40,100,111,117, 98,108,101, 41,116,111,108,117, 97, 73, 95,114,101,116, 41, + 59, 0, 2, 0, 0, 0, 14, 40,116,111,108,117, 97, 73, 95,114,101,116, 41, 59, + 0, 2, 0, 0, 0, 5, 32, 32, 32,123, 0, 2, 0, 0, 0, 20, 35,105,102,100, +101,102, 32, 95, 95, 99,112,108,117,115,112,108,117,115, 10, 0, 2, 0, 0, 0, + 29, 32, 32, 32, 32,118,111,105,100, 42, 32,116,111,108,117, 97, 73, 95, 99,108, +111,110,101, 32, 61, 32,110,101,119, 0, 2, 0, 0, 0, 7, 35,101,108,115,101, + 10, 0, 2, 0, 0, 0, 63, 32, 32, 32, 32,118,111,105,100, 42, 32,116,111,108, +117, 97, 73, 95, 99,108,111,110,101, 32, 61, 32,116,111,108,117, 97, 95, 99,111, +112,121, 40, 40,118,111,105,100, 42, 41, 38,116,111,108,117, 97, 73, 95,114,101, +116, 44,115,105,122,101,111,102, 40, 0, 2, 0, 0, 0, 4, 41, 41, 59, 0, 2, + 0, 0, 0, 8, 35,101,110,100,105,102, 10, 0, 2, 0, 0, 0, 51, 32, 32, 32, + 32,116,111,108,117, 97, 95,112,117,115,104,117,115,101,114,116,121,112,101, 40, +116,111,108,117, 97, 95,100,111, 99,108,111,110,101, 40,116,111,108,117, 97, 73, + 95, 99,108,111,110,101, 44, 0, 2, 0, 0, 0, 3, 41, 44, 0, 2, 0, 0, 0, + 5, 32, 32, 32,125, 0, 2, 0, 0, 0, 2, 38, 0, 2, 0, 0, 0, 42, 32, 32, + 32,116,111,108,117, 97, 95,112,117,115,104,117,115,101,114,116,121,112,101, 40, + 40,118,111,105,100, 42, 41, 38,116,111,108,117, 97, 73, 95,114,101,116, 44, 0, + 2, 0, 0, 0, 41, 32, 32, 32,116,111,108,117, 97, 95,112,117,115,104,117,115, +101,114,116,121,112,101, 40, 40,118,111,105,100, 42, 41,116,111,108,117, 97, 73, + 95,114,101,116, 44, 0, 2, 0, 0, 0, 9,114,101,116,118, 97,108,117,101, 0, + 2, 0, 0, 0, 4, 32, 32,125, 0, 2, 0, 0, 0, 9,115,101,116, 97,114,114, + 97,121, 0, 2, 0, 0, 0, 10,102,114,101,101, 97,114,114, 97,121, 0, 2, 0, + 0, 0, 3, 32,125, 0, 2, 0, 0, 0, 9, 32,114,101,116,117,114,110, 59, 0, + 2, 0, 0, 0, 8,101,114,114,111,114, 58, 10, 0, 2, 0, 0, 0, 9,111,118, +101,114,108,111, 97,100, 0, 2, 0, 0, 0, 7,115,116,114,115,117, 98, 0, 2, + 0, 0, 0, 7,102,111,114,109, 97,116, 0, 2, 0, 0, 0, 5, 37, 48, 50,100, + 0, 2, 0, 0, 0, 4, 40, 41, 59, 0, 2, 0, 0, 0, 36, 32,116,111,108,117, + 97, 95,101,114,114,111,114, 40, 34, 35,102,101,114,114,111,114, 32,105,110, 32, +102,117,110, 99,116,105,111,110, 32, 39, 0, 2, 0, 0, 0, 6,108,110, 97,109, +101, 0, 2, 0, 0, 0, 6, 39, 46, 34, 41, 59, 0, 2, 0, 0, 0, 2,125, 0, + 2, 0, 0, 0, 2, 10, 0, 2, 0, 0, 0, 9,114,101,103,105,115,116,101,114, + 0, 4, 0, 0, 0,232, 0, 0, 0, 14, 64,102,117,110, 99,116,105,111,110, 46, +108,117, 97, 0, 0, 0, 0, 89, 5, 1, 60,233, 13, 0, 20, 2, 2, 1, 1, 46, + 7, 13, 0, 20, 3, 2, 1, 1, 60,234, 13, 1, 52, 33, 60,235, 15, 4, 11, 5, + 13, 1, 42, 11, 6, 42, 13, 0, 18, 7, 42, 11, 8, 42, 13, 0, 18, 9, 42, 11, + 10, 42, 2, 0, 1, 50, 27, 60,237, 15, 4, 11, 11, 13, 0, 18, 7, 42, 11, 8, + 42, 13, 0, 18, 9, 42, 11, 10, 42, 2, 0, 1, 60,238, 60,239, 0, 0, 0, 0, + 2, 0, 0, 0,232, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0,233, 0, 0, + 0, 7,112, 97,114,101,110,116, 0, 0, 0, 0, 12, 2, 0, 0, 0, 7,112, 97, +114,101,110,116, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 8, +105,110, 99,108, 97,115,115, 0, 2, 0, 0, 0, 9,105,110,109,111,100,117,108, +101, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, 0, 18, 32, +116,111,108,117, 97, 95,102,117,110, 99,116,105,111,110, 40, 34, 0, 2, 0, 0, + 0, 4, 34, 44, 34, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, + 0, 3, 34, 44, 0, 2, 0, 0, 0, 6, 99,110, 97,109,101, 0, 2, 0, 0, 0, + 3, 41, 59, 0, 2, 0, 0, 0, 23, 32,116,111,108,117, 97, 95,102,117,110, 99, +116,105,111,110, 40, 78, 85, 76, 76, 44, 34, 0, 2, 0, 0, 0, 11,117,110,114, +101,103,105,115,116,101,114, 0, 4, 0, 0, 0,242, 0, 0, 0, 14, 64,102,117, +110, 99,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0, 52, 4, 1, 60,243, 13, + 0, 20, 1, 2, 1, 1, 4, 0, 32, 48, 10, 13, 0, 20, 2, 2, 1, 1, 4, 0, + 32, 52, 19, 60,244, 15, 3, 11, 4, 13, 0, 18, 5, 42, 11, 6, 42, 2, 0, 1, + 50, 2, 60,245, 60,246, 0, 0, 0, 0, 1, 0, 0, 0,242, 0, 0, 0, 5,115, +101,108,102, 0, 0, 0, 0, 7, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, + 0, 0, 8,105,110, 99,108, 97,115,115, 0, 2, 0, 0, 0, 9,105,110,109,111, +100,117,108,101, 0, 2, 0, 0, 0, 7,111,117,116,112,117,116, 0, 2, 0, 0, + 0, 32, 32,108,117, 97, 95,112,117,115,104,110,105,108, 40, 41, 59, 32,108,117, + 97, 95,115,101,116,103,108,111, 98, 97,108, 40, 34, 0, 2, 0, 0, 0, 6,108, +110, 97,109,101, 0, 2, 0, 0, 0, 4, 34, 41, 59, 0, 2, 0, 0, 0, 6,112, +114,105,110,116, 0, 4, 0, 0, 0,250, 0, 0, 0, 14, 64,102,117,110, 99,116, +105,111,110, 46,108,117, 97, 0, 0, 0, 1, 1, 8, 3, 60,251, 15, 2, 13, 1, + 11, 3, 42, 2, 0, 1, 60,252, 15, 2, 13, 1, 11, 4, 42, 13, 0, 18, 6, 42, + 11, 7, 42, 2, 0, 1, 60,253, 15, 2, 13, 1, 11, 8, 42, 13, 0, 18, 9, 42, + 11, 7, 42, 2, 0, 1, 60,254, 15, 2, 13, 1, 11, 10, 42, 13, 0, 18, 11, 42, + 11, 7, 42, 2, 0, 1, 60,255, 15, 2, 13, 1, 11, 12, 42, 13, 0, 18, 13, 42, + 11, 7, 42, 2, 0, 1, 59, 1, 0, 15, 2, 13, 1, 11, 14, 42, 13, 0, 18, 15, + 42, 11, 7, 42, 2, 0, 1, 59, 1, 1, 15, 2, 13, 1, 11, 16, 42, 13, 0, 18, + 17, 42, 11, 7, 42, 2, 0, 1, 59, 1, 2, 15, 2, 13, 1, 11, 18, 42, 13, 0, + 18, 19, 42, 11, 7, 42, 2, 0, 1, 59, 1, 3, 15, 2, 13, 1, 11, 20, 42, 2, + 0, 1, 59, 1, 4, 7, 1, 50, 35, 59, 1, 6, 13, 0, 18, 22, 13, 3, 16, 20, + 2, 13, 1, 11, 23, 42, 11, 24, 2, 0, 3, 59, 1, 7, 13, 3, 7, 1, 37, 23, + 3, 59, 1, 8, 59, 1, 5, 13, 0, 18, 22, 13, 3, 16, 54, 47, 59, 1, 9, 15, + 2, 13, 1, 11, 25, 42, 2, 0, 1, 59, 1, 10, 15, 2, 13, 1, 11, 26, 42, 13, + 2, 42, 2, 0, 1, 59, 1, 11, 0, 0, 0, 0, 4, 0, 0, 0,250, 0, 0, 0, + 5,115,101,108,102, 0, 0, 0, 0,250, 0, 0, 0, 6,105,100,101,110,116, 0, + 0, 0, 0,250, 0, 0, 0, 6, 99,108,111,115,101, 0, 0, 0, 1, 4, 0, 0, + 0, 2,105, 0, 0, 0, 0, 27, 2, 0, 0, 0, 6,105,100,101,110,116, 0, 2, + 0, 0, 0, 6, 99,108,111,115,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, + 0, 2, 0, 0, 0, 10, 70,117,110, 99,116,105,111,110,123, 0, 2, 0, 0, 0, + 10, 32,109,111,100, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,115,101,108,102, + 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 3, 39, 44, 0, 2, 0, + 0, 0, 10, 32,116,121,112,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,116,121, +112,101, 0, 2, 0, 0, 0, 10, 32,112,116,114, 32, 32, 61, 32, 39, 0, 2, 0, + 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 10, 32,110, 97,109,101, 32, 61, 32, + 39, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 11, 32, 99,111, +110,115,116, 32, 61, 32, 39, 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, + 0, 0, 0, 11, 32, 99,110, 97,109,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 6, + 99,110, 97,109,101, 0, 2, 0, 0, 0, 11, 32,108,110, 97,109,101, 32, 61, 32, + 39, 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 10, 32, 97, +114,103,115, 32, 61, 32,123, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 5, + 97,114,103,115, 0, 2, 0, 0, 0, 3, 32, 32, 0, 2, 0, 0, 0, 2, 44, 0, + 2, 0, 0, 0, 3, 32,125, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 9, +111,118,101,114,108,111, 97,100, 0, 4, 0, 0, 1, 14, 0, 0, 0, 14, 64,102, +117,110, 99,116,105,111,110, 46,108,117, 97, 0, 0, 0, 0, 22, 4, 1, 59, 1, + 15, 13, 0, 18, 1, 20, 2, 13, 0, 18, 3, 3, 1, 2, 59, 1, 16, 0, 0, 0, + 0, 1, 0, 0, 1, 14, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 4, 2, + 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 7,112, 97,114,101,110,116, + 0, 2, 0, 0, 0, 9,111,118,101,114,108,111, 97,100, 0, 2, 0, 0, 0, 6, +108,110, 97,109,101, 0, 2, 0, 0, 0, 10, 95, 70,117,110, 99,116,105,111,110, + 0, 4, 0, 0, 1, 21, 0, 0, 0, 14, 64,102,117,110, 99,116,105,111,110, 46, +108,117, 97, 0, 0, 0, 0,231, 7, 1, 59, 1, 22, 13, 0, 11, 1, 15, 2, 26, + 59, 1, 23, 15, 3, 13, 0, 15, 4, 2, 0, 2, 59, 1, 25, 13, 0, 18, 5, 11, + 5, 31, 48, 7, 13, 0, 18, 5, 11, 6, 31, 52, 12, 59, 1, 26, 15, 7, 11, 8, + 2, 0, 1, 50, 3, 59, 1, 27, 59, 1, 29, 15, 9, 13, 0, 2, 0, 1, 59, 1, + 30, 13, 0, 20, 10, 2, 1, 1, 52,108, 59, 1, 31, 13, 0, 18, 11, 13, 0, 18, + 12, 18, 11, 32, 52, 46, 59, 1, 32, 13, 0, 11, 11, 11, 13, 26, 59, 1, 33, 13, + 0, 11, 14, 11, 13, 26, 59, 1, 34, 13, 0, 11, 15, 13, 0, 18, 12, 18, 11, 26, + 59, 1, 35, 13, 0, 11, 16, 11, 17, 26, 50, 44, 59, 1, 36, 13, 0, 18, 11, 11, + 18, 13, 0, 18, 12, 18, 11, 42, 32, 52, 22, 59, 1, 37, 13, 0, 11, 11, 11, 19, + 26, 59, 1, 38, 13, 0, 11, 14, 11, 19, 26, 50, 3, 59, 1, 39, 50, 3, 59, 1, + 40, 59, 1, 41, 13, 0, 11, 20, 13, 0, 20, 21, 11, 22, 2, 1, 2, 13, 0, 20, + 23, 13, 0, 2, 1, 2, 42, 26, 59, 1, 42, 13, 0, 1, 1, 59, 1, 43, 0, 0, + 0, 0, 1, 0, 0, 1, 21, 0, 0, 0, 2,116, 0, 0, 0, 0, 24, 2, 0, 0, + 0, 2,116, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 14, + 99,108, 97,115,115, 70,117,110, 99,116,105,111,110, 0, 2, 0, 0, 0, 7,115, +101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, + 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 6,101,114,114,111,114, 0, 2, 0, 0, 0, 31, 35,105,110,118, 97,108, +105,100, 32, 39, 99,111,110,115,116, 39, 32,115,112,101, 99,105,102,105, 99, 97, +116,105,111,110, 0, 2, 0, 0, 0, 7, 97,112,112,101,110,100, 0, 2, 0, 0, + 0, 8,105,110, 99,108, 97,115,115, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, + 2, 0, 0, 0, 7,112, 97,114,101,110,116, 0, 2, 0, 0, 0, 4,110,101,119, + 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 5,116,121,112, +101, 0, 2, 0, 0, 0, 4,112,116,114, 0, 2, 0, 0, 0, 2, 42, 0, 2, 0, + 0, 0, 2,126, 0, 2, 0, 0, 0, 7,100,101,108,101,116,101, 0, 2, 0, 0, + 0, 6, 99,110, 97,109,101, 0, 2, 0, 0, 0, 10, 99,102,117,110, 99,110, 97, +109,101, 0, 2, 0, 0, 0, 7,116,111,108,117, 97, 73, 0, 2, 0, 0, 0, 9, +111,118,101,114,108,111, 97,100, 0, 2, 0, 0, 0, 9, 70,117,110, 99,116,105, +111,110, 0, 4, 0, 0, 1, 49, 0, 0, 0, 14, 64,102,117,110, 99,116,105,111, +110, 46,108,117, 97, 0, 0, 0, 0,147, 11, 3, 59, 1, 50, 15, 4, 15, 5, 13, + 1, 7, 2, 9, 2, 2, 1, 3, 11, 6, 2, 1, 2, 59, 1, 51, 7, 1, 59, 1, + 52, 22, 1, 11, 9, 7, 0, 30, 0, 50, 50, 59, 1, 54, 13, 5, 11, 9, 13, 5, + 18, 9, 7, 1, 37, 26, 59, 1, 55, 13, 5, 13, 5, 18, 9, 15, 10, 13, 3, 13, + 4, 16, 11, 11, 2, 1, 2, 26, 59, 1, 56, 13, 4, 7, 1, 37, 23, 4, 59, 1, + 57, 59, 1, 53, 13, 3, 13, 4, 16, 54, 60, 59, 1, 58, 15, 10, 13, 0, 11, 13, + 2, 1, 2, 59, 1, 59, 13, 6, 11, 14, 13, 5, 26, 59, 1, 60, 13, 6, 11, 15, + 13, 2, 26, 59, 1, 61, 15, 16, 13, 6, 3, 7, 1, 59, 1, 62, 0, 0, 0, 0, + 7, 0, 0, 1, 49, 0, 0, 0, 2,100, 0, 0, 0, 1, 49, 0, 0, 0, 2, 97, + 0, 0, 0, 1, 49, 0, 0, 0, 2, 99, 0, 0, 0, 1, 50, 0, 0, 0, 2,116, + 0, 0, 0, 1, 51, 0, 0, 0, 2,105, 0, 0, 0, 1, 52, 0, 0, 0, 2,108, + 0, 0, 0, 1, 58, 0, 0, 0, 2,102, 0, 0, 0, 0, 17, 2, 0, 0, 0, 2, +100, 0, 2, 0, 0, 0, 2, 97, 0, 2, 0, 0, 0, 2, 99, 0, 2, 0, 0, 0, + 2,116, 0, 2, 0, 0, 0, 6,115,112,108,105,116, 0, 2, 0, 0, 0, 7,115, +116,114,115,117, 98, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 2,105, 0, + 2, 0, 0, 0, 2,108, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 12, 68, +101, 99,108, 97,114, 97,116,105,111,110, 0, 2, 0, 0, 0, 4,118, 97,114, 0, + 2, 0, 0, 0, 2,102, 0, 2, 0, 0, 0, 5,102,117,110, 99, 0, 2, 0, 0, + 0, 5, 97,114,103,115, 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, 0, + 0, 0, 10, 95, 70,117,110, 99,116,105,111,110, 0, +}; + +/* operator.lo */ +static char B14[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 14, 64,111,112,101,114, 97, +116,111,114, 46,108,117, 97, 0, 0, 0, 0,125, 21, 0, 60, 18, 22, 2, 60, 19, + 11, 1, 11, 2, 11, 3, 60, 20, 15, 4, 30, 1, 60, 21, 25, 0, 60, 22, 15, 5, + 15, 0, 15, 6, 2, 0, 2, 60, 25, 22, 10, 11, 8, 11, 9, 60, 26, 11, 10, 11, + 11, 60, 27, 11, 12, 11, 13, 60, 28, 11, 14, 11, 15, 60, 29, 11, 16, 11, 17, 60, + 30, 11, 18, 11, 19, 60, 31, 11, 20, 11, 21, 60, 32, 11, 22, 11, 23, 60, 33, 11, + 24, 11, 25, 60, 34, 11, 26, 11, 27, 30, 9, 60, 35, 25, 7, 60, 39, 15, 0, 11, + 28, 11, 29, 26, 60, 60, 11, 31, 25, 30, 60, 82, 11, 33, 25, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 34, 2, 0, 0, 0, 14, 99,108, 97,115,115, 79,112,101,114, 97, +116,111,114, 0, 2, 0, 0, 0, 5,107,105,110,100, 0, 2, 0, 0, 0, 1, 0, + 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 14, 99,108, 97,115, +115, 70,117,110, 99,116,105,111,110, 0, 2, 0, 0, 0, 7,115,101,116,116, 97, +103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, + 0, 4, 95, 84, 77, 0, 2, 0, 0, 0, 2, 43, 0, 2, 0, 0, 0, 13,111,112, +101,114, 97,116,111,114, 95, 97,100,100, 0, 2, 0, 0, 0, 2, 45, 0, 2, 0, + 0, 0, 13,111,112,101,114, 97,116,111,114, 95,115,117, 98, 0, 2, 0, 0, 0, + 2, 42, 0, 2, 0, 0, 0, 13,111,112,101,114, 97,116,111,114, 95,109,117,108, + 0, 2, 0, 0, 0, 2, 47, 0, 2, 0, 0, 0, 13,111,112,101,114, 97,116,111, +114, 95,100,105,118, 0, 2, 0, 0, 0, 2, 60, 0, 2, 0, 0, 0, 12,111,112, +101,114, 97,116,111,114, 95,108,116, 0, 2, 0, 0, 0, 2, 62, 0, 2, 0, 0, + 0, 12,111,112,101,114, 97,116,111,114, 95,103,116, 0, 2, 0, 0, 0, 3, 60, + 61, 0, 2, 0, 0, 0, 12,111,112,101,114, 97,116,111,114, 95,108,101, 0, 2, + 0, 0, 0, 3, 62, 61, 0, 2, 0, 0, 0, 12,111,112,101,114, 97,116,111,114, + 95,103,101, 0, 2, 0, 0, 0, 3, 91, 93, 0, 2, 0, 0, 0, 13,111,112,101, +114, 97,116,111,114, 95,103,101,116, 0, 2, 0, 0, 0, 4, 38, 91, 93, 0, 2, + 0, 0, 0, 13,111,112,101,114, 97,116,111,114, 95,115,101,116, 0, 2, 0, 0, + 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, 39, 0, 0, 0, 14, 64,111,112, +101,114, 97,116,111,114, 46,108,117, 97, 0, 0, 0, 1, 9, 8, 3, 60, 40, 15, + 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 41, 15, 2, 13, 1, 11, 4, 42, 13, 0, + 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 42, 15, 2, 13, 1, 11, 8, 42, 13, 0, + 18, 9, 42, 11, 7, 42, 2, 0, 1, 60, 43, 15, 2, 13, 1, 11, 10, 42, 13, 0, + 18, 11, 42, 11, 7, 42, 2, 0, 1, 60, 44, 15, 2, 13, 1, 11, 12, 42, 13, 0, + 18, 13, 42, 11, 7, 42, 2, 0, 1, 60, 45, 15, 2, 13, 1, 11, 14, 42, 13, 0, + 18, 15, 42, 11, 7, 42, 2, 0, 1, 60, 46, 15, 2, 13, 1, 11, 16, 42, 13, 0, + 18, 17, 42, 11, 7, 42, 2, 0, 1, 60, 47, 15, 2, 13, 1, 11, 18, 42, 13, 0, + 18, 19, 42, 11, 7, 42, 2, 0, 1, 60, 48, 15, 2, 13, 1, 11, 20, 42, 13, 0, + 18, 21, 42, 11, 7, 42, 2, 0, 1, 60, 49, 15, 2, 13, 1, 11, 22, 42, 2, 0, + 1, 60, 50, 7, 1, 50, 32, 60, 52, 13, 0, 18, 24, 13, 3, 16, 20, 2, 13, 1, + 11, 25, 42, 11, 26, 2, 0, 3, 60, 53, 13, 3, 7, 1, 37, 23, 3, 60, 54, 60, + 51, 13, 0, 18, 24, 13, 3, 16, 54, 43, 60, 55, 15, 2, 13, 1, 11, 27, 42, 2, + 0, 1, 60, 56, 15, 2, 13, 1, 11, 28, 42, 13, 2, 42, 2, 0, 1, 60, 57, 0, + 0, 0, 0, 4, 0, 0, 0, 39, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, + 39, 0, 0, 0, 6,105,100,101,110,116, 0, 0, 0, 0, 39, 0, 0, 0, 6, 99, +108,111,115,101, 0, 0, 0, 0, 50, 0, 0, 0, 2,105, 0, 0, 0, 0, 29, 2, + 0, 0, 0, 6,105,100,101,110,116, 0, 2, 0, 0, 0, 6, 99,108,111,115,101, + 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, 10, 79,112,101, +114, 97,116,111,114,123, 0, 2, 0, 0, 0, 11, 32,107,105,110,100, 32, 32, 61, + 32, 39, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5,107,105, +110,100, 0, 2, 0, 0, 0, 3, 39, 44, 0, 2, 0, 0, 0, 10, 32,109,111,100, + 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4,109,111,100, 0, 2, 0, 0, 0, 10, + 32,116,121,112,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,116,121,112,101, 0, + 2, 0, 0, 0, 10, 32,112,116,114, 32, 32, 61, 32, 39, 0, 2, 0, 0, 0, 4, +112,116,114, 0, 2, 0, 0, 0, 10, 32,110, 97,109,101, 32, 61, 32, 39, 0, 2, + 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, 0, 0, 11, 32, 99,111,110,115,116, + 32, 61, 32, 39, 0, 2, 0, 0, 0, 6, 99,111,110,115,116, 0, 2, 0, 0, 0, + 11, 32, 99,110, 97,109,101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 6, 99,110, 97, +109,101, 0, 2, 0, 0, 0, 11, 32,108,110, 97,109,101, 32, 61, 32, 39, 0, 2, + 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 10, 32, 97,114,103,115, + 32, 61, 32,123, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, 5, 97,114,103, +115, 0, 2, 0, 0, 0, 3, 32, 32, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, + 0, 3, 32,125, 0, 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 10, 95, 79,112, +101,114, 97,116,111,114, 0, 4, 0, 0, 0, 60, 0, 0, 0, 14, 64,111,112,101, +114, 97,116,111,114, 46,108,117, 97, 0, 0, 0, 0,140, 7, 1, 60, 61, 13, 0, + 11, 1, 15, 2, 26, 60, 62, 15, 3, 13, 0, 15, 4, 2, 0, 2, 60, 64, 13, 0, + 18, 5, 11, 5, 31, 48, 7, 13, 0, 18, 5, 11, 6, 31, 52, 11, 60, 65, 15, 7, + 11, 8, 2, 0, 1, 50, 2, 60, 66, 60, 68, 15, 9, 13, 0, 2, 0, 1, 60, 69, + 13, 0, 20, 10, 2, 1, 1, 44, 52, 11, 60, 70, 15, 7, 11, 11, 2, 0, 1, 50, + 2, 60, 71, 60, 73, 13, 0, 11, 12, 13, 0, 20, 13, 11, 14, 2, 1, 2, 13, 0, + 20, 15, 13, 0, 2, 1, 2, 42, 26, 60, 74, 13, 0, 11, 16, 13, 0, 18, 16, 13, + 0, 18, 17, 42, 26, 60, 75, 13, 0, 1, 1, 60, 76, 0, 0, 0, 0, 1, 0, 0, + 0, 60, 0, 0, 0, 2,116, 0, 0, 0, 0, 18, 2, 0, 0, 0, 2,116, 0, 2, + 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 14, 99,108, 97,115,115, + 79,112,101,114, 97,116,111,114, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, + 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, + 6, 99,111,110,115,116, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 6,101,114, +114,111,114, 0, 2, 0, 0, 0, 31, 35,105,110,118, 97,108,105,100, 32, 39, 99, +111,110,115,116, 39, 32,115,112,101, 99,105,102,105, 99, 97,116,105,111,110, 0, + 2, 0, 0, 0, 7, 97,112,112,101,110,100, 0, 2, 0, 0, 0, 8,105,110, 99, +108, 97,115,115, 0, 2, 0, 0, 0, 46, 35,111,112,101,114, 97,116,111,114, 32, + 99, 97,110, 32,111,110,108,121, 32, 98,101, 32,100,101,102,105,110,101,100, 32, + 97,115, 32, 99,108, 97,115,115, 32,109,101,109, 98,101,114, 0, 2, 0, 0, 0, + 6, 99,110, 97,109,101, 0, 2, 0, 0, 0, 10, 99,102,117,110, 99,110, 97,109, +101, 0, 2, 0, 0, 0, 7,116,111,108,117, 97, 73, 0, 2, 0, 0, 0, 9,111, +118,101,114,108,111, 97,100, 0, 2, 0, 0, 0, 5,110, 97,109,101, 0, 2, 0, + 0, 0, 5,107,105,110,100, 0, 2, 0, 0, 0, 9, 79,112,101,114, 97,116,111, +114, 0, 4, 0, 0, 0, 82, 0, 0, 0, 14, 64,111,112,101,114, 97,116,111,114, + 46,108,117, 97, 0, 0, 0, 1, 99, 14, 4, 60, 83, 15, 5, 15, 6, 13, 2, 7, + 2, 15, 7, 13, 2, 2, 1, 1, 7, 1, 38, 2, 1, 3, 11, 8, 2, 1, 2, 60, + 84, 7, 1, 60, 85, 22, 1, 11, 11, 7, 0, 30, 0, 50, 46, 60, 87, 13, 6, 11, + 11, 13, 6, 18, 11, 7, 1, 37, 26, 60, 88, 13, 6, 13, 6, 18, 11, 15, 12, 13, + 4, 13, 5, 16, 11, 13, 2, 1, 2, 26, 60, 89, 13, 5, 7, 1, 37, 23, 5, 60, + 90, 60, 86, 13, 4, 13, 5, 16, 54, 55, 60, 91, 13, 1, 11, 14, 32, 52, 17, 60, + 92, 15, 15, 13, 0, 11, 16, 11, 17, 2, 1, 3, 23, 0, 50, 59, 60, 93, 13, 1, + 11, 18, 32, 52, 48, 60, 94, 13, 6, 11, 11, 13, 6, 18, 11, 7, 1, 37, 26, 60, + 95, 13, 6, 13, 6, 18, 11, 15, 12, 13, 0, 11, 13, 2, 1, 2, 26, 60, 96, 13, + 6, 13, 6, 18, 11, 16, 11, 19, 11, 20, 26, 50, 2, 60, 97, 60, 98, 15, 12, 13, + 0, 11, 22, 2, 1, 2, 60, 99, 13, 1, 11, 14, 32, 48, 25, 13, 6, 7, 1, 16, + 4, 0, 32, 46, 15, 15, 23, 13, 6, 7, 1, 16, 18, 24, 2, 1, 1, 11, 25, 31, + 52, 11, 60,100, 15, 26, 11, 27, 2, 0, 1, 50, 2, 60,101, 60,102, 13, 7, 11, + 28, 13, 6, 26, 60,103, 13, 7, 11, 29, 13, 3, 26, 60,104, 13, 7, 11, 30, 15, + 15, 13, 1, 11, 31, 11, 17, 2, 1, 3, 26, 60,105, 13, 7, 11, 32, 15, 33, 13, + 7, 18, 30, 16, 26, 60,106, 13, 7, 18, 30, 11, 14, 32, 48, 12, 15, 34, 13, 7, + 18, 35, 11, 29, 2, 1, 2, 44, 52, 20, 60,107, 15, 36, 13, 0, 11, 16, 13, 1, + 42, 13, 2, 13, 3, 2, 0, 4, 50, 2, 60,108, 60,109, 15, 37, 13, 7, 3, 8, + 1, 60,110, 0, 0, 0, 0, 8, 0, 0, 0, 82, 0, 0, 0, 2,100, 0, 0, 0, + 0, 82, 0, 0, 0, 2,107, 0, 0, 0, 0, 82, 0, 0, 0, 2, 97, 0, 0, 0, + 0, 82, 0, 0, 0, 2, 99, 0, 0, 0, 0, 83, 0, 0, 0, 2,116, 0, 0, 0, + 0, 84, 0, 0, 0, 2,105, 0, 0, 0, 0, 85, 0, 0, 0, 2,108, 0, 0, 0, + 0, 98, 0, 0, 0, 2,102, 0, 0, 0, 0, 38, 2, 0, 0, 0, 2,100, 0, 2, + 0, 0, 0, 2,107, 0, 2, 0, 0, 0, 2, 97, 0, 2, 0, 0, 0, 2, 99, 0, + 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6,115,112,108,105,116, 0, 2, 0, + 0, 0, 7,115,116,114,115,117, 98, 0, 2, 0, 0, 0, 7,115,116,114,108,101, +110, 0, 2, 0, 0, 0, 2, 44, 0, 2, 0, 0, 0, 2,105, 0, 2, 0, 0, 0, + 2,108, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 12, 68,101, 99,108, 97, +114, 97,116,105,111,110, 0, 2, 0, 0, 0, 4,118, 97,114, 0, 2, 0, 0, 0, + 3, 91, 93, 0, 2, 0, 0, 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, 2, 38, + 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 4, 38, 91, 93, 0, 2, 0, 0, 0, + 5,110, 97,109,101, 0, 2, 0, 0, 0, 13,116,111,108,117, 97, 73, 95,118, 97, +108,117,101, 0, 2, 0, 0, 0, 2,102, 0, 2, 0, 0, 0, 5,102,117,110, 99, + 0, 2, 0, 0, 0, 8,105,115, 98, 97,115,105, 99, 0, 2, 0, 0, 0, 5,116, +121,112,101, 0, 2, 0, 0, 0, 7,110,117,109, 98,101,114, 0, 2, 0, 0, 0, + 6,101,114,114,111,114, 0, 2, 0, 0, 0, 50,111,112,101,114, 97,116,111,114, + 91, 93, 32, 99, 97,110, 32,111,110,108,121, 32, 98,101, 32,100,101,102,105,110, +101,100, 32,102,111,114, 32,110,117,109,101,114,105, 99, 32,105,110,100,101,120, + 46, 0, 2, 0, 0, 0, 5, 97,114,103,115, 0, 2, 0, 0, 0, 6, 99,111,110, +115,116, 0, 2, 0, 0, 0, 5,107,105,110,100, 0, 2, 0, 0, 0, 3, 37,115, + 0, 2, 0, 0, 0, 6,108,110, 97,109,101, 0, 2, 0, 0, 0, 4, 95, 84, 77, + 0, 2, 0, 0, 0, 8,115,116,114,102,105,110,100, 0, 2, 0, 0, 0, 4,109, +111,100, 0, 2, 0, 0, 0, 9, 79,112,101,114, 97,116,111,114, 0, 2, 0, 0, + 0, 10, 95, 79,112,101,114, 97,116,111,114, 0, +}; + +/* verbatim.lo */ +static char B15[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 14, 64,118,101,114, 98, 97, +116,105,109, 46,108,117, 97, 0, 0, 0, 0, 84, 5, 0, 60, 20, 22, 2, 60, 21, + 11, 1, 11, 2, 11, 3, 60, 22, 15, 4, 30, 1, 60, 23, 25, 0, 60, 24, 15, 5, + 15, 0, 15, 6, 2, 0, 2, 60, 27, 15, 0, 11, 7, 11, 8, 26, 60, 34, 15, 0, + 11, 9, 11, 10, 26, 60, 42, 15, 0, 11, 11, 11, 12, 26, 60, 50, 15, 0, 11, 13, + 11, 14, 26, 60, 58, 11, 16, 25, 15, 60, 67, 11, 18, 25, 17, 0, 0, 0, 0, 0, + 0, 0, 0, 19, 2, 0, 0, 0, 14, 99,108, 97,115,115, 86,101,114, 98, 97,116, +105,109, 0, 2, 0, 0, 0, 5,108,105,110,101, 0, 2, 0, 0, 0, 1, 0, 2, + 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, + 70,101, 97,116,117,114,101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, + 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 9, +112,114,101, 97,109, 98,108,101, 0, 4, 0, 0, 0, 27, 0, 0, 0, 14, 64,118, +101,114, 98, 97,116,105,109, 46,108,117, 97, 0, 0, 0, 0, 29, 3, 1, 60, 28, + 13, 0, 18, 1, 44, 52, 13, 60, 29, 15, 2, 13, 0, 18, 3, 2, 0, 1, 50, 2, + 60, 30, 60, 31, 0, 0, 0, 0, 1, 0, 0, 0, 27, 0, 0, 0, 5,115,101,108, +102, 0, 0, 0, 0, 4, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, + 5, 99,111,110,100, 0, 2, 0, 0, 0, 6,119,114,105,116,101, 0, 2, 0, 0, + 0, 5,108,105,110,101, 0, 2, 0, 0, 0, 8,115,117,112, 99,111,100,101, 0, + 4, 0, 0, 0, 34, 0, 0, 0, 14, 64,118,101,114, 98, 97,116,105,109, 46,108, +117, 97, 0, 0, 0, 0, 37, 3, 1, 60, 35, 13, 0, 18, 1, 52, 22, 60, 36, 15, + 2, 13, 0, 18, 3, 2, 0, 1, 60, 37, 15, 2, 11, 4, 2, 0, 1, 50, 2, 60, + 38, 60, 39, 0, 0, 0, 0, 1, 0, 0, 0, 34, 0, 0, 0, 5,115,101,108,102, + 0, 0, 0, 0, 5, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5, + 99,111,110,100, 0, 2, 0, 0, 0, 6,119,114,105,116,101, 0, 2, 0, 0, 0, + 5,108,105,110,101, 0, 2, 0, 0, 0, 2, 10, 0, 2, 0, 0, 0, 9,114,101, +103,105,115,116,101,114, 0, 4, 0, 0, 0, 42, 0, 0, 0, 14, 64,118,101,114, + 98, 97,116,105,109, 46,108,117, 97, 0, 0, 0, 0, 28, 3, 1, 60, 43, 13, 0, + 18, 1, 52, 13, 60, 44, 15, 2, 13, 0, 18, 3, 2, 0, 1, 50, 2, 60, 45, 60, + 46, 0, 0, 0, 0, 1, 0, 0, 0, 42, 0, 0, 0, 5,115,101,108,102, 0, 0, + 0, 0, 4, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, 5, 99,111, +110,100, 0, 2, 0, 0, 0, 6,119,114,105,116,101, 0, 2, 0, 0, 0, 5,108, +105,110,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 4, 0, 0, 0, 50, + 0, 0, 0, 14, 64,118,101,114, 98, 97,116,105,109, 46,108,117, 97, 0, 0, 0, + 0, 52, 6, 3, 60, 51, 15, 2, 13, 1, 11, 3, 42, 2, 0, 1, 60, 52, 15, 2, + 13, 1, 11, 4, 42, 13, 0, 18, 6, 42, 11, 7, 42, 2, 0, 1, 60, 53, 15, 2, + 13, 1, 11, 8, 42, 13, 2, 42, 2, 0, 1, 60, 54, 0, 0, 0, 0, 3, 0, 0, + 0, 50, 0, 0, 0, 5,115,101,108,102, 0, 0, 0, 0, 50, 0, 0, 0, 6,105, +100,101,110,116, 0, 0, 0, 0, 50, 0, 0, 0, 6, 99,108,111,115,101, 0, 0, + 0, 0, 9, 2, 0, 0, 0, 6,105,100,101,110,116, 0, 2, 0, 0, 0, 6, 99, +108,111,115,101, 0, 2, 0, 0, 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, + 10, 86,101,114, 98, 97,116,105,109,123, 0, 2, 0, 0, 0, 10, 32,108,105,110, +101, 32, 61, 32, 39, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, 2, 0, 0, 0, + 5,108,105,110,101, 0, 2, 0, 0, 0, 3, 39, 44, 0, 2, 0, 0, 0, 2,125, + 0, 2, 0, 0, 0, 10, 95, 86,101,114, 98, 97,116,105,109, 0, 4, 0, 0, 0, + 58, 0, 0, 0, 14, 64,118,101,114, 98, 97,116,105,109, 46,108,117, 97, 0, 0, + 0, 0, 40, 4, 1, 60, 59, 13, 0, 11, 1, 15, 2, 26, 60, 60, 15, 3, 13, 0, + 15, 4, 2, 0, 2, 60, 61, 15, 5, 13, 0, 2, 0, 1, 60, 62, 13, 0, 1, 1, + 60, 63, 0, 0, 0, 0, 1, 0, 0, 0, 58, 0, 0, 0, 2,116, 0, 0, 0, 0, + 6, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, + 0, 0, 0, 14, 99,108, 97,115,115, 86,101,114, 98, 97,116,105,109, 0, 2, 0, + 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, + 95,116, 97,103, 0, 2, 0, 0, 0, 7, 97,112,112,101,110,100, 0, 2, 0, 0, + 0, 9, 86,101,114, 98, 97,116,105,109, 0, 4, 0, 0, 0, 67, 0, 0, 0, 14, + 64,118,101,114, 98, 97,116,105,109, 46,108,117, 97, 0, 0, 0, 0, 75, 8, 1, + 60, 68, 4, 0, 60, 69, 15, 2, 13, 0, 7, 1, 7, 1, 2, 1, 3, 11, 3, 32, + 52, 21, 60, 70, 7, 1, 23, 1, 60, 71, 15, 2, 13, 0, 7, 2, 2, 1, 2, 23, + 0, 50, 2, 60, 72, 60, 73, 15, 4, 22, 2, 60, 74, 11, 5, 13, 0, 11, 6, 60, + 75, 13, 1, 30, 1, 60, 76, 3, 2, 1, 60, 77, 0, 0, 0, 0, 2, 0, 0, 0, + 67, 0, 0, 0, 2,108, 0, 0, 0, 0, 68, 0, 0, 0, 2, 99, 0, 0, 0, 0, + 7, 2, 0, 0, 0, 2,108, 0, 2, 0, 0, 0, 2, 99, 0, 2, 0, 0, 0, 7, +115,116,114,115,117, 98, 0, 2, 0, 0, 0, 2, 36, 0, 2, 0, 0, 0, 10, 95, + 86,101,114, 98, 97,116,105,109, 0, 2, 0, 0, 0, 5,108,105,110,101, 0, 2, + 0, 0, 0, 5, 99,111,110,100, 0, +}; + +/* code.lo */ +static char B16[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 10, 64, 99,111,100,101, 46, +108,117, 97, 0, 0, 0, 0, 66, 5, 0, 60, 19, 22, 2, 60, 20, 11, 1, 11, 2, + 11, 3, 60, 21, 15, 4, 30, 1, 60, 22, 25, 0, 60, 23, 15, 5, 15, 0, 15, 6, + 2, 0, 2, 60, 26, 15, 0, 11, 7, 11, 8, 26, 60, 63, 15, 0, 11, 9, 11, 10, + 26, 60, 71, 11, 12, 25, 11, 60, 80, 11, 14, 25, 13, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 2, 0, 0, 0, 10, 99,108, 97,115,115, 67,111,100,101, 0, 2, 0, 0, + 0, 5,116,101,120,116, 0, 2, 0, 0, 0, 1, 0, 2, 0, 0, 0, 6, 95, 98, + 97,115,101, 0, 2, 0, 0, 0, 13, 99,108, 97,115,115, 70,101, 97,116,117,114, +101, 0, 2, 0, 0, 0, 7,115,101,116,116, 97,103, 0, 2, 0, 0, 0, 10,116, +111,108,117, 97, 95,116, 97,103, 0, 2, 0, 0, 0, 9,114,101,103,105,115,116, +101,114, 0, 4, 0, 0, 0, 26, 0, 0, 0, 10, 64, 99,111,100,101, 46,108,117, + 97, 0, 0, 0, 0,239, 13, 1, 60, 27, 15, 1, 2, 1, 0, 60, 28, 15, 1, 2, + 1, 0, 60, 29, 15, 4, 13, 2, 11, 5, 2, 1, 2, 60, 30, 13, 3, 44, 52, 11, + 60, 31, 15, 6, 11, 7, 2, 0, 1, 50, 2, 60, 32, 60, 34, 15, 8, 13, 3, 13, + 0, 18, 10, 2, 0, 2, 60, 35, 15, 11, 13, 3, 2, 0, 1, 60, 36, 15, 12, 11, + 13, 13, 1, 42, 11, 14, 42, 13, 2, 42, 2, 0, 1, 60, 37, 15, 15, 13, 2, 2, + 0, 1, 60, 40, 15, 4, 13, 1, 11, 17, 2, 1, 2, 60, 41, 13, 4, 4, 0, 32, + 52, 11, 60, 42, 15, 6, 11, 7, 2, 0, 1, 50, 2, 60, 43, 60, 44, 15, 19, 13, + 4, 11, 20, 2, 1, 2, 60, 45, 15, 11, 13, 4, 2, 0, 1, 60, 46, 15, 15, 13, + 1, 2, 0, 1, 60, 48, 15, 21, 11, 22, 2, 0, 1, 60, 49, 15, 21, 11, 23, 2, + 0, 1, 60, 50, 22, 1, 11, 2, 7, 0, 30, 0, 60, 51, 15, 21, 15, 25, 13, 5, + 11, 26, 13, 6, 58, 27, 1, 60, 55, 2, 1, 3, 2, 0, 1, 60, 56, 15, 21, 11, + 28, 2, 0, 1, 60, 57, 15, 21, 11, 29, 2, 0, 1, 60, 58, 15, 21, 11, 30, 2, + 0, 1, 60, 59, 0, 0, 0, 0, 7, 0, 0, 0, 26, 0, 0, 0, 5,115,101,108, +102, 0, 0, 0, 0, 27, 0, 0, 0, 2,111, 0, 0, 0, 0, 28, 0, 0, 0, 2, +110, 0, 0, 0, 0, 29, 0, 0, 0, 2,102, 0, 0, 0, 0, 40, 0, 0, 0, 3, +102,112, 0, 0, 0, 0, 44, 0, 0, 0, 2,115, 0, 0, 0, 0, 50, 0, 0, 0, + 2,116, 0, 0, 0, 0, 31, 2, 0, 0, 0, 2,111, 0, 2, 0, 0, 0, 8,116, +109,112,110, 97,109,101, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, 2,102, + 0, 2, 0, 0, 0, 9,111,112,101,110,102,105,108,101, 0, 2, 0, 0, 0, 2, +119, 0, 2, 0, 0, 0, 6,101,114,114,111,114, 0, 2, 0, 0, 0, 61, 10, 32, + 32, 32, 99, 97,110,110,111,116, 32,111,112,101,110, 32,116,101,109,112,111,114, + 97,114,121, 32,102,105,108,101, 32,116,111, 32,112,114,111, 99, 99,101,115,115, + 32,101,109, 98,101,100,100,101,100, 32, 76,117, 97, 32, 99,111,100,101, 0, 2, + 0, 0, 0, 6,119,114,105,116,101, 0, 2, 0, 0, 0, 5,115,101,108,102, 0, + 2, 0, 0, 0, 5,116,101,120,116, 0, 2, 0, 0, 0, 10, 99,108,111,115,101, +102,105,108,101, 0, 2, 0, 0, 0, 8,101,120,101, 99,117,116,101, 0, 2, 0, + 0, 0, 9,108,117, 97, 99, 32, 45,111, 32, 0, 2, 0, 0, 0, 2, 32, 0, 2, + 0, 0, 0, 7,114,101,109,111,118,101, 0, 2, 0, 0, 0, 3,102,112, 0, 2, + 0, 0, 0, 3,114, 98, 0, 2, 0, 0, 0, 2,115, 0, 2, 0, 0, 0, 5,114, +101, 97,100, 0, 2, 0, 0, 0, 3, 46, 42, 0, 2, 0, 0, 0, 7,111,117,116, +112,117,116, 0, 2, 0, 0, 0, 35, 10, 32,123, 32, 47, 42, 32, 98,101,103,105, +110, 32,101,109, 98,101,100,100,101,100, 32,108,117, 97, 32, 99,111,100,101, 32, + 42, 47, 10, 0, 2, 0, 0, 0, 35, 32, 32,115,116, 97,116,105, 99, 32,117,110, +115,105,103,110,101,100, 32, 99,104, 97,114, 32, 66, 91, 93, 32, 61, 32,123, 10, + 32, 32, 32, 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 5,103,115,117, 98, + 0, 2, 0, 0, 0, 4, 40, 46, 41, 0, 4, 0, 0, 0, 51, 0, 0, 0, 10, 64, + 99,111,100,101, 46,108,117, 97, 0, 0, 0, 0, 61, 6, 1, 60, 52, 11, 2, 60, + 53, 12, 0, 11, 4, 12, 0, 18, 4, 7, 1, 37, 26, 12, 0, 18, 4, 7, 20, 32, + 52, 11, 12, 0, 11, 4, 7, 0, 26, 11, 5, 23, 1, 60, 54, 15, 6, 11, 7, 15, + 8, 13, 0, 2, 1, 1, 13, 1, 3, 2, 3, 60, 55, 0, 0, 0, 0, 2, 0, 0, + 0, 51, 0, 0, 0, 2, 99, 0, 0, 0, 0, 52, 0, 0, 0, 2,101, 0, 0, 0, + 0, 9, 2, 0, 0, 0, 2, 99, 0, 2, 0, 0, 0, 2,101, 0, 2, 0, 0, 0, + 1, 0, 2, 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, 0, 0, + 5, 10, 32, 32, 32, 0, 2, 0, 0, 0, 7,102,111,114,109, 97,116, 0, 2, 0, + 0, 0, 7, 37, 51,117, 44, 37,115, 0, 2, 0, 0, 0, 8,115,116,114, 98,121, +116,101, 0, 2, 0, 0, 0, 6, 32, 32,125, 59, 10, 0, 2, 0, 0, 0, 56, 32, + 32,108,117, 97, 95,100,111, 98,117,102,102,101,114, 40, 66, 44,115,105,122,101, +111,102, 40, 66, 41, 44, 34,116,111,108,117, 97, 58, 32,101,109, 98,101,100,100, +101,100, 32, 76,117, 97, 32, 99,111,100,101, 34, 41, 59, 0, 2, 0, 0, 0, 36, + 32,125, 32, 47, 42, 32,101,110,100, 32,111,102, 32,101,109, 98,101,100,100,101, +100, 32,108,117, 97, 32, 99,111,100,101, 32, 42, 47, 10, 10, 0, 2, 0, 0, 0, + 6,112,114,105,110,116, 0, 4, 0, 0, 0, 63, 0, 0, 0, 10, 64, 99,111,100, +101, 46,108,117, 97, 0, 0, 0, 0, 52, 6, 3, 60, 64, 15, 2, 13, 1, 11, 3, + 42, 2, 0, 1, 60, 65, 15, 2, 13, 1, 11, 4, 42, 13, 0, 18, 6, 42, 11, 7, + 42, 2, 0, 1, 60, 66, 15, 2, 13, 1, 11, 8, 42, 13, 2, 42, 2, 0, 1, 60, + 67, 0, 0, 0, 0, 3, 0, 0, 0, 63, 0, 0, 0, 5,115,101,108,102, 0, 0, + 0, 0, 63, 0, 0, 0, 6,105,100,101,110,116, 0, 0, 0, 0, 63, 0, 0, 0, + 6, 99,108,111,115,101, 0, 0, 0, 0, 9, 2, 0, 0, 0, 6,105,100,101,110, +116, 0, 2, 0, 0, 0, 6, 99,108,111,115,101, 0, 2, 0, 0, 0, 6,112,114, +105,110,116, 0, 2, 0, 0, 0, 6, 67,111,100,101,123, 0, 2, 0, 0, 0, 11, + 32,116,101,120,116, 32, 61, 32, 91, 91, 0, 2, 0, 0, 0, 5,115,101,108,102, + 0, 2, 0, 0, 0, 5,116,101,120,116, 0, 2, 0, 0, 0, 4, 93, 93, 44, 0, + 2, 0, 0, 0, 2,125, 0, 2, 0, 0, 0, 6, 95, 67,111,100,101, 0, 4, 0, + 0, 0, 71, 0, 0, 0, 10, 64, 99,111,100,101, 46,108,117, 97, 0, 0, 0, 0, + 40, 4, 1, 60, 72, 13, 0, 11, 1, 15, 2, 26, 60, 73, 15, 3, 13, 0, 15, 4, + 2, 0, 2, 60, 74, 15, 5, 13, 0, 2, 0, 1, 60, 75, 13, 0, 1, 1, 60, 76, + 0, 0, 0, 0, 1, 0, 0, 0, 71, 0, 0, 0, 2,116, 0, 0, 0, 0, 6, 2, + 0, 0, 0, 2,116, 0, 2, 0, 0, 0, 6, 95, 98, 97,115,101, 0, 2, 0, 0, + 0, 10, 99,108, 97,115,115, 67,111,100,101, 0, 2, 0, 0, 0, 7,115,101,116, +116, 97,103, 0, 2, 0, 0, 0, 10,116,111,108,117, 97, 95,116, 97,103, 0, 2, + 0, 0, 0, 7, 97,112,112,101,110,100, 0, 2, 0, 0, 0, 5, 67,111,100,101, + 0, 4, 0, 0, 0, 80, 0, 0, 0, 10, 64, 99,111,100,101, 46,108,117, 97, 0, + 0, 0, 0, 24, 5, 1, 60, 81, 15, 1, 22, 1, 60, 82, 11, 2, 13, 0, 30, 0, + 60, 83, 3, 1, 1, 60, 84, 0, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 2, +108, 0, 0, 0, 0, 3, 2, 0, 0, 0, 2,108, 0, 2, 0, 0, 0, 6, 95, 67, +111,100,101, 0, 2, 0, 0, 0, 5,116,101,120,116, 0, +}; + +/* doit.lo */ +static char B17[]={ + 27, 76,117, 97, 50, 0, 0, 0, 0, 0, 0, 0, 0, 10, 64,100,111,105,116, 46, +108,117, 97, 0, 0, 0, 1, 92, 6, 0, 60, 17, 15, 0, 18, 1, 52, 38, 60, 18, + 15, 4, 15, 0, 18, 1, 2, 2, 1, 60, 19, 13, 0, 44, 52, 14, 60, 20, 15, 5, + 11, 6, 13, 1, 42, 2, 0, 1, 50, 2, 60, 21, 5, 2, 50, 2, 60, 22, 60, 25, + 15, 0, 18, 7, 44, 52, 43, 60, 26, 15, 0, 18, 1, 52, 22, 60, 27, 15, 0, 11, + 7, 15, 8, 15, 0, 18, 1, 11, 9, 11, 10, 2, 1, 3, 26, 50, 11, 60, 29, 15, + 5, 11, 11, 2, 0, 1, 60, 30, 50, 2, 60, 31, 60, 33, 15, 13, 15, 0, 18, 7, + 2, 1, 1, 60, 35, 15, 0, 18, 1, 52, 9, 60, 36, 15, 4, 2, 0, 0, 50, 2, + 60, 37, 60, 39, 15, 0, 18, 12, 52, 4, 60, 41, 1, 1, 60, 43, 15, 0, 18, 14, + 52, 38, 60, 44, 15, 15, 15, 0, 18, 14, 2, 2, 1, 60, 45, 13, 1, 44, 52, 14, + 60, 46, 15, 5, 11, 6, 13, 2, 42, 2, 0, 1, 50, 2, 60, 47, 5, 2, 50, 2, + 60, 48, 60, 50, 15, 0, 18, 16, 52, 11, 60, 51, 13, 0, 20, 17, 2, 0, 1, 50, + 38, 60, 53, 13, 0, 20, 18, 2, 0, 1, 60, 54, 13, 0, 20, 19, 2, 0, 1, 60, + 55, 13, 0, 20, 20, 2, 0, 1, 60, 56, 13, 0, 20, 21, 2, 0, 1, 60, 57, 60, + 59, 15, 0, 18, 14, 52, 9, 60, 60, 15, 15, 2, 0, 0, 50, 2, 60, 61, 60, 64, + 15, 0, 18, 16, 44, 52, 66, 60, 65, 15, 0, 18, 22, 52, 54, 60, 66, 15, 15, 15, + 0, 18, 22, 2, 2, 1, 60, 67, 13, 1, 44, 52, 14, 60, 68, 15, 5, 11, 6, 13, + 2, 42, 2, 0, 1, 50, 2, 60, 69, 60, 70, 13, 0, 20, 23, 2, 0, 1, 60, 71, + 15, 15, 2, 0, 0, 5, 2, 50, 2, 60, 72, 50, 2, 60, 73, 0, 0, 0, 0, 0, + 0, 0, 0, 24, 2, 0, 0, 0, 6,102,108, 97,103,115, 0, 2, 0, 0, 0, 2, +102, 0, 2, 0, 0, 0, 3,115,116, 0, 2, 0, 0, 0, 4,109,115,103, 0, 2, + 0, 0, 0, 9,114,101, 97,100,102,114,111,109, 0, 2, 0, 0, 0, 6,101,114, +114,111,114, 0, 2, 0, 0, 0, 2, 35, 0, 2, 0, 0, 0, 2,110, 0, 2, 0, + 0, 0, 5,103,115,117, 98, 0, 2, 0, 0, 0, 5, 37, 46, 46, 42, 0, 2, 0, + 0, 0, 1, 0, 2, 0, 0, 0, 41, 35,110,111, 32,112, 97, 99,107, 97,103,101, + 32,110, 97,109,101, 32,110,111,114, 32,105,110,112,117,116, 32,102,105,108,101, + 32,112,114,111,118,105,100,101,100, 0, 2, 0, 0, 0, 2,112, 0, 2, 0, 0, + 0, 8, 80, 97, 99,107, 97,103,101, 0, 2, 0, 0, 0, 2,111, 0, 2, 0, 0, + 0, 8,119,114,105,116,101,116,111, 0, 2, 0, 0, 0, 2, 80, 0, 2, 0, 0, + 0, 6,112,114,105,110,116, 0, 2, 0, 0, 0, 9,112,114,101, 97,109, 98,108, +101, 0, 2, 0, 0, 0, 8,115,117,112, 99,111,100,101, 0, 2, 0, 0, 0, 9, +114,101,103,105,115,116,101,114, 0, 2, 0, 0, 0, 11,117,110,114,101,103,105, +115,116,101,114, 0, 2, 0, 0, 0, 2, 72, 0, 2, 0, 0, 0, 7,104,101, 97, +100,101,114, 0, +}; + + lua_dobuffer(B1,sizeof(B1),"basic.lo"); + lua_dobuffer(B2,sizeof(B2),"feature.lo"); + lua_dobuffer(B3,sizeof(B3),"declaration.lo"); + lua_dobuffer(B4,sizeof(B4),"container.lo"); + lua_dobuffer(B5,sizeof(B5),"package.lo"); + lua_dobuffer(B6,sizeof(B6),"module.lo"); + lua_dobuffer(B7,sizeof(B7),"class.lo"); + lua_dobuffer(B8,sizeof(B8),"typedef.lo"); + lua_dobuffer(B9,sizeof(B9),"define.lo"); + lua_dobuffer(B10,sizeof(B10),"enumerate.lo"); + lua_dobuffer(B11,sizeof(B11),"variable.lo"); + lua_dobuffer(B12,sizeof(B12),"array.lo"); + lua_dobuffer(B13,sizeof(B13),"function.lo"); + lua_dobuffer(B14,sizeof(B14),"operator.lo"); + lua_dobuffer(B15,sizeof(B15),"verbatim.lo"); + lua_dobuffer(B16,sizeof(B16),"code.lo"); + lua_dobuffer(B17,sizeof(B17),"doit.lo"); +} diff --git a/src/lua/tolualua.pkg b/src/lua/tolualua.pkg new file mode 100644 index 00000000..1694c2c1 --- /dev/null +++ b/src/lua/tolualua.pkg @@ -0,0 +1,21 @@ +$[ +$<basic.lua> +$<feature.lua> +$<verbatim.lua> +$<code.lua> +$<typedef.lua> +$<container.lua> +$<package.lua> +$<module.lua> +$<define.lua> +$<enumerate.lua> +$<declaration.lua> +$<variable.lua> +$<array.lua> +$<function.lua> +$<operator.lua> +$<class.lua> +$<clean.lua> +$<doit.lua> +$] + diff --git a/src/lua/typedef.lua b/src/lua/typedef.lua new file mode 100644 index 00000000..1633f3e6 --- /dev/null +++ b/src/lua/typedef.lua @@ -0,0 +1,59 @@ +-- tolua: typedef class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: typedef.lua,v 1.2 2001/11/26 23:00:27 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + + +-- Typedef class +-- Represents a type synonym. +-- The 'de facto' type replaces the typedef before the +-- remaining code is parsed. +-- The following fields are stored: +-- utype = typedef name +-- type = 'de facto' type +-- mod = modifiers to the 'de facto' type +classTypedef = { + utype = '', + mod = '', + type = '' +} + +-- Print method +function classTypedef:print (ident,close) + print(ident.."Typedef{") + print(ident.." utype = '"..self.utype.."',") + print(ident.." mod = '"..self.mod.."',") + print(ident.." type = '"..self.type.."',") + print(ident.."}"..close) +end + +-- Internal constructor +function _Typedef (t) + t._base = classTypedef + settag(t,tolua_tag) + appendtypedef(t) + return t +end + +-- Constructor +-- Expects one string representing the type definition. +function Typedef (s) + if strfind(s,'[%*&]') then + tolua_error("#invalid typedef: pointers (and references) are not supported") + end + local t = split(gsub(s,"%s%s*"," ")," ") + return _Typedef { + utype = t[t.n], + type = t[t.n-1], + mod = concat(t,1,t.n-2) + } +end + + diff --git a/src/lua/variable.lua b/src/lua/variable.lua new file mode 100644 index 00000000..310808b8 --- /dev/null +++ b/src/lua/variable.lua @@ -0,0 +1,192 @@ +-- tolua: variable class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: variable.lua,v 1.4 2004/06/04 13:42:10 neil Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + +-- Variable class +-- Represents a extern variable or a public member of a class. +-- Stores all fields present in a declaration. +classVariable = { + _base = classDeclaration, +} + +settag(classVariable,tolua_tag) + +-- Print method +function classVariable:print (ident,close) + print(ident.."Variable{") + print(ident.." mod = '"..self.mod.."',") + print(ident.." type = '"..self.type.."',") + print(ident.." ptr = '"..self.ptr.."',") + print(ident.." name = '"..self.name.."',") + print(ident.." def = '"..self.def.."',") + print(ident.." ret = '"..self.ret.."',") + print(ident.."}"..close) +end + +-- get variable value +function classVariable:getvalue (class,static) + if class and static then + return class..'::'..self.name + elseif class then + return 'self->'..self.name + else + return self.name + end +end + +-- Write binding functions +function classVariable:supcode () + local class = self:inclass() + + -- get function ------------------------------------------------ + if class then + output("/* get function:",self.name," of class ",class," */") + else + output("/* get function:",self.name," */") + end + self.cgetname = self:cfuncname("toluaI_get") + output("static int",self.cgetname,"(lua_State* tolua_S)") + output("{") + + -- declare self, if the case + local _,_,static = strfind(self.mod,'^%s*(static)') + if class and static==nil then + output(' ',class,'*','self = ') + output('(',class,'*) ') + output('tolua_getusertype(tolua_S,1,0);') + elseif static then + _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)') + end + + + -- check self value + if class and static==nil then + output(' if (!self) TOLUA_ERR_SELF;'); + end + + -- return value + local t,ct = isbasic(self.type) + if t then + output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static)..');') + else + if self.ptr == '&' or self.ptr == '' then + output(' tolua_pushusertype(tolua_S,(void*)&'..self:getvalue(class,static)..',',self.tag,');') + else + output(' tolua_pushusertype(tolua_S,(void*)'..self:getvalue(class,static)..',',self.tag,');') + end + end + output(' return 1;') + output('}') + output('\n') + + -- set function ------------------------------------------------ + if not strfind(self.mod,'const') then + if class then + output("/* set function:",self.name," of class ",class," */") + else + output("/* set function:",self.name," */") + end + self.csetname = self:cfuncname("toluaI_set") + output("static int",self.csetname,"(lua_State* tolua_S)") + output("{") + + -- declare self, if the case + local narg=1 + if class and static==nil then + output(' ',class,'*','self = ') + output('(',class,'*) ') + output('tolua_getusertype(tolua_S,1,0);') + -- check self value + output(' if (!self) TOLUA_ERR_SELF;'); + narg = narg+1 + elseif static then + _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)') + narg = narg+1 + end + + -- check type + output(' if (!'..self:outchecktype(narg)..')') + output(' TOLUA_ERR_ASSIGN;') + + -- assign value + local ptr = '' + if self.ptr~='' then ptr = '*' end + output(' ') + if class and static then + output(class..'::'..self.name) + elseif class then + output('self->'..self.name) + else + output(self.name) + end + local t = isbasic(self.type) + output(' = ') + if not t and ptr=='' then output('*') end + output('((',self.mod,self.type) + if not t then + output('*') + end + output(') ') + local def = 0 + if self.def ~= '' then def = self.def end + if t then + output('tolua_get'..t,'(tolua_S,',narg,',',def,'));') + else + output('tolua_getusertype(tolua_S,',narg,',',def,'));') + end + output(' return 0;') + output('}') + output('\n') + end + +end + +function classVariable:register () + local parent = self:inclass() or self:inmodule() + if parent then + if self.csetname then + output(' tolua_tablevar(tolua_S,"'..parent..'","'..self.lname..'",'..self.cgetname..','..self.csetname..');') + else + output(' tolua_tablevar(tolua_S,"'..parent..'","'..self.lname..'",'..self.cgetname..',NULL);') + end + else + if self.csetname then + output(' tolua_globalvar(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');') + else + output(' tolua_globalvar(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);') + end + end +end + +function classVariable:unregister () + if self:inclass()==nil and self:inmodule()==nil then + output(' lua_getglobals(tolua_S);') + output(' lua_pushstring(tolua_S,"',self.lname,'"); lua_pushnil(tolua_S); lua_rawset(tolua_S,-3);') + output(' lua_pop(tolua_S,1);') + end +end + + +-- Internal constructor +function _Variable (t) + t._base = classVariable + settag(t,tolua_tag) + append(t) + return t +end + +-- Constructor +-- Expects a string representing the variable declaration. +function Variable (s) + return _Variable (Declaration(s,'var')) +end + + diff --git a/src/lua/verbatim.lua b/src/lua/verbatim.lua new file mode 100644 index 00000000..9dae0dc3 --- /dev/null +++ b/src/lua/verbatim.lua @@ -0,0 +1,77 @@ +-- tolua: verbatim class +-- Written by Waldemar Celes +-- TeCGraf/PUC-Rio +-- Jul 1998 +-- $Id: verbatim.lua,v 1.2 2001/11/26 23:00:27 darkgod Exp $ + +-- This code is free software; you can redistribute it and/or modify it. +-- The software provided hereunder is on an "as is" basis, and +-- the author has no obligation to provide maintenance, support, updates, +-- enhancements, or modifications. + + + +-- Verbatim class +-- Represents a line translated directed to the binding file. +-- The following filds are stored: +-- line = line text +classVerbatim = { + line = '', + _base = classFeature, +} +settag(classVerbatim,tolua_tag) + +-- preamble verbatim +function classVerbatim:preamble () + if not self.cond then + write(self.line) + end +end + +-- support code +function classVerbatim:supcode () + if self.cond then + write(self.line) + write('\n') + end +end + +-- register code +function classVerbatim:register () + if self.cond then + write(self.line) + end +end + + +-- Print method +function classVerbatim:print (ident,close) + print(ident.."Verbatim{") + print(ident.." line = '"..self.line.."',") + print(ident.."}"..close) +end + + +-- Internal constructor +function _Verbatim (t) + t._base = classVerbatim + settag(t,tolua_tag) + append(t) + return t +end + +-- Constructor +-- Expects a string representing the text line +function Verbatim (l) + local c + if strsub(l,1,1) == '$' then + c = 1 + l = strsub(l,2) + end + return _Verbatim { + line = l, + cond = c + } +end + + |