API tools faq
paste
Advertisement
RasterPython

Tsb v0.80

RasterPython
Jul 3rd, 2019
155
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 43.56 KB | None | 0 0
raw download clone embed print report
  1. from math import fabs
  2.  
  3. #*Tsb v0.80.py*#
  4.  
  5. code = "iisibCmbCZbmbbCZbmbbbCZbmbbbbCbcazZ"
  6. p = open("input.tsb")# encoding = "utf_8"
  7. inp = p.read()
  8. p.close
  9. inp = "\n"+inp #bug fix v39
  10. inp = inp.replace("\n",";")
  11. inpcomm = inp.split(";")###
  12. inpcomm.append("pass")#v0.60
  13. layers = []
  14.  
  15. a = [0,0]
  16. b = [1,5,25,125,625,3125]
  17. def spacecount(comm):
  18.     f = 0
  19.     output = 0
  20.     while len(comm)>f and comm[f]==" ":
  21.         f+=1
  22.     return f
  23.  
  24. def number(num):
  25.     num = int(fabs(int(num)))
  26.     counter = [0,0,0,0,0,0]
  27.     while num!=0:
  28.         if num>=3125:
  29.             counter[5]=num//3125
  30.             num-=(num//3125)*3125
  31.         elif num>=625:
  32.             counter[4]=num//625
  33.             num-=(num//625)*625
  34.         elif num>=125:
  35.             counter[3]=num//125
  36.             num-=(num//125)*125
  37.         elif num>=25:
  38.             counter[2]=num//25
  39.             num-=(num//25)*25
  40.         elif num>=5:
  41.             counter[1]=num//5
  42.             num-=(num//5)*5
  43.         else:
  44.             counter[0]=num
  45.             num=0
  46.     return counter
  47.  
  48. def noupper(counter):
  49.     try:
  50.         while counter[-1]==0:
  51.             counter.pop(-1)
  52.         return counter
  53.     except IndexError:
  54.         return [0]
  55.  
  56. def spacecutter(text):
  57.     while text[0]==" ":
  58.         text=text[1:]
  59.     return text
  60.  
  61. def spacenull(text):
  62.     f = 0
  63.     string = False
  64.     newtext = ""
  65.     while f<len(text):
  66.         if text[f]=='"' or text[f]=='/':
  67.             string = not string
  68.         if text[f]==" " and not string:
  69.             pass
  70.         else:
  71.             newtext+=text[f]
  72.         f+=1
  73.     return newtext
  74.  
  75. def isnumber(text):
  76.     try:
  77.         int(text)
  78.         return True
  79.     except ValueError:
  80.         return False
  81.  
  82. def isfloat(text):
  83.     try:
  84.         float(text)
  85.         if text.count(".")==1:
  86.             return True
  87.         else:
  88.             return False
  89.     except ValueError:
  90.         return False
  91. def floatworks(floa):
  92.     if floa[-1]=="0":
  93.         floa = floa[:-2]+"0"
  94.     floa = float(floa)
  95.     fstr = str(floa)
  96.     after = len(fstr)-fstr.find(".")-1
  97.     before = fstr.find(".")
  98.     while floa%1!=0:
  99.         floa = floa*10
  100.     return int(floa),before,after
  101.  
  102. def ifinder(text):#no str support
  103.     if text.count('"')!=2 and text.count("++")==1:
  104.         return True
  105.     else:
  106.         return False
  107.  
  108. def dfinder(text):
  109.     if text.count('"')!=2 and text.count("--")==1:
  110.         return True
  111.     else:
  112.         return False
  113.  
  114. def nostring(text):
  115.     f = 0
  116.     newtext = ""
  117.     while f<len(text) and text[f]!='"':
  118.         newtext+=text[f]
  119.         f+=1
  120.     return newtext
  121.  
  122. def literals(string):
  123.     string = string.replace(r"\n","\n")
  124.     return string
  125.  
  126. def doublesharp(command):#finds ## in operations
  127.     truefalse = [False,False,False]
  128.     if command[:2]=="##":
  129.         truefalse[0]=True
  130.     if command[command.index("=")+1:][:2]=="##":
  131.         truefalse[1]=True
  132.     counter = -1
  133.     while command[counter]!="#":
  134.         counter-=1
  135.     if command[counter-1:counter+1]=="##":
  136.         truefalse[2]=True
  137.     return truefalse
  138.  
  139. def tf2(command):#truefalse v2
  140.     truefalse = [False,False]
  141.     commlist = command.split("=")
  142.     if commlist[0].count("#")==2:
  143.         truefalse[0]=True
  144.     if commlist[1].count("#")==2:
  145.         truefalse[1]=True
  146.     return truefalse
  147.  
  148. def truefalse3(command):
  149.     truefalse = [False,False]
  150.     counter1=0
  151.     while command[counter1]!="#":
  152.         counter1+=1
  153.     if command[counter1+1]=="#":
  154.         truefalse[0]=True
  155.     counter2=-1
  156.     while command[counter2]!="#":
  157.         counter2-=1
  158.     if command[counter2-1]=="#":
  159.         truefalse[1]=True
  160.     return truefalse
  161.  
  162. def tffunc(command):
  163.     truefalse = [False]
  164.     commlist = command.replace("##","#").split("#")[1:]
  165.     if len(commlist)==1:
  166.         if command.count("#")==2:
  167.             truefalse[0]=True
  168.     if len(commlist)==2:
  169.         truefalse.append(False)
  170.         counter = 0
  171.         while command[counter]!="#":
  172.             counter+=1
  173.         if command[counter+1]=="#":
  174.             truefalse[0]=True
  175.         counter = -1
  176.         while command[counter]!="#":
  177.             counter-=1
  178.         if command[counter-1]=="#":
  179.             truefalse[1]=True
  180.     if len(commlist)==3:
  181.         truefalse.extend([False,False])
  182.         counter = 0
  183.         while command[counter]!="#":
  184.             counter+=1
  185.         if command[counter+1]=="#":
  186.             truefalse[0]=True
  187.         counter = -1
  188.         while command[counter]!="#":
  189.             counter-=1
  190.         if command[counter-1]=="#":
  191.             truefalse[2]=True
  192.             counter-=2
  193.         else:
  194.             counter-=1
  195.         while command[counter]!="#":
  196.             counter-=1
  197.         if command[counter-1]=="#":
  198.             truefalse[1]=True
  199.     return truefalse
  200.    
  201. for comm in inpcomm:
  202.     layers.append(spacecount(comm))
  203. sortedlayers = layers[:]
  204. sortedlayers.sort()
  205. sortcounter = 0
  206. while sortcounter!=len(sortedlayers)-1 and sortedlayers[sortcounter]==0:#fixed in v72
  207.     sortcounter+=1
  208. minindent = sortedlayers[sortcounter]#v71
  209. #print(minindent)
  210.  
  211. funvar = []
  212. foc=0
  213. outputbool = False
  214. while foc<len(inpcomm):
  215.  
  216.     c = spacenull(inpcomm[foc])#Command
  217.    
  218.     if c=="":
  219.         foc+=1
  220.         continue
  221.  
  222.    
  223.  
  224.     if layers[foc]<layers[foc-1]:#closing with >
  225.         if minindent!=0:
  226.             if len(funvar)!=0 and funvar[-1]:#fun start
  227.                 funvar.pop()
  228.                 code+="aCzl"#fun end
  229.             code+=">"*round((layers[foc-1]-layers[foc])/minindent)#v71
  230.         if spacenull(inpcomm[foc])!="else:" and spacenull(inpcomm[foc]).find("elif")!=0:#v67
  231.             code+="zZaCaczc"#bug v0.59
  232.    
  233.     #variable cleanup
  234.     #code+="zZaCaczc"
  235.     if c.count("/")>0:#comments
  236.         if c.count("/")==1:
  237.             code+=c[c.index("/"):]+"/"
  238.         if c.count("/")==2:
  239.             code+=c[c.index("/"):]
  240.         if c.count("/useoutput")==1 and c.index("/useoutput")==0:
  241.             outputbool = True
  242.         c = c[:c.index("/")]
  243.         if c=="":
  244.             foc+=1
  245.             continue
  246.    
  247.     if c[0]=="#" and c.count("=")==1 and nostring(c).count("*")==0 and nostring(c).count("\\")==0 and nostring(c).count("\\\\")==0 and nostring(c).count("^")==0 and nostring(c).count("%")==0 and nostring(c).count("+")==0 and nostring(c).count("-#")==0 and nostring(c).replace("##","#").count("#")!=2:#and nostring(c).count("#")!=2
  248.         if c[:2]=="##":
  249.             name = c[2:c.index("=")]#var name
  250.             namenum = noupper(number(name))
  251.             code+="i"*namenum[0]
  252.             if len(namenum)>1:
  253.                 for numb in namenum[1:]:
  254.                     code+="b"
  255.                     code+="I"*numb
  256.             code+="ZxlaCzx"#v0.61
  257.  
  258.         else:
  259.             name = c[1:c.index("=")]#var name
  260.             namenum = noupper(number(name))
  261.             code+="i"*namenum[0]
  262.             if len(namenum)>1:
  263.                 for numb in namenum[1:]:
  264.                     code+="b"
  265.                     code+="I"*numb
  266.             code+="Zx"
  267.         if c.split("=")[1]=="False" or c.split("=")[1]=="True":#Bools
  268.             if c.split("=")[1]=="False":
  269.                 code+="e"
  270.             else:
  271.                 code+="ie"
  272.         elif isnumber(c.split("=")[1]):#Integers
  273.             value = noupper( number( c.split("=")[1] ) )
  274.             if c.split("=")[1][0]=="-":
  275.                 code+= "d"*value[0]
  276.                 if len(value)>1:
  277.                     for val in value[1:]:
  278.                         code+="b"
  279.                         code+="D"*val
  280.                     code+="Z"
  281.                 code+="n"
  282.  
  283.             else:
  284.                 code+= "i"*value[0]
  285.                 if len(value)>1:
  286.                     for val in value[1:]:
  287.                         code+="b"
  288.                         code+="I"*val
  289.                     code+="Z"
  290.                 code+="n"
  291.         elif isfloat(c.split("=")[1]):#Floats
  292.             floa,before, after = floatworks(c.split("=")[1])
  293.             if len(str(floa))>len(c.split("=")[1]):
  294.                 strfloa = str(floa)[:before + after + 1]
  295.                 intfloa = round(int(strfloa)/10)
  296.             else:
  297.                 intfloa = floa
  298.  
  299.             value = noupper( number( intfloa ) )
  300.             if c.split("=")[1][0]=="-":
  301.                 code+= "d"*value[0]
  302.                 if len(value)>1:
  303.                     for val in value[1:]:
  304.                         code+="b"
  305.                         code+="D"*val
  306.                     code+="Z"
  307.             else:
  308.                 code+= "i"*value[0]
  309.                 if len(value)>1:
  310.                     for val in value[1:]:
  311.                         code+="b"
  312.                         code+="I"*val
  313.                     code+="Z"
  314.             code+="aaiiisixz"
  315.             code+="v"*after
  316.             code+="aaxzf"#
  317.         elif c.split("=")[1][0]=='"' and c.split("=")[1][-1]=='"':#Strings
  318.             string = c.split("=")[1][1:-1]
  319.  
  320.             string = literals(string)
  321.            
  322.             for character in string:
  323.                 code+="axzcaxz"
  324.                 charnum = ord(character)
  325.                 value = noupper( number( charnum ) )
  326.                 code+= "i"*value[0]
  327.                 if len(value)>1:
  328.                     for val in value[1:]:
  329.                         code+="b"
  330.                         code+="I"*val
  331.                     code+="Z"
  332.                 code+="T"
  333.  
  334.     elif c[0]=="#" and c.count("=")==1 and nostring(c).replace("##","#").count("#")==2:#equal #if
  335.         nos = nostring(c).replace("##","#")
  336.         value = noupper( number( nos.split("#")[2] ) )
  337.         code+= "i"*value[0]
  338.         if len(value)>1:
  339.             for val in value[1:]:
  340.                 code+="b"
  341.                 code+="I"*val
  342.             code+="Z"
  343.         if tf2(c)[1]:
  344.             code+="xlxlaCzx"
  345.         else:
  346.             code+="xlaCzx"
  347.  
  348.         value = noupper( number( nos.split("#")[1][:-1] ) )
  349.         code+= "i"*value[0]
  350.         if len(value)>1:
  351.             for val in value[1:]:
  352.                 code+="b"
  353.                 code+="I"*val
  354.             code+="Z"
  355.         if tf2(c)[0]:
  356.             code+="xaalxzf"#
  357.         else:
  358.             code+="xf"#oxox
  359.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("*")==1:#operations
  360.         tf = doublesharp(nostring(c))#
  361.         c = c.replace("##","#")#
  362.         nos = nostring(c)[nostring(c).index("=#")+1:]
  363.         value = noupper( number( nos.split("*")[1][1:] ) )
  364.         code+= "i"*value[0]
  365.         if len(value)>1:
  366.             for val in value[1:]:
  367.                 code+="b"
  368.                 code+="I"*val
  369.             code+="Z"
  370.         if tf[2]==False:
  371.             code+="xlxaaxzc"
  372.         else:
  373.             code+="xlxlxaaxzc"
  374.  
  375.         value = noupper( number( nos.split("*")[0][1:] ) )
  376.         code+= "i"*value[0]
  377.         if len(value)>1:
  378.             for val in value[1:]:
  379.                 code+="b"
  380.                 code+="I"*val
  381.             code+="Z"
  382.         if tf[1]==False:
  383.             code+="xlaaxz"#oxox
  384.         else:
  385.             code+="xlxlaaxz"
  386.        
  387.         code+="maCac"#var name
  388.         #print(nos,"_",c)
  389.         value = noupper( number( c.split("=#")[0][1:] ) )
  390.         code+= "i"*value[0]
  391.         if len(value)>1:
  392.             for val in value[1:]:
  393.                 code+="b"
  394.                 code+="I"*val
  395.             code+="Z"
  396.         if tf[0]==False:
  397.             code+="xzf"
  398.         else:
  399.             code+="xlxzf"
  400.  
  401.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("\\")==1:
  402.         tf = doublesharp(nostring(c))#
  403.         c = c.replace("##","#")#
  404.         nos = nostring(c)[nostring(c).index("=#")+1:]
  405.         value = noupper( number( nos.split("\\")[1][1:] ) )
  406.         code+= "i"*value[0]
  407.         if len(value)>1:
  408.             for val in value[1:]:
  409.                 code+="b"
  410.                 code+="I"*val
  411.             code+="Z"
  412.         if tf[2]:
  413.             code+="xlxlxaaxzc"
  414.         else:
  415.             code+="xlxaaxzc"
  416.  
  417.         value = noupper( number( nos.split("\\")[0][1:] ) )
  418.         code+= "i"*value[0]
  419.         if len(value)>1:
  420.             for val in value[1:]:
  421.                 code+="b"
  422.                 code+="I"*val
  423.             code+="Z"
  424.         if tf[1]:
  425.             code+="xlxlaaxz"
  426.         else:
  427.             code+="xlaaxz"#oxox
  428.        
  429.         code+="vaCac"#var name
  430.         #print(nos,"_",c)
  431.         value = noupper( number( c.split("=#")[0][1:] ) )
  432.         code+= "i"*value[0]
  433.         if len(value)>1:
  434.             for val in value[1:]:
  435.                 code+="b"
  436.                 code+="I"*val
  437.             code+="Z"
  438.         if tf[0]:
  439.             code+="xlxzf"
  440.         else:
  441.             code+="xzf"
  442.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("\\")==1:
  443.         tf = doublesharp(nostring(c))#
  444.         c = c.replace("##","#")#
  445.         nos = nostring(c)[nostring(c).index("=#")+1:]
  446.         value = noupper( number( nos.split("\\")[1][1:] ) )
  447.         code+= "i"*value[0]
  448.         if len(value)>1:
  449.             for val in value[1:]:
  450.                 code+="b"
  451.                 code+="I"*val
  452.             code+="Z"
  453.         if tf[2]:
  454.             code+="xlxlxaaxzc"
  455.         else:
  456.             code+="xlxaaxzc"
  457.  
  458.         value = noupper( number( nos.split("\\")[0][1:] ) )
  459.         code+= "i"*value[0]
  460.         if len(value)>1:
  461.             for val in value[1:]:
  462.                 code+="b"
  463.                 code+="I"*val
  464.             code+="Z"
  465.         if tf[1]:
  466.             code+="xlxlaaxz"
  467.         else:
  468.             code+="xlaaxz"#oxox
  469.        
  470.         code+="vaCac"#var name
  471.         #print(nos,"_",c)
  472.         value = noupper( number( c.split("=#")[0][1:] ) )
  473.         code+= "i"*value[0]
  474.         if len(value)>1:
  475.             for val in value[1:]:
  476.                 code+="b"
  477.                 code+="I"*val
  478.             code+="Z"
  479.         if tf[2]:
  480.             code+="xlxzf"
  481.         else:
  482.             code+="xzf"
  483.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("%")==1:
  484.         tf = doublesharp(nostring(c))#
  485.         c = c.replace("##","#")#
  486.         nos = nostring(c)[nostring(c).index("=#")+1:]
  487.         value = noupper( number( nos.split("%")[1][1:] ) )
  488.         code+= "i"*value[0]
  489.         if len(value)>1:
  490.             for val in value[1:]:
  491.                 code+="b"
  492.                 code+="I"*val
  493.             code+="Z"
  494.         if tf[2]:
  495.             code+="xlxlxaaxzc"
  496.         else:
  497.             code+="xlxaaxzc"
  498.  
  499.         value = noupper( number( nos.split("%")[0][1:] ) )
  500.         code+= "i"*value[0]
  501.         if len(value)>1:
  502.             for val in value[1:]:
  503.                 code+="b"
  504.                 code+="I"*val
  505.             code+="Z"
  506.         if tf[1]:
  507.             code+="xlxlaaxz"
  508.         else:
  509.             code+="xlaaxz"#oxox
  510.        
  511.         code+="MaCac"#var name
  512.         #print(nos,"_",c)
  513.         value = noupper( number( c.split("=#")[0][1:] ) )
  514.         code+= "i"*value[0]
  515.         if len(value)>1:
  516.             for val in value[1:]:
  517.                 code+="b"
  518.                 code+="I"*val
  519.             code+="Z"
  520.         if tf[2]:
  521.             code+="xlxzf"
  522.         else:
  523.             code+="xzf"
  524.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("+")==1:
  525.         tf = doublesharp(nostring(c))#
  526.         c = c.replace("##","#")#
  527.         nos = nostring(c)[nostring(c).index("=#")+1:]
  528.         value = noupper( number( nos.split("+")[1][1:] ) )
  529.         code+= "i"*value[0]
  530.         if len(value)>1:
  531.             for val in value[1:]:
  532.                 code+="b"
  533.                 code+="I"*val
  534.             code+="Z"
  535.         if tf[2]:
  536.             code+="xlxlxaaxzc"
  537.         else:
  538.             code+="xlxaaxzc"
  539.  
  540.         value = noupper( number( nos.split("+")[0][1:] ) )
  541.         code+= "i"*value[0]
  542.         if len(value)>1:
  543.             for val in value[1:]:
  544.                 code+="b"
  545.                 code+="I"*val
  546.             code+="Z"
  547.         if tf[1]:
  548.             code+="xlxlaaxz"
  549.         else:
  550.             code+="xlaaxz"#oxox
  551.        
  552.         code+="IaCac"#action
  553.         #print(nos,"_",c)
  554.         value = noupper( number( c.split("=#")[0][1:] ) )
  555.         code+= "i"*value[0]
  556.         if len(value)>1:
  557.             for val in value[1:]:
  558.                 code+="b"
  559.                 code+="I"*val
  560.             code+="Z"
  561.         if tf[0]:
  562.             code+="xlxzf"
  563.         else:
  564.             code+="xzf"
  565.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("-")==1:
  566.         tf = doublesharp(nostring(c))#
  567.         c = c.replace("##","#")#
  568.         nos = nostring(c)[nostring(c).index("=#")+1:]
  569.         value = noupper( number( nos.split("-")[1][1:] ) )
  570.         code+= "i"*value[0]
  571.         if len(value)>1:
  572.             for val in value[1:]:
  573.                 code+="b"
  574.                 code+="I"*val
  575.             code+="Z"
  576.         if tf[2]:
  577.             code+="xlxlxaaxzc"
  578.         else:
  579.             code+="xlxaaxzc"
  580.  
  581.         value = noupper( number( nos.split("-")[0][1:] ) )
  582.         code+= "i"*value[0]
  583.         if len(value)>1:
  584.             for val in value[1:]:
  585.                 code+="b"
  586.                 code+="I"*val
  587.             code+="Z"
  588.         if tf[1]:
  589.             code+="xlxlaaxz"
  590.         else:
  591.             code+="xlaaxz"#oxox
  592.        
  593.         code+="DaCac"#action
  594.         #print(nos,"_",c)
  595.         value = noupper( number( c.split("=#")[0][1:] ) )
  596.         code+= "i"*value[0]
  597.         if len(value)>1:
  598.             for val in value[1:]:
  599.                 code+="b"
  600.                 code+="I"*val
  601.             code+="Z"
  602.         if tf[0]:
  603.             code+="xlxzf"
  604.         else:
  605.             code+="xzf"
  606.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("\\\\")==1:
  607.         tf = doublesharp(nostring(c))#
  608.         c = c.replace("##","#")#
  609.         nos = nostring(c)[nostring(c).index("=#")+1:]
  610.         value = noupper( number( nos.split("\\\\")[1][1:] ) )
  611.         code+= "i"*value[0]
  612.         if len(value)>1:
  613.             for val in value[1:]:
  614.                 code+="b"
  615.                 code+="I"*val
  616.             code+="Z"
  617.         if tf[2]:
  618.             code+="xlxlxaaxzc"
  619.         else:
  620.             code+="xlxaaxzc"
  621.  
  622.         value = noupper( number( nos.split("\\\\")[0][1:] ) )
  623.         code+= "i"*value[0]
  624.         if len(value)>1:
  625.             for val in value[1:]:
  626.                 code+="b"
  627.                 code+="I"*val
  628.             code+="Z"
  629.         if tf[1]:
  630.             code+="xlxlaaxz"
  631.         code+="xlaaxz"#oxox
  632.        
  633.         code+="%aCac"#var name
  634.         #print(nos,"_",c)
  635.         value = noupper( number( c.split("=#")[0][1:] ) )
  636.         code+= "i"*value[0]
  637.         if len(value)>1:
  638.             for val in value[1:]:
  639.                 code+="b"
  640.                 code+="I"*val
  641.             code+="Z"
  642.         if tf[0]:
  643.             code+="xlxzf"
  644.         else:
  645.             code+="xzf"
  646.     elif c[0]=="#" and c.count("=")==1 and nostring(c).count("^")==1:
  647.         tf = doublesharp(nostring(c))#
  648.         c = c.replace("##","#")#
  649.         nos = nostring(c)[nostring(c).index("=#")+1:]
  650.         value = noupper( number( nos.split("^")[1][1:] ) )
  651.         code+= "i"*value[0]
  652.         if len(value)>1:
  653.             for val in value[1:]:
  654.                 code+="b"
  655.                 code+="I"*val
  656.             code+="Z"
  657.         if tf[2]:
  658.             code+="xlxlxaaxzc"
  659.         else:
  660.             code+="xlxaaxzc"
  661.  
  662.         value = noupper( number( nos.split("^")[0][1:] ) )
  663.         code+= "i"*value[0]
  664.         if len(value)>1:
  665.             for val in value[1:]:
  666.                 code+="b"
  667.                 code+="I"*val
  668.             code+="Z"
  669.         if tf[1]:
  670.             code+="xlxlaaxz"
  671.         else:
  672.             code+="xlaaxz"#oxox
  673.        
  674.         code+="SaCac"#var name
  675.         #print(nos,"_",c)
  676.         value = noupper( number( c.split("=#")[0][1:] ) )
  677.         code+= "i"*value[0]
  678.         if len(value)>1:
  679.             for val in value[1:]:
  680.                 code+="b"
  681.                 code+="I"*val
  682.             code+="Z"
  683.         if tf[0]:
  684.             code+="xlxzf"
  685.         else:
  686.             code+="xzf"#operations end
  687.     elif c[0]=="#" and c.count("++")==1:
  688.         double = False
  689.         if c[:2]=="##":
  690.             double = True
  691.         c = c.replace("##","#")
  692.        
  693.         tup = c.split("++")
  694.         name = c[1:c.index("+")]#var name
  695.         namenum = noupper(number(name))
  696.         code+="i"*namenum[0]
  697.         if len(namenum)>1:
  698.             for numb in namenum[1:]:
  699.                 code+="b"
  700.                 code+="I"*numb
  701.         if double:
  702.             code+="ZxlaCzx"
  703.         else:
  704.             code+="Zx"
  705.         if tup[1]=="":#n++
  706.             code+="li"
  707.             code+="n"
  708.         elif tup[1]!="" and tup[1].count("#")==0:#n++m #v74
  709.             if isfloat(tup[1]):
  710.                 floa,before, after = floatworks(c.split("++")[1])
  711.                 if len(str(floa))>len(c.split("++")[1]):
  712.                     strfloa = str(floa)[:before + after + 1]
  713.                     intfloa = round(int(strfloa)/10)
  714.                 else:
  715.                     intfloa = floa
  716.  
  717.                 value = noupper( number( intfloa ) )
  718.                 code+= "i"*value[0]
  719.                 if len(value)>1:
  720.                     for val in value[1:]:
  721.                         code+="b"
  722.                         code+="I"*val
  723.                     code+="Z"
  724.                 code+="aaiiisixz"
  725.                 code+="v"*after
  726.                 code+="aaxzbbbbbbxZlbbbbbbIaCzZf"#
  727.             elif isnumber(tup[1]):
  728.                 #print(c)
  729.                 code+="l"
  730.                 name = c.split("++")[1]
  731.                 namenum = noupper(number(name))
  732.                 code+="i"*namenum[0]
  733.                 if len(namenum)>1:
  734.                     for numb in namenum[1:]:
  735.                         code+="b"
  736.                         code+="I"*numb
  737.                 code+="Zn"
  738.         elif tup[1][0]=="#":
  739.             #print(c,tup[1])
  740.             double = False
  741.             if tup[1].count("#")==2:
  742.                 tup[1]=tup[1].replace("##","#")
  743.                 double = True
  744.             if isnumber(tup[1][1:]):
  745.                 #print(c)
  746.                 code+="laaxzx"
  747.                 name = c.split("++")[1][1:]
  748.                 namenum = noupper(number(name))
  749.                 code+="i"*namenum[0]
  750.                 if len(namenum)>1:
  751.                     for numb in namenum[1:]:
  752.                         code+="b"
  753.                         code+="I"*numb
  754.                 if not double:
  755.                     code+="ZxaaalxzIaaxznaCaac"
  756.                 else:
  757.                     code+="ZxaaalxlxzIaaxznaCaac"
  758.                    
  759.     elif c[0]=="#" and c.count("--")==1:#d
  760.         double = False
  761.         if c[:2]=="##":
  762.             double = True
  763.         c = c.replace("##","#")
  764.        
  765.         tup = c.split("--")
  766.         name = c[1:c.index("-")]#var name
  767.         namenum = noupper(number(name))
  768.         code+="i"*namenum[0]
  769.         if len(namenum)>1:
  770.             for numb in namenum[1:]:
  771.                 code+="b"
  772.                 code+="I"*numb
  773.         if double:
  774.             code+="ZxlaCzx"
  775.         else:
  776.             code+="Zx"
  777.         if tup[1]=="":#n--
  778.             code+="ld"
  779.             code+="n"
  780.         elif tup[1]!="" and tup[1].count("#")==0:#n++m
  781.             if isfloat(tup[1]):
  782.                 floa,before, after = floatworks(c.split("--")[1])
  783.                 if len(str(floa))>len(c.split("--")[1]):
  784.                     strfloa = str(floa)[:before + after + 1]
  785.                     intfloa = round(int(strfloa)/10)
  786.                 else:
  787.                     intfloa = floa
  788.  
  789.                 value = noupper( number( intfloa ) )
  790.                 code+= "i"*value[0]
  791.                 if len(value)>1:
  792.                     for val in value[1:]:
  793.                         code+="b"
  794.                         code+="I"*val
  795.                     code+="Z"
  796.                 code+="aaiiisixz"
  797.                 code+="v"*after
  798.                 code+="aaxzbbbbbbxZlbbbbbbDaCzZf"#
  799.             elif isnumber(tup[1]):
  800.                 #print(c)
  801.                 code+="l"
  802.                 name = c.split("--")[1]
  803.                 namenum = noupper(number(name))
  804.                 code+="d"*namenum[0]
  805.                 if len(namenum)>1:
  806.                     for numb in namenum[1:]:
  807.                         code+="b"
  808.                         code+="D"*numb
  809.                 code+="Zn"
  810.         elif tup[1][0]=="#":
  811.             double = False
  812.             if tup[1].count("#")==2:
  813.                 tup[1]=tup[1].replace("##","#")
  814.                 double = True
  815.             if isnumber(tup[1][1:]):
  816.                 #print(c)
  817.                 code+="laaxzx"
  818.                 name = c.split("--")[1][1:]
  819.                 namenum = noupper(number(name))
  820.                 code+="i"*namenum[0]
  821.                 if len(namenum)>1:
  822.                     for numb in namenum[1:]:
  823.                         code+="b"
  824.                         code+="I"*numb
  825.                 if not double:
  826.                     code+="ZxaaalxzDaaxznaCaac"
  827.                 else:
  828.                     code+="ZxaaalxlxzDaaxznaCaac"
  829.  
  830.     elif nostring(c).count("square")==1:#s
  831.         tup = c.split("#")
  832.         name = tup[1]#var name
  833.         namenum = noupper(number(name))
  834.         code+="i"*namenum[0]
  835.         if len(namenum)>1:
  836.             for numb in namenum[1:]:
  837.                 code+="b"
  838.                 code+="I"*numb
  839.         code+="Zxlsf"
  840.     elif nostring(c).count("round")==1:
  841.         tup = c.replace("##","#").split("#")#v66
  842.         name = tup[1]#var name
  843.         namenum = noupper(number(name))
  844.         code+="i"*namenum[0]
  845.         if len(namenum)>1:
  846.             for numb in namenum[1:]:
  847.                 code+="b"
  848.                 code+="I"*numb
  849.         if tffunc(c)[0]:
  850.             code+="xlxlaaxzxixMaiixvxddz<aaxzln>.aaxzlin>"
  851.         else:
  852.             code+="xlaaxzxixMaiixvxddz<aaxzln>.aaxzlin>"
  853.     elif nostring(c).count("int")==1:
  854.         tup = c.replace("##","#").split("#")
  855.         name = tup[1]#var name
  856.         namenum = noupper(number(name))
  857.         code+="i"*namenum[0]
  858.         if len(namenum)>1:
  859.             for numb in namenum[1:]:
  860.                 code+="b"
  861.                 code+="I"*numb
  862.         if tffunc(c)[0]:
  863.             code+="xlxln"
  864.         else:
  865.             code+="xln"
  866.     elif nostring(c).count("outn")==1:
  867.         tup = c.replace("##","#").split("#")
  868.         name = tup[1]#var name
  869.         namenum = noupper(number(name))
  870.         code+="i"*namenum[0]
  871.         if len(namenum)>1:
  872.             for numb in namenum[1:]:
  873.                 code+="b"
  874.                 code+="I"*numb
  875.         if tffunc(c)[0]:
  876.             code+="xlgO"
  877.         else:
  878.             code+="gO"
  879.     elif nostring(c).count("out")==1:#o
  880.         tup = c.replace("##","#").split("#")
  881.         name = tup[1]#var name
  882.         namenum = noupper(number(name))
  883.         code+="i"*namenum[0]
  884.         if len(namenum)>1:
  885.             for numb in namenum[1:]:
  886.                 code+="b"
  887.                 code+="I"*numb
  888.         if tffunc(c)[0]:
  889.             code+="xlO"
  890.         code+="O"
  891.     elif nostring(c).count("absolute")==1:
  892.         tup = c.replace("##","#").split("#")
  893.         name = tup[1]#var name
  894.         namenum = noupper(number(name))
  895.         code+="i"*namenum[0]
  896.         if len(namenum)>1:
  897.             for numb in namenum[1:]:
  898.                 code+="b"
  899.                 code+="I"*numb
  900.         if tffunc(c)[0]:
  901.             code+="xlxlpf"
  902.         else:
  903.             code+="xlpf"
  904.     elif nostring(c).count("input")==1:
  905.         tup = c.replace("##","#").split("#")
  906.         name = tup[1]#console pointer
  907.         namenum = noupper(number(name))
  908.         code+="i"*namenum[0]
  909.         if len(namenum)>1:
  910.             for numb in namenum[1:]:
  911.                 code+="b"
  912.                 code+="I"*numb
  913.         if tffunc(c)[0]:
  914.             code+="ZxlaCzx"#v66
  915.         else:
  916.             code+="Zx"
  917.         name = tup[2]#var name
  918.         namenum = noupper(number(name))
  919.         code+="i"*namenum[0]
  920.         if len(namenum)>1:
  921.             for numb in namenum[1:]:
  922.                 code+="b"
  923.                 code+="I"*numb
  924.         if tffunc(c)[1]:
  925.             code+="ZxaalxzxQ"#v^^
  926.         else:
  927.             code+="ZQ"
  928.     elif nostring(c).count("inp")==1:
  929.         tup = c.replace("##","#").split("#")
  930.         name = tup[1]#console pointer
  931.         namenum = noupper(number(name))
  932.         code+="i"*namenum[0]
  933.         if len(namenum)>1:
  934.             for numb in namenum[1:]:
  935.                 code+="b"
  936.                 code+="I"*numb
  937.         if tffunc(c)[0]:
  938.             code+="Zxlxqf"
  939.         else:
  940.             code+="Zxqf"
  941.     elif nostring(c).count("charget")==1 and c.index("charget")==0:#char extraction
  942.         value = noupper( number( c[7:].replace("##","#").split("#")[1] ) )#charget3#0#1
  943.         code+= "i"*value[0]
  944.         if len(value)>1:
  945.             for val in value[1:]:
  946.                 code+="b"
  947.                 code+="I"*val
  948.             code+="Z"
  949.         if tffunc(c)[0]:
  950.             code+="xlxlaCzx"
  951.         else:
  952.             code+="xlaCzx"#fixed in v44
  953.  
  954.         value = noupper( number( c[7:].replace("##","#").split("#")[2] ) )
  955.         code+= "i"*value[0]
  956.         if len(value)>1:
  957.             for val in value[1:]:
  958.                 code+="b"
  959.                 code+="I"*val
  960.             code+="Z"
  961.         if tffunc(c)[1]:
  962.             code+="aaczxlaaCz#aCzx"
  963.         else:
  964.             code+="#aCzx"
  965.  
  966.         value = noupper( number( c[7:].replace("##","#").split("#")[3] ) )
  967.         code+= "i"*value[0]
  968.         if len(value)>1:
  969.             for val in value[1:]:
  970.                 code+="b"
  971.                 code+="I"*val
  972.             code+="Z"
  973.         if tffunc(c)[2]:
  974.             code+="ad=i>.izxaalxzT>"
  975.         else:
  976.             code+="ad=i>.izxT>"
  977.     elif nostring(c).count("random")==1 and c.index("random")==0:
  978.         value = noupper( number( c[6:].replace("##","#").split("#")[1] ) )#random3#0#1
  979.         code+= "i"*value[0]
  980.         if len(value)>1:
  981.             for val in value[1:]:
  982.                 code+="b"
  983.                 code+="I"*val
  984.             code+="Z"
  985.         if tffunc(c)[0]:
  986.             code+="xlxlaCzxaaxz"
  987.         else:
  988.             code+="xlaCzxaaxz"
  989.  
  990.         value = noupper( number( c[6:].replace("##","#").split("#")[2] ) )
  991.         code+= "i"*value[0]
  992.         if len(value)>1:
  993.             for val in value[1:]:
  994.                 code+="b"
  995.                 code+="I"*val
  996.             code+="Z"
  997.         if tffunc(c)[1]:
  998.             code+="xlxlaaxzx?aCzx"
  999.         else:
  1000.             code+="xlaaxzx?aCzx"
  1001.  
  1002.         value = noupper( number( c[6:].replace("##","#").split("#")[3] ) )
  1003.         code+= "i"*value[0]
  1004.         if len(value)>1:
  1005.             for val in value[1:]:
  1006.                 code+="b"
  1007.                 code+="I"*val
  1008.             code+="Z"
  1009.         if tffunc(c)[2]:
  1010.             code+="xaalxzf"
  1011.         else:
  1012.             code+="xf"
  1013.     elif nostring(c).count("numget")==1 and c.index("numget")==0:#num extraction
  1014.         value = noupper( number( c[7:].replace("##","#").split("#")[0] ) )#numget3#0#1
  1015.         code+= "i"*value[0]
  1016.         if len(value)>1:
  1017.             for val in value[1:]:
  1018.                 code+="b"
  1019.                 code+="I"*val
  1020.             code+="Z"
  1021.         if tffunc(c)[0]:
  1022.             code+="xlxlaCzx"
  1023.         else:
  1024.             code+="xlaCzx"
  1025.  
  1026.         value = noupper( number( c[7:].replace("##","#").split("#")[1] ) )
  1027.         code+= "i"*value[0]
  1028.         if len(value)>1:
  1029.             for val in value[1:]:
  1030.                 code+="b"
  1031.                 code+="I"*val
  1032.             code+="Z"
  1033.         if tffunc(c)[1]:
  1034.             code+="aaczxlaaCz$aCzx"
  1035.         else:
  1036.             code+="$aCzx"
  1037.  
  1038.         value = noupper( number( c[7:].replace("##","#").split("#")[2] ) )
  1039.         code+= "i"*value[0]
  1040.         if len(value)>1:
  1041.             for val in value[1:]:
  1042.                 code+="b"
  1043.                 code+="I"*val
  1044.             code+="Z"
  1045.         if tffunc(c)[1]:
  1046.             code+="xaalxzf"
  1047.         else:
  1048.             code+="xf"
  1049.     elif nostring(c).count("fun")==1 and c.index("fun")==0 and c[-1]==":":
  1050.         value = noupper( number( c[3:-1]) )#fun7:
  1051.         code+= "i"*value[0]
  1052.         if len(value)>1:
  1053.             for val in value[1:]:
  1054.                 code+="b"
  1055.                 code+="I"*val
  1056.             code+="Z"
  1057.         code+="kxaaaxziisibCmbCZbmbbCZbmbbbCZbmbbbbCbcazZaaaxzxfc"
  1058.         funvar.append(True)
  1059.     elif nostring(c).count("global")==1 and c.index("global")==0:
  1060.         code+="K"
  1061.     elif nostring(c).count("runfun")==1 and c.index("runfun")==0:
  1062.         value = noupper( number( c.replace("##","#").split("#")[0][6:] ) )#fun7:
  1063.         code+= "i"*value[0]
  1064.         if len(value)>1:
  1065.             for val in value[1:]:
  1066.                 code+="b"
  1067.                 code+="I"*val
  1068.             code+="Z"
  1069.         code+="x"
  1070.         value = noupper( number( c.replace("##","#").split("#")[1] ) )
  1071.         code+= "i"*value[0]
  1072.         if len(value)>1:
  1073.             for val in value[1:]:
  1074.                 code+="b"
  1075.                 code+="I"*val
  1076.             code+="Z"
  1077.         if tffunc(c)[0]:#v78
  1078.             code+="xaalxlxzH"
  1079.         else:
  1080.             code+="xaalxzH"
  1081.         value = noupper( number( c.replace("##","#").split("#")[2] ) )
  1082.         code+="xaCzx"
  1083.         code+= "i"*value[0]
  1084.         if len(value)>1:
  1085.             for val in value[1:]:
  1086.                 code+="b"
  1087.                 code+="I"*val
  1088.             code+="Z"
  1089.         if tffunc(c)[1]:#v78
  1090.             code+="xaalxzf"
  1091.         else:
  1092.             code+="xf"
  1093.     elif nostring(c).count("literal")==1 and c.index("literal")==0:#literal Seabass
  1094.         code+=c[7:]
  1095.     elif nostring(c).count("write")==1 and c.index("write")==0:#file works
  1096.         tup = c.replace("##","#").split("#")
  1097.         name = tup[1]#console pointer
  1098.         namenum = noupper(number(name))
  1099.         code+="i"*namenum[0]
  1100.         if len(namenum)>1:
  1101.             for numb in namenum[1:]:
  1102.                 code+="b"
  1103.                 code+="I"*numb
  1104.         if tffunc(c)[0]:
  1105.             code+="ZxlaCzx"
  1106.         else:
  1107.             code+="Zx"
  1108.         name = tup[2]#var name
  1109.         namenum = noupper(number(name))
  1110.         code+="i"*namenum[0]
  1111.         if len(namenum)>1:
  1112.             for numb in namenum[1:]:
  1113.                 code+="b"
  1114.                 code+="I"*numb
  1115.         if tffunc(c)[1]:
  1116.             code+="Zxaalxzxw"
  1117.         else:
  1118.             code+="Zxw"
  1119.     elif nostring(c).count("append")==1 and c.index("append")==0:#file works
  1120.         tup = c.split("#")
  1121.         name = tup[1]#console pointer
  1122.         namenum = noupper(number(name))
  1123.         code+="i"*namenum[0]
  1124.         if len(namenum)>1:
  1125.             for numb in namenum[1:]:
  1126.                 code+="b"
  1127.                 code+="I"*numb
  1128.         if tffunc(c)[0]:
  1129.             code+="ZxlaCzx"
  1130.         else:
  1131.             code+="Zx"
  1132.         name = tup[2]#var name
  1133.         namenum = noupper(number(name))
  1134.         code+="i"*namenum[0]
  1135.         if len(namenum)>1:
  1136.             for numb in namenum[1:]:
  1137.                 code+="b"
  1138.                 code+="I"*numb
  1139.         if tffunc(c)[1]:
  1140.             code+="ZxaalxzxW"
  1141.         else:
  1142.             code+="ZxW"
  1143.     elif nostring(c).count("read")==1 and c.index("read")==0:#file works
  1144.         tup = c.split("#")
  1145.         name = tup[1]#console pointer
  1146.         namenum = noupper(number(name))
  1147.         code+="i"*namenum[0]
  1148.         if len(namenum)>1:
  1149.             for numb in namenum[1:]:
  1150.                 code+="b"
  1151.                 code+="I"*numb
  1152.         if tffunc(c)[0]:
  1153.             code+="ZxlaCzx"
  1154.         else:
  1155.             code+="Zx"
  1156.         name = tup[2]#var name
  1157.         namenum = noupper(number(name))
  1158.         code+="i"*namenum[0]
  1159.         if len(namenum)>1:
  1160.             for numb in namenum[1:]:
  1161.                 code+="b"
  1162.                 code+="I"*numb
  1163.         if tffunc(c)[1]:
  1164.             code+="Zxaalxzxy"
  1165.         else:
  1166.             code+="Zxy"
  1167.     elif nostring(c).find("if")==0 and nostring(c)[-1]==":":#logic
  1168.         nos = nostring(c).replace("##","#")[2:-1]
  1169.         tf3 = truefalse3(c)#65
  1170.         if nos.count("<=")==1:
  1171.             revers = False
  1172.             value = noupper( number( nos.split("<=")[1][1:] ) )
  1173.             code+= "i"*value[0]
  1174.             if len(value)>1:
  1175.                 for val in value[1:]:
  1176.                     code+="b"
  1177.                     code+="I"*val
  1178.                 code+="Z"
  1179.            
  1180.             if tf3[1]:
  1181.                 code+="xlxlxaaxzc"
  1182.             else:
  1183.                 code+="xlxaaxzc"
  1184.  
  1185.             value = noupper( number( nos.split("<=")[0][1:] ) )
  1186.             code+= "i"*value[0]
  1187.             if len(value)>1:
  1188.                 for val in value[1:]:
  1189.                     code+="b"
  1190.                     code+="I"*val
  1191.                 code+="Z"
  1192.             if tf3[0]:
  1193.                 code+="xlxlaaxz{"#oxox
  1194.             else:
  1195.                 code+="xlaaxz{"
  1196.         elif nos.count(">=")==1:
  1197.                 revers = True
  1198.                 value = noupper( number( nos.split(">=")[1][1:] ) )
  1199.                 code+= "i"*value[0]
  1200.                 if len(value)>1:
  1201.                     for val in value[1:]:
  1202.                         code+="b"
  1203.                         code+="I"*val
  1204.                     code+="Z"
  1205.                 if tf3[1]:
  1206.                     code+="xlxlxaaxzc"
  1207.                 else:
  1208.                     code+="xlxaaxzc"
  1209.  
  1210.                 value = noupper( number( nos.split(">=")[0][1:] ) )
  1211.                 code+= "i"*value[0]
  1212.                 if len(value)>1:
  1213.                     for val in value[1:]:
  1214.                         code+="b"
  1215.                         code+="I"*val
  1216.                     code+="Z"
  1217.                 if tf3[0]:
  1218.                     code+="xlxlaaxzx{"
  1219.                 else:
  1220.                     code+="xlaaxzx{"
  1221.         elif nos.count("<")==1:
  1222.                 revers = False
  1223.                 value = noupper( number( nos.split("<")[1][1:] ) )
  1224.                 code+= "i"*value[0]
  1225.                 if len(value)>1:
  1226.                     for val in value[1:]:
  1227.                         code+="b"
  1228.                         code+="I"*val
  1229.                     code+="Z"
  1230.                 if tf3[1]:
  1231.                     code+="xlxlxaaxzc"
  1232.                 else:
  1233.                     code+="xlxaaxzc"
  1234.  
  1235.                 value = noupper( number( nos.split("<")[0][1:] ) )
  1236.                 code+= "i"*value[0]
  1237.                 if len(value)>1:
  1238.                     for val in value[1:]:
  1239.                         code+="b"
  1240.                         code+="I"*val
  1241.                     code+="Z"
  1242.                 if tf3[0]:
  1243.                     code+="xlxlaaxz<"
  1244.                 else:
  1245.                     code+="xlaaxz<"
  1246.         elif nos.count(">")==1:
  1247.                 revers = True
  1248.                 value = noupper( number( nos.split(">")[1][1:] ) )
  1249.                 code+= "i"*value[0]
  1250.                 if len(value)>1:
  1251.                     for val in value[1:]:
  1252.                         code+="b"
  1253.                         code+="I"*val
  1254.                     code+="Z"
  1255.                 if tf3[1]:
  1256.                     code+="xlxlxaaxzc"
  1257.                 else:
  1258.                     code+="xlxaaxzc"
  1259.  
  1260.                 value = noupper( number( nos.split(">")[0][1:] ) )
  1261.                 code+= "i"*value[0]
  1262.                 if len(value)>1:
  1263.                     for val in value[1:]:
  1264.                         code+="b"
  1265.                         code+="I"*val
  1266.                     code+="Z"
  1267.                 if tf3[0]:
  1268.                     code+="xlxlaaxzx<"
  1269.                 else:
  1270.                     code+="xlaaxzx<"
  1271.         elif nos.count("=")==1 and nos.count("!=")==0:
  1272.             revers = False
  1273.             value = noupper( number( nos.split("=")[1][1:] ) )
  1274.             code+= "i"*value[0]
  1275.             if len(value)>1:
  1276.                 for val in value[1:]:
  1277.                     code+="b"
  1278.                     code+="I"*val
  1279.                 code+="Z"
  1280.             if tf3[1]:
  1281.                 code+="xlxlxaaxzc"
  1282.             else:
  1283.                 code+="xlxaaxzc"
  1284.  
  1285.             value = noupper( number( nos.split("=")[0][1:] ) )#bug v45
  1286.             code+= "i"*value[0]
  1287.             if len(value)>1:
  1288.                 for val in value[1:]:
  1289.                     code+="b"
  1290.                     code+="I"*val
  1291.                 code+="Z"
  1292.             if tf3[0]:
  1293.                 code+="xlxlaaxz="
  1294.             else:
  1295.                 code+="xlaaxz="
  1296.         elif nos.count("!=")==1:
  1297.             revers = False
  1298.             value = noupper( number( nos.split("!=")[1][1:] ) )
  1299.             code+= "i"*value[0]
  1300.             if len(value)>1:
  1301.                 for val in value[1:]:
  1302.                     code+="b"
  1303.                     code+="I"*val
  1304.                 code+="Z"
  1305.             if tf3[1]:
  1306.                 code+="xlxlxaaxzc"
  1307.             else:
  1308.                 code+="xlxaaxzc"
  1309.  
  1310.             value = noupper( number( nos.split("!=")[0][1:] ) )
  1311.             code+= "i"*value[0]
  1312.             if len(value)>1:
  1313.                 for val in value[1:]:
  1314.                     code+="b"
  1315.                     code+="I"*val
  1316.                 code+="Z"
  1317.             if tf3[0]:
  1318.                 code+="xlxlaaxz!"
  1319.             code+="xlaaxz!"
  1320.  
  1321.         elif nos.count("not")==0:#bools v 65
  1322.             revers = False
  1323.             double = False
  1324.             if c.count("#")==2:
  1325.                 double=True
  1326.            
  1327.             value = noupper( number( nos[1:] ) )
  1328.             code+= "i"*value[0]
  1329.             if len(value)>1:
  1330.                 for val in value[1:]:
  1331.                     code+="b"
  1332.                     code+="I"*val
  1333.                 code+="Z"
  1334.             if double:
  1335.                 code+="xlxl]"
  1336.             else:
  1337.                 code+="xl]"
  1338.         elif nos.count("not")==1:
  1339.             revers = False
  1340.             double = False
  1341.             if c.count("#")==2:
  1342.                 double=True
  1343.            
  1344.             value = noupper( number( nos[4:] ) )
  1345.             code+= "i"*value[0]
  1346.             if len(value)>1:
  1347.                 for val in value[1:]:
  1348.                     code+="b"
  1349.                     code+="I"*val
  1350.                 code+="Z"
  1351.             if double:
  1352.                 code+="xlxl["
  1353.             else:
  1354.                 code+="xl["
  1355.  
  1356.     elif nostring(c).count("else:")==1:
  1357.         code+="."
  1358.     elif nostring(c).count("elif")==1:
  1359.         code+=","
  1360.         comm = nostring(c)[4:-1]#v67 #no bool support
  1361.         if revers:
  1362.             code+="x"
  1363.         if comm=="=":
  1364.             code+="="
  1365.             revers = False
  1366.         elif comm=="<":
  1367.             code+="<"
  1368.             revers = False
  1369.         elif comm=="!=":
  1370.             code+="!"
  1371.             revers = False
  1372.         elif comm=="<=":
  1373.             code+="{"
  1374.             revers = False
  1375.         elif comm==">":
  1376.             code+="x<"
  1377.             revers = True
  1378.         elif code==">=":
  1379.             code+="x{"
  1380.             revers = True
  1381.     elif c[0]==":":
  1382.         name = nostring(c)[1:]
  1383.         value = noupper( number( name ) )
  1384.         code+= "i"*value[0]
  1385.         if len(value)>1:
  1386.             for val in value[1:]:
  1387.                 code+="b"
  1388.                 code+="I"*val
  1389.             code+="Z"
  1390.         code+=";"
  1391.     elif c=="halt":
  1392.         code+="@"
  1393.     elif c.count("root")==1 and c.index("root")==0:
  1394.         value = noupper( number( c.replace("##","#").split("#")[1] ) )#v66
  1395.         code+= "i"*value[0]
  1396.         if len(value)>1:
  1397.             for val in value[1:]:
  1398.                 code+="b"
  1399.                 code+="I"*val
  1400.             code+="Z"
  1401.         if tffunc(c)[0]:
  1402.             code+="xlxlrf"
  1403.         else:
  1404.             code+="xlrf"
  1405.     elif c.count("pass")==1 and c.index("pass")==0:
  1406.         code+=""
  1407.     elif c.count("jump")==1 and c.index("jump")==0:
  1408.         name = c.split(":")[1]
  1409.         value = noupper( number( name ) )
  1410.         code+= "i"*value[0]
  1411.         if len(value)>1:
  1412.             for val in value[1:]:
  1413.                 code+="b"
  1414.                 code+="I"*val
  1415.             code+="Z"
  1416.         code+="j"
  1417.     if not foc==len(inpcomm)-2:
  1418.         code+="zZaCaczc"#variable cleanup
  1419.    
  1420.     foc+=1
  1421. print(code)
  1422. if outputbool:
  1423.     f = open("output.txt","w")
  1424.     f.write(code)
  1425.     f.close()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!