#!/usr/bin/env python
# coding: utf-8
#### license: creative commons cc0 1.0 (public domain)
#### http://creativecommons.org/publicdomain/zero/1.0/
proginf = "fig 2.7, oct 2015 mn"
import sys
import os
from sys import stdin, stdout
from os import popen
try: from colorama import init ; init()
except: pass

buf = []

def outfilewrite(outb, p):
    outb += [p]

def color(f, b):
    if f == None: f = 0
    if b == None: b = 0
    n = "0"
    if f > 7: n = "1" ; f = f - 8
    if f == 1: f = 4 ## switch ansi colors for qb colors
    elif f == 4: f = 1 ## 1 = blue not red, 4 = red not blue, etc.
    if f == 3: f = 6
    elif f == 6: f = 3
    if b > 7: b = b - 8
    if b == 1: b = 4
    elif b == 4: b = 1
    if b == 3: b = 6
    elif b == 6: b = 3
    stdout.write("\x1b[" + n + ";" + str(30+f) + ";" + str(40+b) + "m")
    return "\x1b[" + n + ";" + str(30+f) + ";" + str(40+b) + "m"

def bcolor(b):
    f = None
    if f == None: f = 0
    if b == None: b = 0
    n = "0"
    if f > 7: n = "1" ; f = f - 8
    if f == 1: f = 4 ## switch ansi colors for qb colors
    elif f == 4: f = 1 ## 1 = blue not red, 4 = red not blue, etc.
    if f == 3: f = 6
    elif f == 6: f = 3
    if b > 7: b = b - 8
    if b == 1: b = 4
    elif b == 4: b = 1
    if b == 3: b = 6
    elif b == 6: b = 3
    stdout.write("\x1b[" + n + ";" + str(30+f) + ";" + str(40+b) + "m")
    return "\x1b[" + n + str(40+b) + "m"

def sgn(p):
    p = float(p)
    if p > 0: return 1
    if p < 0: return -1
    return 0

def left(p, s):
    return p[:s]

def right(p, s):
    return p[-s:]

def leftfour(p):
    try:
        if left(p, 4) == chr(32) * 4: p = right(p, len(p) - 4)
    except:
        pass
    return p

def atleast(s, p):
    if p < s: return s
    else: return p

def figfsplit(p):
    # return p.split() # that was fine when strings weren't tokens
    # we have to make this 3 tokens: variable "hello, world!" #comment not string

    px = []
    pxc = -1 # could use len(px) -1 instead?

    inquotes = 0
    remarked = 0
    inspc = "" ; vnspc = ""

    #print "->", p

    for l in p:
        if inquotes == 0 and remarked == 0 and l == "#":
            remarked = 1
            pxc += 1 ; px += [""]
        if remarked == 1:
            px[pxc] += l

        if remarked == 0:
            if l == "\"":
                if inquotes == 0:
                    inquotes = 1 ; pxc += 1 ; px += [""]
                else: inquotes = 0 #; px[pxc] += l
        if inquotes == 1: px[pxc] += l

        if remarked == 0 and inquotes == 0:
            if vnspc not in "1234567890-" + chr(32) and l[0] == ".": l = " "
            vnspc = l
            if l[0] in "():;|=,": l = " "
            if inspc != " " and l == " ": pxc += 1 ; px += [""]
            if l != " ":
                if pxc == -1: pxc += 1 ; px += [""]
                px[pxc] += l.lower()
            inspc = l
    #print "->", px[:]
    while ('') in px: px.remove('')
    while (':') in px: px.remove(':')
    for p in range(len(px)):
        if px[p][0] != "#":
            if right(px[p], 1) == ":":
                lenpx = len(px[p]) - 1
                if lenpx > 0:
                    px[p] = left(px[p], lenpx)
    return px[:]

def nob(p, s):
    r = ""
    if s == len(p) - 1:
        if len(p):
            if p[s].rstrip() != ".": r = p[s].rstrip()
        if len(r):
            if r[-1:] == ".": r = left(r, len(r) - 1)
    pfig = ""
    try: pfig = left(p[s], 3)
    except: pfig = ""
    if pfig.lower() == "fig" and p[s].lower() != "fig": return "figg"
    try:
        if r != "": return r
        else: return p[s]
    except: return ""

def snobl(p):
    if "\"" in p: return p
    else: return p.lower()

def snob(p, s):
    r = ""
    if s == len(p) - 1:
        if len(p):
            if p[s].rstrip() != ".": r = p[s].rstrip()
        if len(r):
            if r[-1:] == ".": r = left(r, len(r) - 1)
    pqt = ""
    try: pqt = left(p[s], 2)
    except: pqt = ""
    if pqt.lower() == "qt" and p[s].lower() != "qt": return "qtt"
    try:
        if r != "": return snobl(r)
        else: return snobl(p[s])
    except: return ""

def lnob(p, s):
    r = ""
    if s == len(p) - 1:
        if len(p):
            if p[s].rstrip() != ".": r = p[s].rstrip()
        if len(r):
            if r[-1:] == ".": r = left(r, len(r) - 1)
    pfig = ""
    try: pfig = left(p[s], 3)
    except: pfig = ""
    if pfig.lower() == "fig" and p[s].lower() != "fig": return "figg"
    try:
        if r != "": return r.lower()
        else: return p[s].lower()
    except: return ""

def stripcoords(p):
    ps = ""
    for s in str(p):
        if s in "1234567890.": ps += s
    return ps

def getmore(p, s):
    try:
        for t in range(1, s + 1):
            if len(p) == 1: p = []
            p = right(p, len(p) - 1)
        while "" in p: p.remove("")
        for prx in range(len(p)):
            if p[prx][0] == "#":
                p.remove(p[prx])
        return p
    except: return []

def getlmore(p, s):
    try:
        for t in range(1, s + 1):
            if len(p) == 1: p = []
            p = right(p, len(p) - 1)
        while "" in p: p.remove("")
        return p
    except: return []

def getpairs(p, s):
    r = ""
    if len(p):
        if p[len(p) - 1].rstrip() != ".": r = p[len(p) - 1].rstrip()
    if len(r):
        if r[-1:] == ".":
            r = left(r, len(r) - 1)
            p[len(p) - 1] = r
    try:
        p = right(p, len(p) - s)
        if not len(p) % 2: return p
        else: return []
    except: return []

def lc():
    global linecount
    global flen
    es = " \x1b[0;37;40m"
    return "\x1b[0;37;44m" + right(chr(32) * flen + str(linecount), flen) + es

def wr(p):
    global buf
    buf += [p + "\n"]

color(11, None) ; print proginf; color(7, None) ; print

addtoout = [0]
addto = [0]

addtoout[0] = """import sys, os
from sys import stdin, stdout
try: from colorama import init ; init()
except: pass # (only) windows users want colorama installed or ansi.sys enabled
from random import randint
from time import sleep\n\n
from os import chdir as figoch
from os import popen as figpo
from os import system as figsh
from os import name as figosname
figsysteme = 0
figfilehandles = {}
figfilecounters = {}
"""

addtoout += [0] ; addto += [0]

addtoout[1] = """from sys import stdout
def figlocate(x, l = "ignore", c = "ignore"):
    import sys
    if l == "ignore" and c == "ignore": pass
    # do nothing. want it to return an error?

    elif l < 1 and c != "ignore":
        sys.stdout.write("\x1b[" + str(c) + "G") # not ansi.sys compatible
    elif l != "ignore" and c == "ignore":
        sys.stdout.write("\x1b[" + str(l) + ";" + str(1) + "H")
    else: sys.stdout.write("\x1b[" + str(l) + ";" + str(c) + "H")

import time

def fignonz(p, n=None):
    if n==None:
        if p == 0: return 1
    else:
        if p == 0: return n
    return p

def fignot(p):
    if p: return 0
    return -1

figbac = None
figprsbac = None
sub = None
def fignone(p, figbac):
    if p == None: return figbac
    return p
    return -1

def stopgraphics():
    global yourscreen
    global figraphics
    figraphics = 0
    try: pygame.quit()
    except: pass\n
\n"""
addtoout += [0] ; addto += [0]

addtoout[2] = """palette = {}
palette["black"] = (0, 0, 0)
palette["gray"], palette["grey"] = (0, 0, 0), (85, 85, 85)
palette["blue"], palette["lightblue"] = (0, 0, 170), (85, 85, 255)
palette["green"], palette["lightgreen"] = (0, 170, 0), (85, 255, 85)
palette["cyan"], palette["lightcyan"] = (0, 170, 170), (85, 255, 255)
palette["red"], palette["lightred"] = (170, 0, 0), (255, 85, 85)
palette["magenta"], palette["lightmagenta"] = (170, 0, 170), (255, 85, 255)
palette["brown"], palette["yellow"] = (170, 85, 0), (255, 255, 85)
palette["white"], palette["lightwhite"] = (170, 170, 170), (255, 255, 255)\n"""
addtoout += [0] ; addto += [0]

addtoout[3] = """figraphics = -1
figrupd = 1
try: import pygame
except: figraphics = 0
yourscreen = ""
try: pygame.init()
except: figraphics = 0 # unable to init pygame, just use text
def figpset(z, x, y, c):
    global figraphics, figrupd
    global yourscreen
    global figcgapal
    if figraphics == -1:
        #pygame.init()
        try:
            yourscreen = pygame.display.set_mode((800, 600))
            pygame.display.set_caption("fig graphics screen")
            #pygame.quit()
            figraphics = 1
        except:
            stopgraphics() ; figraphics = 0
    if figraphics == 0:
        if x > -1 and y > -1:
            figcolortext(c, c)
            figlocate(0, int(y) + 1, int(x) + 1) ; stdout.write(unichr(9608))
            sys.stdout.flush()
    if figraphics == 1:
        if x > -1 and y > -1:
            yourscreen.set_at((x, y), figcgapal[c])
            #pygame.draw.circle(yourscreen,(255, 255, 255),(int(x), int(y)), 1, 0)
            if figrupd: pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    figraphics = 0
                    stopgraphics()

def figline(z, x, y, x2, y2, c):
    global figraphics, figrupd
    global yourscreen
    global figcgapal
    if figraphics == -1:
        #pygame.init()
        try:
            yourscreen = pygame.display.set_mode((800, 600))
            pygame.display.set_caption("fig graphics screen")
            #pygame.quit()
            figraphics = 1
        except:
            stopgraphics() ; figraphics = 0
    if figraphics == 0:
        if x > -1 and y > -1 and x2 > -1 and y2 > -1:
            figcolortext(c, c)
            if x2 < x: x, y, x2, y2 = x2, y2, x, y
            figliney = [y, y2]
            figlinec = 0
            figlinestep = int(y2 - y)
            if figlinestep < 0: figlinestep = int(y - y2) ; figlinec = 0
            if figlinestep < 1: figlinestep = 1
            figlinestep = float(1) / figlinestep
            figlinex = x
            while 1:
                if figlinex > x2: break
                if y2 - y == 0:
                    figlocate(0, int(y) + 1, int(figlinex) + 1)
                    stdout.write(unichr(9608))
                elif y2 < y:
                    figlinec -= figlinestep
                    figlocate(0, int(y + int(float(y - y2) / fignonz(x2 - x,.1) *
                    fignonz(figlinec,.1) ) ) + 1, int(figlinex) + 1)
                    stdout.write(unichr(9608))
                else:
                    figlocate(0, int(y + int(float(y2 - y) / fignonz(x2 - x,.1) *
                    fignonz ( figlinec,.1) ) ) + 1, int(figlinex) + 1) ;
                    stdout.write(unichr(9608))
                    figlinec += figlinestep
                    #[0] = figliney[0]+float(figliney[1] - figliney[0]) / (x2 - x)
                figlinex += figlinestep
            figlocate(0, int(y) + 1, int(x) + 1) ; stdout.write(unichr(9608))
            figlocate(0, int(y2) + 1, int(x2) + 1) ; stdout.write(unichr(9608))
            sys.stdout.flush()
    if figraphics == 1:
        if x > -1 and y > -1 and x2 > -1 and y2 > -1:
            yourscreen.set_at((x, y), figcgapal[c])
            pygame.draw.line(yourscreen, figcgapal[c], (x, y), (x2, y2), 1)
            if figrupd: pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    figraphics = 0
                    stopgraphics()

def anykeypyg():
    global yourscreen
    global figraphics, figrupd
    p = 0
    while not p:
        if figraphics == 0: break
        time.sleep(0.001)
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if figrupd: pygame.display.update()
                p = 1\n\n"""

addtoout += [0] ; addto += [0]

palette = {}
palette["black"] = (0, 0, 0)
palette["gray"], palette["grey"] = (0, 0, 0), (85, 85, 85)
palette["blue"], palette["lightblue"] = (0, 0, 170), (85, 85, 255)
palette["green"], palette["lightgreen"] = (0, 170, 0), (85, 255, 85)
palette["cyan"], palette["lightcyan"] = (0, 170, 170), (85, 255, 255)
palette["red"], palette["lightred"] = (170, 0, 0), (255, 85, 85)
palette["magenta"], palette["lightmagenta"] = (170, 0, 170), (255, 85, 255)
palette["brown"], palette["yellow"] = (170, 85, 0), (255, 255, 85)
palette["white"], palette["lightwhite"] = (170, 170, 170), (255, 255, 255)

textpalette = {}
textpalette["black"],textpalette["gray"], palette["grey"] = 0, 8, 8
textpalette["blue"], textpalette["lightblue"] = 1, 9
textpalette["green"], textpalette["lightgreen"] = 2, 10
textpalette["cyan"], textpalette["lightcyan"] = 3, 11
textpalette["red"], textpalette["lightred"] = 4, 12
textpalette["magenta"], textpalette["lightmagenta"] = 5, 13
textpalette["brown"], textpalette["yellow"] = 6, 14
textpalette["white"], textpalette["lightwhite"] = 7, 15

# -2: print(variable, etc)
# -1: print(variable), 0: variable = int(variable), 1: variable=left(variable, etc)

cmds = {"ltrim":0, "lineinput":0, "len":0, "asc":0, "atn":0, "str":0,
"get":1, "chr":0, "prints":-1, "sleep":-2, "arrsort":-1,
"arreverse":-1, "reverse":0, "display":-1, "system":-1, "end":-1,
"print":-1, "arrset":-3,
"split":2, "left":1, "join":2, "arrget":2, "mid":2, "right":1,
"plus":1, "times":1, "close":-1, "cls":-1, "flineinput":1, "fprint":-2,
"open":-2, "arropen":1, "arrstdin":0, "arrcurl":1, "colortext":-2,
"highlight":-2, "divby":1, "hex":0, "rtrim":0, "string":2, "timer":0,
"time":0, "date":0, "tan":0, "oct":0, "val":0, "minus":1, "lcase":0, "ucase":0,
"int":0, "left":1, "swap":-3, "locate":-3, "pset":-4, "line":-6,
"return":-2, "randint":2, "topwr":1, "arr":0, "mod":1, "cos":0,
"not":0, "sin":0, "instr":2, "chdir":-1, "shell":-1, "arrshell":0,
"sgn":0, "sqr":0}

funcs = {"function" : -1, "iftrue" : -2, "ifequal" : -3, "ifless" : -3,
"ifmore" : -3, "try":0, "except":0, "resume":0, "else":0}

ufunc = {}

#addfuncs = addtoout[0] + addtoout[1] + addtoout[3] + """
addfuncs = """
def figcolortext(x, f):
    b = 0
    if f == None: f = 0
    if b == None: b = 0
    n = "0"
    if f > 7: n = "1" ; f = f - 8
    if f == 1: f = 4 ## switch ansi colors for qb colors
    elif f == 4: f = 1 ## 1 = blue not red, 4 = red not blue, etc.
    if f == 3: f = 6
    elif f == 6: f = 3
    if b > 7: b = b - 8
    if b == 1: b = 4
    elif b == 4: b = 1
    if b == 3: b = 6
    elif b == 6: b = 3
    stdout.write("\\x1b[" + n + ";" + str(30+f) + "m")
    return "\\x1b[" + n + ";" + str(30+f) + ";" + str(40+b) + "m"

figcgapal = [(0, 0, 0), (0, 0, 170), (0, 170, 0), (0, 170, 170),
(170, 0, 0), (170, 0, 170), (170, 85, 0), (170, 170, 170),
(85, 85, 85), (85, 85, 255), (85, 255, 85), (85, 255, 255),
(255, 85, 85), (255, 85, 255), (255, 255, 85), (255, 255, 255)]

def figget(p, s): return s

def fighighlight(x, b):
    f = None
    if f == None: f = 0
    if b == None: b = 0
    n = "0"
    if f > 7: n = "1" ; f = f - 8
    if f == 1: f = 4 ## switch ansi colors for qb colors
    elif f == 4: f = 1 ## 1 = blue not red, 4 = red not blue, etc.
    if f == 3: f = 6
    elif f == 6: f = 3
    if b > 7: b = b - 8
    if b == 1: b = 4
    elif b == 4: b = 1
    if b == 3: b = 6
    elif b == 6: b = 3
    stdout.write("\\x1b[" + n + str(40+b) + "m")
    return "\\x1b[" + n + str(40+b) + "m"

def figinstr(x, p, e):
    try: return p.index(e) + 1
    except: return 0

def figchdir(p):
    try: figoch(p)
    except: print "no such file or directory: " + str(p) ; figend(1)

def figshell(p):
    global figsysteme
    try: figsysteme = figsh(p)
    except:
        print "error running shell command: " + chr(34) + str(p) + chr(34)
        figend(1)

def figarrshell(c):
    global figsysteme
    try:
        figsysteme = 0
        sh = figpo(c)
        ps = sh.read().replace(chr(13) + chr(10),
        chr(10)).replace(chr(13), chr(10)).split(chr(10))
        figsysteme = sh.close()
    except:
        print "error running arrshell command: " + chr(34) + str(c) + chr(34)
        figend(1)
    return ps[:]

def figsgn(p):
    p = float(p)
    if p > 0: return 1
    if p < 0: return -1
    return 0

def figstr(p): return str(p)
def figprint(p): print p
def figchr(p):
    if type(p) == str:
        if len(p) > 0:
            return p[0]
    return chr(p)
def figprints(p): stdout.write(str(p)) ; sys.stdout.flush()
def figleft(p, s): return p[:s]
def figmid(p, s, x):
    arr = 0
    if type(p) == list or type(p) == tuple: arr = 1
    rt = p[s - 1:x + s - 1]
    if arr and len(rt) == 1: rt = rt[0]
    return rt
def figright(p, s): return p[-s:]
def figrandint(x, s, f):
    return randint(s, f)
def figlcase(p): return p.lower()

def figucase(p): return p.upper()
def figint(p): return int(p)

def figarrset(x, p, s):
    if 1:
        #if type(p) == str: p = p + s # str(s) if you want it easier
        if 1: #type(p) == list:
            if type(s) == tuple:
                if len(s) == 1: fas = s[0]
            elif type(s) == list:
                if len(s) == 1: fas = s[0]
            else:
                fas = s
            x[p - 1] = s
        #if type(p) == tuple:
        #    if type(s) == tuple:
        #        p = tuple(list(p) + list(s))
        #    elif type(s) == list:
        #        p = tuple(list(p) + s[:])
        #    else:
        #        p = tuple(list(p) + [s])
        #if type(p) == str: p = p + s # str(s) if you want it easier

def figopen(x, s):
    import fileinput
    if s.lower() == "w":
        if (x) not in figfilehandles.keys():
            figfilehandles[x] = open(x[:], s.lower())
    elif s.lower() == "r":
        if (x) not in figfilehandles.keys():
            figfilehandles[x] = fileinput.input(x[:])
            figfilecounters[x] = 0
    else:
        if (x) not in figfilehandles.keys(): figfilehandles[x] = open(x[:], s[:])

def figfprint(x, s):
    fon = figosname
    sep = chr(10)
    if fon == "nt": sep = chr(13) + chr(10)
    figfilehandles[s].write(str(x) + sep)

def figflineinput(x, s):
    try:
        p = figfilehandles[s][figfilecounters[s]].replace(chr(13),
        "").replace(chr(10), "")
        figfilecounters[s] += 1
    except:
        p = chr(10)
    return p

def figclose(x):
    if (x) in figfilehandles.keys():
        figfilehandles[x].close() ; del figfilehandles[x]
        try: del figfilecounters[x]
        except: pass

def figcls(x):
    if figosname == "nt": cls = figsh("cls")
    else: stdout.write("\x1b[2J\x1b[1;1H") ; sys.stdout.flush()

def figarropen(x, s):
    x = open(s).read().replace(chr(13) + chr(10), chr(10)).replace(chr(13),
    chr(10)).split(chr(10))
    return x[:]

def figarrcurl(x, s):
    from urllib import urlopen
    x = str(urlopen(s).read()) ; x = x.replace(chr(13) + chr(10),
    chr(10)).replace(chr(13), chr(10)).split(chr(10))
    return x[:]

def figarrstdin(x):
    ps = []
    for p in stdin: ps += [p[:-1]]
    return ps[:]

def figarrget(x, p, s):
    if 1:
        return p[s - 1]

def figplus(p, s):
    if type(p) in (float, int):
        if type(s) in (float, int):
            p = p + s
        else:
            p = p + s # float(s) if you want it easier
        if p == float(int(p)): p = int(p)
    else:
        if type(p) == str: p = p + s # str(s) if you want it easier
        if type(p) == list:
            if type(s) == tuple:
                p = p + list(s)
            elif type(s) == list:
                p = p + s[:]
            else:
                p = p + [s]
        if type(p) == tuple:
            if type(s) == tuple:
                p = tuple(list(p) + list(s))
            elif type(s) == list:
                p = tuple(list(p) + s[:])
            else:
                p = tuple(list(p) + [s])
    return p

def figjoin(p, x, s):
    t = ""
    if len(x) : t = str(x[0])
    for c in range(len(x)):
        if c > 0: t += str(s) + str(x[c])
    return t # s.join(x)

def figarr(p):
    if type(p) in (float, int, str):
        p = [p]
    else:
        p = list(p)
    return p

def figsplit(p, x, s):
    return x.split(s)

def figval(n):
    n = float(n)
    if float(int(n)) == float(n): n = int(n)
    return n
def figtimes(p, s):
    if type(p) in (float, int):
        p = p * s # float(s) if you want it easier
        if p == float(int(p)): p = int(p)
    else:
        if type(p) == list:
            p = p[:] * s # figval(s)
        else:
            p = p * s # figval(s) if you want it easer
    return p
def figdivby(p, s):
    p = float(p) / s
    if p == float(int(p)): p = int(p)
    return p
def figminus(p, s): return p - s

def figtopwr(p, s):
    p = p ** s
    if p == float(int(p)): p = int(p)
    return p
def figmod(p, s):
    return p % s
def figcos(p):
    from math import cos ; p = cos(p)
    if p == float(int(p)): p = int(p)
    return p
def figsin(p):
    from math import sin ; p = sin(p)
    if p == float(int(p)): p = int(p)
    return p
def figsqr(p):
    from math import sqrt ; p = sqrt(p)
    if p == float(int(p)): p = int(p)
    return p

def figltrim(p): return p.lstrip()
def figlineinput(p): return raw_input()
def figlen(p): return len(p)
def figasc(p): return ord(p[0])
def figatn(p):
    from math import atan ; p = atan(p)
    if p == float(int(p)): p = int(p)
    return p

def fighex(p): return hex(p)
def figrtrim(p): return p.rstrip()
def figstring(x, p, n):
    if type(n) == str: return n * p
    return chr(n) * p
def figtimer(p):
    from time import strftime
    return int(strftime("%H"))*60*60+int(strftime("%M"))*60+int(strftime("%S"))

def figtime(p): from time import strftime ; return strftime("%H:%M:%S")

def figdate(p): from time import strftime ; return strftime("%m/%d/%Y")

def figtan(p):
    from math import tan ; p = tan(p)
    if p == float(int(p)): p = int(p)
    return p

def figoct(p): return oct(p)

def figsleep(p, s):
    #print lc() + p
    #addto[0] = 1
    sleep(s)
def figarrsort(p):
    p.sort()

def figdisplay(x):
    global figraphics, figrupd
    figrupd = 0
    if figraphics == 1:
        pygame.display.update()

def figreverse(p):
    if type(p) == list: p.reverse() ; return p
    elif type(p) == str:
        p = map(str, p) ; p.reverse()
        p = "".join(p)
        return p

def figarreverse(p):
    p.reverse()

def figfunction(p, s): return p
def figend(x): quit()
def figif(p, s): return p
def figthen(p, s): return p
def figsystem(x): quit()
\n"""

demo = """
p 7 arr times 5

x "hello, world!"
#z x prints
#z x print
x 5
x 5 times 7
x 3 plus 5 times 7
z x abs
x z str asc abs int

function hello p  |  # function hello(p)
x "hello, "       |  # x = "hello, "
x prints return 5 |  # print x; : hello = 5 : exit function
fig               |  # end function

x hello x         |  # x = hello(x)

#x if 5```````````````` # if x = 5 then
#p "five" print```````` # p = "five" : print p
#else`````````````````` # else
#p "not 5 or 7" print`` # p = "not 5 or 7" : print p
#fig````````````````````# end if

#y x````````````````````# y = x
#y chr 70 mid y 1 1```` # y = chr(70) : y = mid(y, 1, 1)
#x print sleep 2 cls````# print x : sleep 2 : cls

p print
p print arrset 2 8 print
z join p "(_)" print
x z print
p print end

#p "hello, world!" left 5 ucase locate 5 7 prints # comment comment
#y 100 chr rtrim print
#z 32 chr print print print swap y p

#x int plus 5 times 7 colortext 11 highlight 1 prints
#y 32 highlight 0 colortext 14 chr prints
#x 97
#y 97 plus 25

#for n x y 1
#for p x y 1
#for pp x y 1
#z n chr prints
#z p chr prints
#z pp chr prints
#z 32 chr prints
#next
#z 32 chr print
#next
#next

#while
#  y 10 print  # these indents are optional, they don't do anything
#  iftrue y
#    break # this command breaks from while, never from if
#    fig
#  wend
function pete
p "hello" print
fig

function add5 r
x get r plus 5 return x
fig

#z pete
#y 12
#p z add5 y colortext 7 print sleep 1

function ppp
z 32 chr print
for p 1 100 1
x randint 0 3
y randint 0 3
c randint 1 9
#z pset x y c
c colortext 7
next
fig

z ppp
z sleep 1
#textmode
z ppp sleep 2 z ppp
"""

p = ""
try: p = right(sys.argv, 1)[0]
except: pass
if not ".fig" in p.lower():
    #try: inputfile = stdin.read().replace(chr(13), "").split("\n")
    #except:
    #print "need an input file to do anything..."; print ; quit()
    print "using built-in demo source, translating to demo.fig.py..." ; print
    p = "demo.fig"
    inputfile = demo.replace(chr(13), "").split("\n")
else:
    try:
        inputfile = open(p).read().replace(chr(13) + chr(10),
        chr(10)).replace(chr(13), chr(10)).split(chr(10))
    except: print "couldn't open \"" + p + "\", exiting." ; print ; quit()
try: outfile = open(p + ".py", "w")
except: print "couldn't write to \"" + p + ".py" "\", exiting." ; print ; quit()
outname = p + ".py"

flen = len(str(len(inputfile)))

linecount = 0
indent = 0
inlinep = 0
errorin = 0
errorsrc = ""
error = ""
mode = 0
figraphics = -1 # -1 = uninitialized, 0 = textmode, 1 = initialized
vrs = []
vr = ""
outb = []
ingfx = 0

for p in inputfile:
    linecount += 1

    if linecount == 1:
        outfile.write("#!/usr/bin/env python" + "\n# encoding: utf-8\n")
        if "," in proginf:
            outfile.write("# fig translator version: " + proginf.split(",")[0] + "\n")
    if inlinep:
        if p.lower().strip() == "fig":
            inlinep = 0
            print lc() + p
            indent = atleast(0, indent - 4)
        else:
            print lc() + color(2, None) + p + color(7, None)
            outfilewrite(outb, chr(32) * atleast(0, indent - 4) +
            leftfour(p) + "\n")

    elif mode == "output the following:":
        if p.lower().strip() == "display":
            mode = 0
            print lc() + p
        else:
            wr(chr(32) * atleast(0, indent) + "print \"" + p.replace(chr(34),
            "\" + chr(34) + \"").replace(chr(92), "\" + chr(92) + \"") + "\"")
            print lc() + p.replace(chr(34), "\" + chr(34) + \"").replace(chr(92),
            "\" + chr(92) + \"")

    elif mode == 0:
        x = figfsplit(p.lstrip())
        lp = p.lower()
        if not len(p):
            print lc() + ""
            outfilewrite(outb, "\n")
            # assuming you want blank lines in your python output, too

        if len(p.lstrip()):

            e = 0

            if p.lstrip()[0] == "#":
                if linecount == 1:
                    es = 0
                    try:
                         if p.lstrip()[1] == "!": es = 1
                    except: es = 0
                    if not es:
                        wr(p)
                        print lc() + p
                    else: print lc() + "[this first comment isn't copied over]"
                    es = 0
                else:
                    outfilewrite(outb, chr(32) * atleast(0, indent) + p + "\n")
                    print lc() + p

            elif lnob(x, 0) == "figg":
                 e = 2

            elif lnob(x, 0) == "highlight":

                e = 1 # watch for errors in structure
                if lnob(x, 1) in textpalette.keys():
                    e = 0
                    print lc() + p
                    addto[0] = 1
                    wr(chr(32) * atleast(0, indent) + "stdout.write(\"" +
                    bcolor(textpalette[lnob(x, 1)]).replace("\x1b",
                    "\\x1b") + "\")")

            elif lnob(x, 0) == "colortext":

                e = 1 # watch for errors in structure
                if lnob(x, 1) in textpalette.keys():
                    e = 0
                    print lc() + p
                    addto[0] = 1
                    wr(chr(32) * atleast(0, indent) + "stdout.write(\"" +
                    color(textpalette[lnob(x, 1)], None).replace("\x1b",
                    "\\x1b") + "\")")

            elif lnob(x, 0) == "drawdots":

                e = 1 # watch for errors in structure
                if len(getpairs(x, 1)):
                    e = 0
                    print lc() + p
                    addto[0] = 1
                    addto[1] = 1
                    addto[2] = 1
                    addto[3] = 1
                    gp = getpairs(x, 1)
                    for gpr in range(0, len(gp), 2):
                        #pset(str(int(stripcoords(gp[gpr]))),
                        # str(int(stripcoords(gp[gpr+1]))))
                        wr(chr(32) * atleast(0, indent) + "pset(" +
                        str(int(stripcoords(gp[gpr]))) + ", " +
                        str(int(stripcoords(gp[gpr+1]))) + ")")

            #elif lnob(x, 0) == "wait":
            #
            #    e = 1 # watch for errors in structure
            #    seconds = 0
            #    try: seconds = float(lnob(x, 1)) ; e = 0
            #    except: pass
            #    if e == 0:
            #        print lc() + p
            #        addto[0] = 1
            #        wr(chr(32)*atleast(0, indent) + "sleep(" + str(seconds) + ")")
            #    else:
            #        if lnob(x, 1) == "key":
            #            e = 0
            #            wr(chr(32) * atleast(0, indent) + "anykeypyg()")
            #            print lc() + p


            elif lp.rstrip() == "python":
                indent += 4
                inlinep = 1
                print lc() + p

            elif lp.rstrip() == "todisplay":
                mode = "output the following:"
                print lc() + p

            else:
                if not lnob(x, 0) == "figg":
                    if lnob(x, 0) != "fig" and not lnob(x,
                    0) in cmds.keys() and not lnob(x,
                    0) in funcs.keys() + ["forin", "for", "function", "nextin",
                    "next", "while", "wend"] + ["break", "pass"]:
                        if not lnob(x, 0) in vrs: vrs += [lnob(x, 0)[:]]
                        outfilewrite(outb, "\n")
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "figlist = 0\n")

                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "try: figlist = int(type(" + lnob(x, 0) + ") == list)\n")

                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "except NameError: pass\n")
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "if not figlist: " + lnob(x, 0) + " = 0 \n")

                    if lnob(x, 0) == "fig":
                        #print lc() + p
                        indent = atleast(0, indent - 4)
                    if lnob(x, 0) == "wend":
                        #print lc() + p
                        indent = atleast(0, indent - 4)
                    if lnob(x, 0) == "next":
                        #print lc() + p
                        indent = atleast(0, indent - 4)
                    if lnob(x, 0) == "nextin":
                        #print lc() + p
                        indent = atleast(0, indent - 4)
                    if lnob(x, 0) == "try":
                        #print lc() + p
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "try:\n")
                        indent = atleast(0, indent + 4)
                    if lnob(x, 0) == "else":
                        #print lc() + p
                        outfilewrite(outb, chr(32) * atleast(0, indent - 4) +
                        "else:\n")
                    if lnob(x, 0) == "except":
                        #print lc() + p
                        indent = atleast(0, indent - 4)
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "except:\n")
                        indent = atleast(0, indent + 4)
                    if lnob(x, 0) == "resume":
                        #print lc() + p
                        indent = atleast(0, indent - 4)
                    if lnob(x, 0) == "while":
                        #print lc() + p
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "while 1:\n")
                        indent += 4
                    if lnob(x, 0) == "function" and len(getmore(x, 1)) > 0:
                        #print lc() + p
                        mkf = []
                        funcname = getlmore(x, 1)[0]
                        prm = 1
                        while 1:
                            try:
                                aprm = getlmore(x, 1)[prm]
                                if len(aprm):
                                    if aprm[0] != "#":
                                        mkf += [aprm]
                                        if aprm not in vrs: vrs += [aprm[:]]
                                prm += 1
                            except: break
                        ufunc[funcname] = mkf[:] #; print ufunc # #
                        #print ufunc
                        #print len(ufunc[funcname])
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "def " +
                        funcname + "(" + ", ".join(mkf) + "):\n")
                        indent += 4

                    if lnob(x, 0) == "for" and len(getmore(x, 1)) == 4:
                        #print lc() + p
                        gmro = getlmore(x, 1)[0]
                        gmrt = getlmore(x, 1)[1]
                        gmrh = getlmore(x, 1)[2]
                        gmrf = getlmore(x, 1)[3]
                        if gmro not in vrs: vrs += [gmro[:]]
                        if "." not in gmrf and (gmrf.strip()) not in ("0",
                        "0.0", "-0") and "." not in gmrt and "." not in gmrh:
                            outfilewrite(outb, chr(32) * atleast(0, indent)
                            + "for "
                            + gmro + " in range(int(float(" + gmrt +
                            ")), int(float(" + gmrh + ")) + figsgn(" + gmrf +
                            "), fignonz(int(float(" + gmrf + ")))):\n")
                        else:
                            outfilewrite(outb, chr(32) * atleast(0, indent) + gmro
                            + " = float(" + gmrt + ") - float(" + gmrf + ")\n" +
                            chr(32) * atleast(0, indent) + "while 1:\n" + chr(32) *
                            atleast(0, indent + 4) + gmro + " += float(" + gmrf +
                            ")\n" + chr(32) * atleast(0, indent + 4) + "if " +
                            gmrf +
                            " > 0 and " + gmro + " > float(" + gmrh + "): break\n"
                            + chr(32) * atleast(0, indent + 4) + "elif " + gmrf +
                            " <= 0 and " + gmro +
                            " < float(" + gmrh + "): break\n")
                        indent += 4
                    if lnob(x, 0) == "forin" and len(getmore(x, 1)) == 2:
                        #print lc() + p
                        gmro = getlmore(x, 1)[0]
                        gmrt = getlmore(x, 1)[1]
                        if gmro not in vrs: vrs += [gmro[:]]
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "for " +
                        gmro + " in " + gmrt + ":\n")
                        indent += 4
                    if lnob(x, 0) == "break":
                        #print lc() + p
                        outfilewrite(outb, chr(32) *
                        atleast(0, indent) + "break\n")

                    if lp.rstrip() == "graphics":
                        ingfx = 1
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "figraphics = -1\n")
                        figraphics = -1
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "figpset(0, -1, -1, 0)\n")
                        #print lc() + p

                    if lnob(x, 0) == "textmode":
                        #print lc() + p
                        addto[3] = 1
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "figraphics = 0\n")
                        outfilewrite(outb, chr(32) * atleast(0, indent) +
                        "stopgraphics()\n")
                        figraphics = 0

                    if lnob(x, 0) == "pass":
                        #print lc() + p
                        outfilewrite(outb, chr(32) *
                        atleast(0, indent) + "pass\n")

                    if lnob(x, 0) == "iftrue":
                        #print lc() + p
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " +
                        snob(x, 1) + ":\n") ; indent += 4

                    if lnob(x, 0) == "ifequal" and len(getmore(x, 1)) == 2:
                        #print lc() + p
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " +
                        snob(x, 1) + " == " + snob(x, 2) + ":\n") ; indent += 4

                    if lnob(x, 0) == "ifless" and len(getmore(x, 1)) == 2:
                        #print lc() + p
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " +
                        snob(x, 1) + " < " + snob(x, 2) + ":\n") ; indent += 4

                    if lnob(x, 0) == "ifmore" and len(getmore(x, 1)) == 2:
                        #print lc() + p
                        outfilewrite(outb, chr(32) * atleast(0, indent) + "if " +
                        snob(x, 1) + " > " + snob(x, 2) + ":\n") ; indent += 4

                    if lnob(x, 0) != "fig" and lnob(x,
                    0) not in funcs.keys() + ["forin", "for", "function",
                    "nextin", "next", "while", "wend"] + ["break", "pass"]:

                        print lc() + p
                        vr = lnob(x, 0)
                        #print vr, type(vr)
                        #print getlmore(x, 1)
                        prsc = 0
                        cstrctr = 0
                        csbuf = []
                        vrcs = ""
                        for prs in getlmore(x, 1):
                            prsc += 1
                            if cstrctr > 0:
                                vrcs += prs
                                cstrctr -= 1
                                if cstrctr == 0:

                                    if lnob(x, prsc - 1) == "return":
                                        outfilewrite(outb, chr(32) * atleast(0,
                                        indent) + vrcs)

                                    elif lnob(x, prsc - 2) == "swap":
                                        vrcs = lnob(x, prsc - 1) + ", " + lnob(x,
                                        prsc - 0) + " = " + lnob(x,
                                        prsc - 0) + ", " + lnob(x, prsc - 1)
                                        outfilewrite(outb, chr(32) * atleast(0,
                                        indent) + vrcs + " ; ")
                                    else:
                                        if figprsbac in ufunc.keys():
                                            outfilewrite(outb, chr(32) * atleast(0,
                                            indent) + vrcs + ") ; " + lnob(x, 0) +
                                            " = fignone(" + lnob(x, 0) +
                                            ", figbac) ; ")
                                        else:
                                            outfilewrite(outb, chr(32) *
                                            atleast(0, indent) + vrcs + ") ; ")
                                else:
                                    vrcs += ", " #; print "*"
                                    #if
                                continue

                            if prs.lower() in funcs.keys() + ["forin", "for",
                            "function", "nextin", "next", "while",
                            "wend"] + ["break", "pass"]:
                                e = 3
                            figprsbac = None

                            if prs.lower() in vrs and cstrctr == 0:
                                #and len(getmore(x, 1)) == 1:
                                outfilewrite(outb, chr(32) * atleast(0, indent) +
                                vr + " = " + prs.lower() + "\n")

                            if prs[0] == "\"":
                                outfilewrite(outb, chr(32) * atleast(0, indent) +
                                vr + " = " + prs + " ; ")
                            if prs[0] in ".1234567890-":
                                outfilewrite(outb, chr(32) * atleast(0, indent) +
                                vr + " = " + prs + " ; ")

                            if prs[0] == "#":
                                outfilewrite(outb, prs + "\n") ; break


                            if prs.lower() in ufunc.keys():
                                outfilewrite(outb, chr(32) * atleast(0, indent) +
                                "figbac = " + lnob(x,0) + " ; " ) # ##
                                figprsbac = prs.lower()

                                cstrctr = len(ufunc[prs])
                                #print cstrctr
                                if cstrctr == 0:
                                    outfilewrite(outb, chr(32) *
                                    atleast(0, indent) +
                                    vr + " = " + prs.lower() + "() ; " + lnob(x, 0) +
                                            " = fignone(" + lnob(x, 0) + ", figbac) ; ") # #
                                else:
                                    #print "y"
                                    vrcs = vr + " = " + prs.lower() + "("
                                    #multiparameter


                            if prs.lower() in cmds.keys():
                                if prs.lower() in ["display", "pset", "line"]:
                                    ingfx = 1
                                ##print prs
                                cstrctr = cmds[prs]
                                ##print cstrctr
                                if cstrctr == -1:
                                    outfilewrite(outb, chr(32) *
                                    atleast(0, indent) + "fig" +
                                    prs.lower() + "(" + vr + ") ; " )

                                if cstrctr == 0:
                                    outfilewrite(outb, chr(32) * atleast(0,
                                    indent) + vr +
                                    " = fig" + prs.lower() + "(" + vr + ") ; " )

                                if cstrctr < -1:
                                    if prs == "return":

                                        cstrctr = abs(cstrctr) - 1
                                        vrcs = "return " #parameter
                                    else:
                                        cstrctr = abs(cstrctr) - 1
                                        if prs == "swap": vrcs = "swap "
                                        else:
                                            vrcs = "fig" + prs.lower() + "(" + vr
                                            vrcs += ", " #multiparameter
                                else:
                                    vrcs = vr + " = fig" + prs.lower() + "(" + vr
                                    vrcs += ", " #multiparameter


                        outfilewrite(outb, "\n")
                    else:
                        print lc() + p
                else:
                    e = 2

#                if not len(error):
#                    error = "error: unknown command."
#                    errorin = linecount
#                    errorsrc = p
#                print lc() + "unknown:", p

            if e == 1:
                e = 0
                if not len(error):
                    error = "error: problem in command structure or details."
                    errorin = linecount
                    errorsrc = p
                print lc() + "unable to parse:", p

            if e == 2:
                e = 0
                if not len(error):
                    error = "error: cannot create variable or function beginning"
                    error += " with 'fig'"
                    errorin = linecount
                    errorsrc = p
                print lc() + "can't fig: " + p

            if e == 3:
                e = 0
                if not len(error):
                    error = "error: single-line function not on own line"
                    errorin = linecount
                    errorsrc = p
                print lc() + "unable to parse: " + p

#for p in range(len(addtoout)):
#    if addto[p]: outfilewrite(outb, addtoout[p])
#for p in buf:
#    outfilewrite(outb, p)

if ingfx == 0: addtoout[3] = ""
outfile.write(addtoout[0] + addtoout[1] + addtoout[3] + addfuncs)
for outsb in outb: outfile.write(outsb)
outfile.close()

try: os.system("chmod +x \"" + outname + "\"")
except: pass

print
if errorin:
    print error ; color(14, None) ; print "error in line " + str(errorin) + ":"
    color(7, None)
    print errorsrc
else:
    color (11, None) ; print "translation complete. ", ; color(7, None)
    print "here's a python script you can run: ",
    print color(11, None) + outname + color(7, None)
print

# APPEND a
# BINARY rb+
# CIRCLE  CLOSE    COMMAND$
# ELSEIF      EOF
# GET
# INCLUDE LOC LSET
# MKDIR NAME
# PAINT   # seek rset put palette