test.py

#!/usr/bin/env python3
# python 3.6+

from functools import lru_cache
import unittest

import sympy as sp
from sast import AST
import spatch
import sym
import sparser as _sparser

import test_sym as _test_sym

SympifyError = sp.SympifyError
parser       = _sparser.Parser ()

_USER_FUNCS = {'N', 'O', 'S', 'beta', 'Lambda', 'gamma', 'Gamma', 'zeta'}
_sparser.set_sp_user_funcs (_USER_FUNCS)
sym.set_sym_user_funcs (_USER_FUNCS)

sym.set_pyS (False)
sym.set_simplify (False)
sym.set_doit (False)
sym.set_strict (True)

@lru_cache (maxsize = None)
def sparser (text): return parser.parse (text) [0]

@lru_cache (maxsize = None)
def ast2tex (ast): return sym.ast2tex (ast)

@lru_cache (maxsize = None)
def ast2nat (ast): return sym.ast2nat (ast)

@lru_cache (maxsize = None)
def ast2py (ast): return sym.ast2py (ast)

# @lru_cache (maxsize = None)
# def ast2spt (ast): return sym.ast2spt (ast)

ast2spt = sym.ast2spt
spt2ast = sym.spt2ast

def ast2tex2ast (ast):
	return sparser (ast2tex (ast))

def ast2nat2ast (ast):
	return sparser (ast2nat (ast))

def ast2py2ast (ast):
	return sparser (ast2py (ast))

def ast2spt2ast (ast):
	return spt2ast (ast2spt (ast))

p = sparser

class Test (unittest.TestCase):
	def test_sym (self):
		self.assertEqual (_test_sym.test (['-c']), True)

	#...............................................................................................
	# BEGIN UPDATE BLOCK
	def test_sparser (self):
		self.assertEqual (p ('1'), ('#', '1'))
		self.assertEqual (p ('1.'), ('#', '1.'))
		self.assertEqual (p ('.1'), ('#', '0.1'))
		self.assertEqual (p ('1e20'), ('#', '1e+20'))
		self.assertEqual (p ('1E-20'), ('#', '1e-20'))
		self.assertEqual (p ('1.e+20'), ('#', '1.e+20'))
		self.assertEqual (p ('.1e-20'), ('#', '0.1e-20'))
		self.assertEqual (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)'), ('-func', 'sin', (('#', '-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901'),)))
		self.assertEqual (p ('x'), ('@', 'x'))
		self.assertEqual (p ('xy'), ('@', 'xy'))
		self.assertEqual (p ('dx'), ('@', 'dx'))
		self.assertEqual (p ('partialx'), ('@', 'partialx'))
		self.assertEqual (p ('\\partial x'), ('@', 'partialx'))
		self.assertEqual (p ('x d  y'), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y'))))
		self.assertEqual (p ('x partial y'), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y'))))
		self.assertEqual (p ('x \\partial  y'), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y'))))
		self.assertEqual (p ('x dx dy y'), ('*', (('@', 'x'), ('@', 'dx'), ('@', 'dy'), ('@', 'y'))))
		self.assertEqual (p ('x partialx partialy y'), ('*', (('@', 'x'), ('@', 'partialx'), ('@', 'partialy'), ('@', 'y'))))
		self.assertEqual (p ('-1'), ('#', '-1'))
		self.assertEqual (p ('-x'), ('-', ('@', 'x')))
		self.assertEqual (p ('{x}'), ('@', 'x'))
		self.assertEqual (p ('()'), ('(', (',', ())))
		self.assertEqual (p ('(x)'), ('(', ('@', 'x')))
		self.assertEqual (p ('(x,)'), ('(', (',', (('@', 'x'),))))
		self.assertEqual (p ('(x,y)'), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (p ('(x,y,)'), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (p ('[]'), ('[', ()))
		self.assertEqual (p ('[x]'), ('[', (('@', 'x'),)))
		self.assertEqual (p ('[x,]'), ('[', (('@', 'x'),)))
		self.assertEqual (p ('[x,y]'), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (p ('[x,y,]'), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (p ('"x\\x20\\n"'), ('"', 'x \n'))
		self.assertEqual (p ("'x\\x20\\n'"), ('"', 'x \n'))
		self.assertEqual (p ('|x|'), ('|', ('@', 'x')))
		self.assertEqual (p ('x!'), ('!', ('@', 'x')))
		self.assertEqual (p ('x+y'), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (p ('x-y'), ('+', (('@', 'x'), ('-', ('@', 'y')))))
		self.assertEqual (p ('x*y'), ('*', (('@', 'x'), ('@', 'y')), {1}))
		self.assertEqual (p ('x y'), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (p ('x(y)'), ('-ufunc', 'x', (('@', 'y'),)))
		self.assertEqual (p ('x*(y)'), ('*', (('@', 'x'), ('(', ('@', 'y'))), {1}))
		self.assertEqual (p ('x/y'), ('/', ('@', 'x'), ('@', 'y')))
		self.assertEqual (p ('x^y'), ('^', ('@', 'x'), ('@', 'y')))
		self.assertEqual (p ('log x'), ('-log', ('@', 'x')))
		self.assertEqual (p ('log {x}'), ('-log', ('@', 'x')))
		self.assertEqual (p ('log (x)'), ('-log', ('@', 'x')))
		self.assertEqual (p ('\\log_2 x'), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (p ('\\log_2 {x}'), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (p ('\\log_2 (x)'), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (p ('sqrt x'), ('-sqrt', ('@', 'x')))
		self.assertEqual (p ('sqrt {x}'), ('-sqrt', ('@', 'x')))
		self.assertEqual (p ('sqrt (x)'), ('-sqrt', ('@', 'x')))
		self.assertEqual (p ('sqrt {(x)}'), ('-sqrt', ('@', 'x')))
		self.assertEqual (p ('sqrt[3] x'), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (p ('sqrt[3] {x}'), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (p ('sqrt[3] {(x)}'), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (p ('sqrt[3] (x)'), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (p ('sin x'), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (p ('sin^2 x'), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (p ('sin (x)'), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (p ('sin (x)^2'), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (p ('sin {x}'), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (p ('sin {(x)}'), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (p ('{sin x}^2'), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (p ('sin**2 x'), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (p ('sin**-1 x'), ('-func', 'asin', (('@', 'x'),)))
		self.assertEqual (p ('sin(x)**-1'), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '-1')))
		self.assertEqual (p ('acos (x)'), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (p ('\\arccos (x)'), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (p ('sin(x**2)'), ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (p ('sin(x**2)**2'), ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (p ('(sin(x**2)**2)'), ('(', ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (p ('ln(x**2)'), ('-log', ('^', ('@', 'x'), ('#', '2'))))
		self.assertEqual (p ('ln(x**2)**2'), ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2')))
		self.assertEqual (p ('(ln(x**2)**2)'), ('(', ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2'))))
		self.assertEqual (p ('gamma(x**2)'), ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (p ('gamma(x**2)**2'), ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (p ('(gamma(x**2)**2)'), ('(', ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (p ('{gamma}[2]'), ('-idx', ('@', 'gamma'), (('#', '2'),)))
		self.assertEqual (p ('{Gamma}[2]'), ('-idx', ('@', 'Gamma'), (('#', '2'),)))
		self.assertEqual (p ('f{(x)}'), ('*', (('@', 'f'), ('(', ('@', 'x'), True))))
		self.assertEqual (p ("f{(x)}'(0)"), ('*', (('@', 'f'), ('-diffp', ('(', ('@', 'x'), True), 1), ('(', ('#', '0')))))
		self.assertEqual (p ("f{(x)}'{(0)}"), ('*', (('@', 'f'), ('-diffp', ('(', ('@', 'x'), True), 1), ('(', ('#', '0'), True))))
		self.assertEqual (p ('\\operatorname{x_{1}}{\\left(x \\right)}'), ('-ufunc', 'x1', (('@', 'x'),)))
		self.assertEqual (p ('\\lim_{x\\to0} 1/x'), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (p ('\\lim_{x\\to0^+} 1/x'), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (p ('\\lim_{x\\to0**-} 1/x'), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (p ('Limit (1/x, x, 0)'), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (p ('Limit (1/x, x, 0, "-")'), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (p ('Limit (1/x, x, 0, dir="+-")'), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (p ('limit (1/x, x, 0)'), ('-func', 'limit', (('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'))))
		self.assertEqual (p ('limit (1/x, x, 0, "-")'), ('-func', 'limit', (('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), ('"', '-'))))
		self.assertEqual (p ('limit (1/x, x, 0, dir="+-")'), ('-func', 'limit', (('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), ('=', ('@', 'dir'), ('"', '+-')))))
		self.assertEqual (p ('\\sum_{n=0}^\\infty x^n/n!'), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (p ('Sum (x^n/n!, (n, 0, oo))'), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (p ('summation (x^n/n!, (n, 0, oo))'), ('-func', 'summation', (('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('(', (',', (('@', 'n'), ('#', '0'), ('@', 'oo')))))))
		self.assertEqual (p ('d/dx x**2y**2z'), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), 'd', (('x', 1),)))
		self.assertEqual (p ('d^2/dx^2 x^2y**2z'), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), 'd', (('x', 2),)))
		self.assertEqual (p ('d^3/dx^2dy x^2y**2z'), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), 'd', (('x', 2), ('y', 1))))
		self.assertEqual (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z'), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), 'partial', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (p ('d**1.5 / dx dy x**2y**2'), ('/', ('^', ('@', 'd'), ('#', '1.5')), ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (p ('d**-2 / dx dy x**2y**2'), ('/', ('^', ('@', 'd'), ('#', '-2')), ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (p ('d**2 / dx**1.5 x**2y**2'), ('/', ('^', ('@', 'd'), ('#', '2')), ('*', (('^', ('@', 'dx'), ('#', '1.5')), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (p ('Derivative (x^2y**2z, x, 2, y, z)'), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), 'd', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (p ('diff (x^2y**2z, x, 2, y, z)'), ('-func', 'diff', (('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), ('@', 'x'), ('#', '2'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (p ('\\int dx'), ('-intg', None, ('@', 'dx')))
		self.assertEqual (p ('\\int x dx'), ('-intg', ('@', 'x'), ('@', 'dx')))
		self.assertEqual (p ('\\int_0^1 x dx'), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (p ('\\int_0^1 \\int y dy dx'), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (p ('Integral (\\int y dy, (x, 0, 1))'), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (p ('integrate (\\int y dy, (x, 0, 1))'), ('-func', 'integrate', (('-intg', ('@', 'y'), ('@', 'dy')), ('(', (',', (('@', 'x'), ('#', '0'), ('#', '1')))))))

		self.assertEqual (p ('\\[1,]'), ('-mat', ((('#', '1'),),)))
		self.assertEqual (p ('\\[1,2]'), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (p ('\\[1,2,]'), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (p ('\\[[1,],]'), ('-mat', ((('#', '1'),),)))
		self.assertEqual (p ('\\[[1,],[2,]]'), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (p ('\\[[1,],[2,],]'), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]'), ('-mat', ((('#', '1'),),)))
		self.assertEqual (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}'), ('-mat', ((('#', '1'),),)))
		self.assertEqual (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}'), ('-mat', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}'), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}'), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (p ('\\[1,2]!'), ('!', ('-mat', ((('#', '1'),), (('#', '2'),)))))
		self.assertEqual (p ('\\[[0,1],[1,0]]**x'), ('^', ('-mat', ((('#', '0'), ('#', '1')), (('#', '1'), ('#', '0')))), ('@', 'x')))
		self.assertEqual (p ('\\[[1,2],[3,4]]!'), ('!', ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4'))))))
		self.assertEqual (p ('\\[[1,2,3],[4,5,6]].T'), ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'))
		self.assertEqual (p ('\\[[1,2,3],[4,5,6]].T.T'), ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'), 'T'))
		self.assertEqual (p ('\\[[1,2,3],[4,5,6]].T.T.T'), ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'), 'T'), 'T'))
		self.assertEqual (p ('\\[[1,2,3],[4,5,6]].transpose ()'), ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()))
		self.assertEqual (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()'), ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()))
		self.assertEqual (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()'), ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()), 'transpose', ()))
		self.assertEqual (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()'), ('.', ('.', ('.', ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()), 'T'), 'T'), 'transpose', ()), 'transpose', ()))
		self.assertEqual (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]'), ('*', (('-mat', ((('@', 'A'), ('@', 'B')), (('@', 'C'), ('@', 'D')))), ('-mat', ((('@', 'x'),), (('@', 'y'),)))), {1}))
		self.assertEqual (p ('\\[[1, 2], [3'), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('@', '')))))
		self.assertEqual (p ('\\[[1, 2], [3]]'), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('@', '')))))
		self.assertEqual (p ('\\[[1], [2, 3]]'), ('-mat', ((('#', '1'), ('@', '')), (('#', '2'), ('#', '3')))))

		self.assertEqual (p ('-1**x'), ('-', ('^', ('#', '1'), ('@', 'x'))))
		self.assertEqual (p ('{-1}**x'), ('^', ('#', '-1'), ('@', 'x')))
		self.assertEqual (p ('-{-1}**x'), ('-', ('^', ('#', '-1'), ('@', 'x'))))
		self.assertEqual (p ('(-1)**x'), ('^', ('(', ('#', '-1')), ('@', 'x')))
		self.assertEqual (p ('-(-1)**x'), ('-', ('^', ('(', ('#', '-1')), ('@', 'x'))))
		self.assertEqual (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega'), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega'), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (p ('1 if x < y'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))),)))
		self.assertEqual (p ('1 if x < y else 3'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), True))))
		self.assertEqual (p ('1 if x < y else 3 if x < z'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))))))
		self.assertEqual (p ('1 if x < y else 3 if x < z else 5'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'x'), (('<', ('@', 'w')),))))))
		self.assertEqual (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}'), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'x'), (('<', ('@', 'w')),))))))
		self.assertEqual (p ('x**y.a'), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a')))
		self.assertEqual (p ('x**y.a ()'), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a', ())))
		self.assertEqual (p ('x**y.a.b'), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b')))
		self.assertEqual (p ('x**y.a.b ()'), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b', ())))
		self.assertEqual (p ('x**y.a ().b'), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b')))
		self.assertEqual (p ('x**y.a ().b ()'), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b', ())))
		self.assertEqual (p ('{1 if x < 0 else 3} if x < 1 else 5'), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '3'), True))), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))))
		self.assertEqual (p ('1 if {True if x < 0 else False} else 5'), ('-piece', ((('#', '1'), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('@', 'False'), True)))), (('#', '5'), True))))
		self.assertEqual (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}'), ('-piece', ((('#', '1'), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('@', 'False'), True)))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))), True))))
		self.assertEqual (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}'), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '9'), True))), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('@', 'False'), True)))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '2')),))), (('#', '5'), True))), True))))
		self.assertEqual (p ('x.y!'), ('!', ('.', ('@', 'x'), 'y')))
		self.assertEqual (p ('x.y**2'), ('^', ('.', ('@', 'x'), 'y'), ('#', '2')))
		self.assertEqual (p ('x.y ()!'), ('!', ('.', ('@', 'x'), 'y', ())))
		self.assertEqual (p ('x.y ()**2'), ('^', ('.', ('@', 'x'), 'y', ()), ('#', '2')))
		self.assertEqual (p ('x**y.a!'), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a'))))
		self.assertEqual (p ('x**y.a**2'), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a'), ('#', '2'))))
		self.assertEqual (p ('x**y.a ()!'), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a', ()))))
		self.assertEqual (p ('x**y.a ()**2'), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a', ()), ('#', '2'))))
		self.assertEqual (p ('lambda: x'), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (p ('lambda x: x**2'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (p ('lambda x, y: x + y'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (p ('lambda x, y, z: x + y + z'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))
		self.assertEqual (p ('1, lambda: x'), (',', (('#', '1'), ('-lamb', ('@', 'x'), ()))))
		self.assertEqual (p ('1, lambda x: x**2'), (',', (('#', '1'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))))
		self.assertEqual (p ('1, lambda x, y: x + y'), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))))
		self.assertEqual (p ('1, lambda x, y, z: x + y + z'), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))))
		self.assertEqual (p ('f = lambda: 0'), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ())))
		self.assertEqual (p ('f = lambda x: 0'), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x',))))
		self.assertEqual (p ('f = lambda x, y: 0'), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y'))))
		self.assertEqual (p ('f = lambda x, y, z: 0'), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y', 'z'))))
		self.assertEqual (p ('\\left(\\left(\\right) \\mapsto x \\right)'), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (p ('\\lambda: x'), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (p ('\\lambda x: x'), ('-slice', ('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'x'), None))
		self.assertEqual (p ('\\lambda x, y: x'), (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('-slice', ('@', 'y'), ('@', 'x'), None))))
		self.assertEqual (p ('{lambda}: x'), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (p ('{lambda} x: x'), ('-slice', ('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'x'), None))
		self.assertEqual (p ('{lambda} x, y: x'), (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('-slice', ('@', 'y'), ('@', 'x'), None))))
		self.assertEqual (p ('$'), ('-sym', ''))
		self.assertEqual (p ('$s'), ('-sym', 's'))
		self.assertEqual (p ('$ (real = True)'), ('-sym', '', (('real', ('@', 'True')),)))
		self.assertEqual (p ('$s (real = True)'), ('-sym', 's', (('real', ('@', 'True')),)))

		self.assertEqual (p ('eye (2).is_diagonal ()'), ('.', ('-func', 'eye', (('#', '2'),)), 'is_diagonal', ()))
		self.assertEqual (p ('a [2]'), ('-idx', ('@', 'a'), (('#', '2'),)))
		self.assertEqual (p ('a [2,3]'), ('-idx', ('@', 'a'), (('#', '2'), ('#', '3'))))
		self.assertEqual (p ('a * [2]'), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (p ('a * {-1}[x]'), ('*', (('@', 'a'), ('-idx', ('#', '-1'), (('@', 'x'),))), {1}))
		self.assertEqual (p ('a * [x][y][z]'), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (p ('N (1/2)'), ('-func', 'N', (('/', ('#', '1'), ('#', '2')),)))
		self.assertEqual (p ("S ('1/2')"), ('-func', 'S', (('"', '1/2'),)))
		self.assertEqual (p ("N (S ('1/2'))"), ('-func', 'N', (('-func', 'S', (('"', '1/2'),)),)))
		self.assertEqual (p ('S.Half'), ('.', ('@', 'S'), 'Half'))
		self.assertEqual (p ('N S.Half'), ('-func', 'N', (('.', ('@', 'S'), 'Half'),)))
		self.assertEqual (p ('o [i].t'), ('.', ('-idx', ('@', 'o'), (('@', 'i'),)), 't'))
		self.assertEqual (p ('o [i]**2'), ('^', ('-idx', ('@', 'o'), (('@', 'i'),)), ('#', '2')))
		self.assertEqual (p ('o [i]!'), ('!', ('-idx', ('@', 'o'), (('@', 'i'),))))
		self.assertEqual (p ("'Hello' [::-1]"), ('-idx', ('"', 'Hello'), (('-slice', False, False, ('#', '-1')),)))
		self.assertEqual (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]'), ('-idx', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), (('-slice', False, False, None), ('#', '1'))))
		self.assertEqual (p ('\\binom96'), ('-func', 'binomial', (('#', '9'), ('#', '6'))))
		self.assertEqual (p ('binomial (x, y)'), ('-func', 'binomial', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (p ('y - 1*x'), ('+', (('@', 'y'), ('-', ('*', (('#', '1'), ('@', 'x')), {1})))))
		self.assertEqual (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')"), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'))), ('#', '1'))), ('@', 'x'), ('=', ('@', 'domain'), ('"', 'ZZ')))))
		self.assertEqual (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')"), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'), ('@', 'y'))))), ('@', 'x'), ('@', 'y'), ('=', ('@', 'domain'), ('"', 'CC')))))
		self.assertEqual (p ('oct(10)'), ('-func', 'oct', (('#', '10'),)))
		self.assertEqual (p ('(1,) + (2,)'), ('+', (('(', (',', (('#', '1'),))), ('(', (',', (('#', '2'),))))))
		self.assertEqual (p ('[1] + [2]'), ('+', (('[', (('#', '1'),)), ('[', (('#', '2'),)))))
		self.assertEqual (p ("'a' + 'b'"), ('+', (('"', 'a'), ('"', 'b'))))
		self.assertEqual (p ('(1,) * 2'), ('*', (('(', (',', (('#', '1'),))), ('#', '2')), {1}))
		self.assertEqual (p ('[1] * 2'), ('*', (('[', (('#', '1'),)), ('#', '2')), {1}))
		self.assertEqual (p ("'a' * 2"), ('*', (('"', 'a'), ('#', '2')), {1}))
		self.assertEqual (p ('Lambda (x, x**2)'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (p ('beta (2, 3)'), ('-func', 'beta', (('#', '2'), ('#', '3'))))
		self.assertEqual (p ('{x d} y'), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y'))))
		self.assertEqual (p ('d**2e0/dx**2e0 x**3'), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (p ('ln((a)**b)'), ('-log', ('^', ('(', ('@', 'a')), ('@', 'b'))))
		self.assertEqual (p ('a * \\int dx + {\\int dx dx}'), ('+', (('*', (('@', 'a'), ('-intg', None, ('@', 'dx'))), {1}), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx'))))))
		self.assertEqual (p ('1 if {a = x if z} else 0 if y'), ('-piece', ((('#', '1'), ('=', ('@', 'a'), ('-piece', ((('@', 'x'), ('@', 'z')),)))), (('#', '0'), ('@', 'y')))))
		self.assertEqual (p ('a, lambda: b = 1'), (',', (('@', 'a'), ('-lamb', ('=', ('@', 'b'), ('#', '1')), ()))))
		self.assertEqual (p ('a * [2]'), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (p ('sqrt(1, 2)'), ('-sqrt', (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (p ('x*[][y]'), ('*', (('@', 'x'), ('-idx', ('[', ()), (('@', 'y'),))), {1}))
		self.assertEqual (p ('lambda: x:'), ('-lamb', ('-slice', ('@', 'x'), False, None), ()))
		self.assertEqual (p ('a*[x][y][z]'), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (p ('a*()**2'), ('*', (('@', 'a'), ('^', ('(', (',', ())), ('#', '2'))), {1}))
		self.assertEqual (p ('a*().t'), ('*', (('@', 'a'), ('.', ('(', (',', ())), 't')), {1}))
		self.assertEqual (p ('a*()[2]'), ('*', (('@', 'a'), ('-idx', ('(', (',', ())), (('#', '2'),))), {1}))
		self.assertEqual (p ('o.f*(a)'), ('*', (('.', ('@', 'o'), 'f'), ('(', ('@', 'a'))), {1}))
		self.assertEqual (p ('o.f*{1+2}'), ('*', (('.', ('@', 'o'), 'f'), ('+', (('#', '1'), ('#', '2')))), {1}))
		self.assertEqual (p ('d**2e0/dx**2e0 x**3'), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (p ('y**z [w]'), ('^', ('@', 'y'), ('-idx', ('@', 'z'), (('@', 'w'),))))
		self.assertEqual (p ('{y**z} [w]'), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))
		self.assertEqual (p ('x {y**z} [w]'), ('*', (('@', 'x'), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))))
		self.assertEqual (p ('{x y**z} [w]'), ('-idx', ('*', (('@', 'x'), ('^', ('@', 'y'), ('@', 'z')))), (('@', 'w'),)))
		self.assertEqual (p ('Min (x, y, z)'), ('-func', 'Min', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (p ('Max (x, y, z)'), ('-func', 'Max', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (p ('\\Re (z)'), ('-func', 'Re', (('@', 'z'),)))
		self.assertEqual (p ('\\Im (z)'), ('-func', 'Im', (('@', 'z'),)))
		self.assertEqual (p ('re (z)'), ('-func', 're', (('@', 'z'),)))
		self.assertEqual (p ('im (z)'), ('-func', 'im', (('@', 'z'),)))
		self.assertEqual (p ('{}'), ('-dict', ()))
		self.assertEqual (p ('{1: 2}'), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (p ('{1: 2,}'), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (p ('{1: 2, 3: 4}'), ('-dict', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (p ('set ()'), ('-func', 'set', ()))
		self.assertEqual (p ('\\{}'), ('-set', ()))
		self.assertEqual (p ('\\{1}'), ('-set', (('#', '1'),)))
		self.assertEqual (p ('\\{1,2}'), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (p ('{1,2}'), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (p ('1 in {1,2,3}'), ('<>', ('#', '1'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (p ('1 \\in {1,2,3}'), ('<>', ('#', '1'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (p ('4 in {1,2,3}'), ('<>', ('#', '4'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (p ('4 \\in {1,2,3}'), ('<>', ('#', '4'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (p ('4 not in {1,2,3}'), ('<>', ('#', '4'), (('notin', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (p ('4 \\notin {1,2,3}'), ('<>', ('#', '4'), (('notin', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (p ('{1,2} - {2,3}'), ('+', (('-set', (('#', '1'), ('#', '2'))), ('-', ('-set', (('#', '2'), ('#', '3')))))))
		self.assertEqual (p ('{1,2} || {2,3}'), ('||', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (p ('{1,2} ^^ {2,3}'), ('^^', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (p ('{1,2} && {2,3}'), ('&&', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (p ('{1,2} || {2,3} || {3,4}'), ('||', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (p ('{1,2} ^^ {2,3} ^^ {3,4}'), ('^^', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (p ('{1,2} && {2,3} && {3,4}'), ('&&', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}'), ('||', (('-set', (('#', '1'), ('#', '2'))), ('^^', (('-set', (('#', '2'), ('#', '3'))), ('&&', (('-set', (('#', '3'), ('#', '4'))), ('-set', (('#', '4'), ('#', '5'))))))))))
		self.assertEqual (p ('solve (x**2 = 4)'), ('-func', 'solve', (('=', ('^', ('@', 'x'), ('#', '2')), ('#', '4')),)))
		self.assertEqual (p ('Subs (x y, x, 2)'), ('-subs', ('*', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '2')),)))
		self.assertEqual (p ('Subs (x y, (x, y), (2, 3))'), ('-subs', ('*', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))))
		self.assertEqual (p ('(x y).subs (x, 2)'), ('.', ('(', ('*', (('@', 'x'), ('@', 'y')))), 'subs', (('@', 'x'), ('#', '2'))))
		self.assertEqual (p ('(x y).subs (x, 2).subs (y, 3)'), ('.', ('.', ('(', ('*', (('@', 'x'), ('@', 'y')))), 'subs', (('@', 'x'), ('#', '2'))), 'subs', (('@', 'y'), ('#', '3'))))
		self.assertEqual (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])'), ('.', ('-subs', ('.', ('(', ('*', (('@', 'x'), ('@', 'y'), ('@', 'z'), ('@', 'w')))), 'subs', (('-dict', ((('@', 'z'), ('#', '4')),)),)), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))), 'subs', (('[', (('(', (',', (('@', 'w'), ('#', '5')))),)),)))
		self.assertEqual (p ('x or y'), ('-or', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (p ('x or y or z'), ('-or', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (p ('x and y'), ('-and', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (p ('x and y and z'), ('-and', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (p ('x and y or z'), ('-or', (('-and', (('@', 'x'), ('@', 'y'))), ('@', 'z'))))
		self.assertEqual (p ('x and {y or z}'), ('-and', (('@', 'x'), ('-or', (('@', 'y'), ('@', 'z'))))))
		self.assertEqual (p ('not x or y'), ('-or', (('-not', ('@', 'x')), ('@', 'y'))))
		self.assertEqual (p ('not {x or y}'), ('-not', ('-or', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (p ('not x and y'), ('-and', (('-not', ('@', 'x')), ('@', 'y'))))
		self.assertEqual (p ('not {x and y}'), ('-not', ('-and', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (p ('x or not y'), ('-or', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (p ('x and not y'), ('-and', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (p ('not x'), ('-not', ('@', 'x')))
		self.assertEqual (p ('not not x'), ('-not', ('-not', ('@', 'x'))))
		self.assertEqual (p ('not not not x'), ('-not', ('-not', ('-not', ('@', 'x')))))
		self.assertEqual (p ('0 or []'), ('-or', (('#', '0'), ('[', ()))))
		self.assertEqual (p ('0 or [1]'), ('-or', (('#', '0'), ('[', (('#', '1'),)))))
		self.assertEqual (p ('1 and []'), ('-and', (('#', '1'), ('[', ()))))
		self.assertEqual (p ('1 and [1]'), ('-and', (('#', '1'), ('[', (('#', '1'),)))))
		self.assertEqual (p ('not []'), ('-not', ('[', ())))
		self.assertEqual (p ('not [1]'), ('-not', ('[', (('#', '1'),))))
		self.assertEqual (p ('not None'), ('-not', ('@', 'None')))
		self.assertEqual (p ('True + True'), ('+', (('@', 'True'), ('@', 'True'))))
		self.assertEqual (p ('False - True'), ('+', (('@', 'False'), ('-', ('@', 'True')))))
		self.assertEqual (p ('True * True'), ('*', (('@', 'True'), ('@', 'True')), {1}))
		self.assertEqual (p ('(2 > 1) x'), ('*', (('(', ('<>', ('#', '2'), (('>', ('#', '1')),))), ('@', 'x'))))
		self.assertEqual (p ('(2 > 1) + (1 < 2)'), ('+', (('(', ('<>', ('#', '2'), (('>', ('#', '1')),))), ('(', ('<>', ('#', '1'), (('<', ('#', '2')),))))))
		self.assertEqual (p ('\\[{[a, b]},]'), ('-mat', ((('[', (('@', 'a'), ('@', 'b'))),),)))
		self.assertEqual (p ('{{a:b:c}:d}'), ('-dict', ((('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c')), ('@', 'd')),)))
		self.assertEqual (p ('{a:{b:c:d}}'), ('-dict', ((('@', 'a'), ('-slice', ('@', 'b'), ('@', 'c'), ('@', 'd'))),)))
		self.assertEqual (p ('{a:b:c} = {a:b:c}'), ('=', ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c')), ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c'))))
		self.assertEqual (p ('\\[1:2:3]'), ('-mat', ((('-slice', ('#', '1'), ('#', '2'), ('#', '3')),),)))
		self.assertEqual (p ('-{not x}'), ('-', ('-not', ('@', 'x'))))
		self.assertEqual (p ('x < y in [y] in [[y]] != 2 > 1'), ('<>', ('@', 'x'), (('<', ('@', 'y')), ('in', ('[', (('@', 'y'),))), ('in', ('[', (('[', (('@', 'y'),)),))), ('!=', ('#', '2')), ('>', ('#', '1')))))
		self.assertEqual (p ('x < y < z < w'), ('<>', ('@', 'x'), (('<', ('@', 'y')), ('<', ('@', 'z')), ('<', ('@', 'w')))))
		self.assertEqual (p ('\\[]'), ('-mat', ()))
		self.assertEqual (p ('\\[[]]'), ('-mat', ()))
		self.assertEqual (p ('\\[[], []]'), ('-mat', ()))
		self.assertEqual (p ('\\{a:b}'), ('-set', (('-slice', ('@', 'a'), ('@', 'b'), None),)))
		self.assertEqual (p ('{-x} y / z'), ('/', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'z')))
		self.assertEqual (p ('d / dz {-1} a'), ('-diff', ('*', (('#', '-1'), ('@', 'a'))), 'd', (('z', 1),)))
		self.assertEqual (p ('1 / {-2} x'), ('/', ('#', '1'), ('*', (('#', '-2'), ('@', 'x')))))
		self.assertEqual (p ('\\sum_{x=0}^b {-x} y'), ('-sum', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'x'), ('#', '0'), ('@', 'b')))
		self.assertEqual (p ('\\lim_{x\\to0} {-x} y'), ('-lim', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'x'), ('#', '0')))
		self.assertEqual (p ('\\int a / -1 dx'), ('-intg', ('/', ('@', 'a'), ('#', '-1')), ('@', 'dx')))
		self.assertEqual (p ('\\[[[x]]]'), ('-mat', ((('[', (('@', 'x'),)),),)))
		self.assertEqual (p ('\\[[[1, 2]], [[3]]]'), ('-mat', ((('[', (('#', '1'), ('#', '2'))),), (('[', (('#', '3'),)),))))
		self.assertEqual (p ('{1/x}.limit (x, 0, "-")'), ('.', ('/', ('#', '1'), ('@', 'x')), 'limit', (('@', 'x'), ('#', '0'), ('"', '-'))))
		self.assertEqual (p ('{x^2y**2z}.diff (x, 2, y, z)'), ('.', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), 'diff', (('@', 'x'), ('#', '2'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (p ('{x y}.integrate ((x, 0, 1))'), ('.', ('*', (('@', 'x'), ('@', 'y'))), 'integrate', (('(', (',', (('@', 'x'), ('#', '0'), ('#', '1')))),)))
		self.assertEqual (p ('\\sqrt (a:b)'), ('-sqrt', ('-slice', ('@', 'a'), ('@', 'b'), None)))
		self.assertEqual (p ('\\sqrt[3] (a:b)'), ('-sqrt', ('-slice', ('@', 'a'), ('@', 'b'), None), ('#', '3')))
		self.assertEqual (p ('? ()'), ('-ufunc', '?', ()))
		self.assertEqual (p ('? (x)'), ('-ufunc', '?', (('@', 'x'),)))
		self.assertEqual (p ('? (x) (2)'), ('*', (('-ufunc', '?', (('@', 'x'),)), ('(', ('#', '2')))))
		self.assertEqual (p ('? (2)'), ('-ufunc', '?', (('#', '2'),)))
		self.assertEqual (p ('?f (x, y, real = True)'), ('-ufunc', '?f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (p ('?\\alpha(x)'), ('-ufunc', '?alpha', (('@', 'x'),)))
		self.assertEqual (p ('?beta(y)'), ('-ufunc', '?beta', (('@', 'y'),)))
		self.assertEqual (p ("Function ('f', real = True) (x, y)"), ('-ufunc', '?f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (p ("x'"), ('-diffp', ('@', 'x'), 1))
		self.assertEqual (p ("x''"), ('-diffp', ('@', 'x'), 2))
		self.assertEqual (p ("{x + y}'"), ('-diffp', ('+', (('@', 'x'), ('@', 'y'))), 1))
		self.assertEqual (p ("a [b]'"), ('-diffp', ('-idx', ('@', 'a'), (('@', 'b'),)), 1))
		self.assertEqual (p ("a.b ()'"), ('-diffp', ('.', ('@', 'a'), 'b', ()), 1))
		self.assertEqual (p ("{x/y}'"), ('-diffp', ('/', ('@', 'x'), ('@', 'y')), 1))
		self.assertEqual (p ("1'['ac']"), ('-idx', ('-diffp', ('#', '1'), 1), (('"', 'ac'),)))
		self.assertEqual (p ("|x|'"), ('-diffp', ('|', ('@', 'x')), 1))
		self.assertEqual (p ("| 'str'|'"), ('-diffp', ('|', ('"', 'str')), 1))
		self.assertEqual (p ("{x**y}'"), ('-diffp', ('^', ('@', 'x'), ('@', 'y')), 1))
		self.assertEqual (p ("{{-1}'}"), ('-diffp', ('#', '-1'), 1))
		self.assertEqual (p ("{a [b]}''"), ('-diffp', ('-idx', ('@', 'a'), (('@', 'b'),)), 2))
		self.assertEqual (p ("1.'''"), ('-diffp', ('#', '1.'), 3))
		self.assertEqual (p ('x [1]'), ('-idx', ('@', 'x'), (('#', '1'),)))
		self.assertEqual (p ('1 [x]'), ('-idx', ('#', '1'), (('@', 'x'),)))
		self.assertEqual (p ('[1, 2] [x]'), ('-idx', ('[', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (p ('{1, 2} [x]'), ('-idx', ('-set', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (p ('{x: 2} [x]'), ('-idx', ('-dict', ((('@', 'x'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (p ('{y: 2} [x]'), ('-idx', ('-dict', ((('@', 'y'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (p ("'}'"), ('"', '}'))
		self.assertEqual (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}'), ('*', (('@', 'q'), ('@', 'w'), ('@', 'e'), ('@', 'r'), ('@', 't'), ('@', 'y'), ('@', 'u'), ('@', 'i'), ('@', 'o'), ('@', 'p'), ('@', 'a'), ('@', 's'), ('@', 'd'), ('@', 'f')), {2, 3, 4, 5, 8, 12}))
		self.assertEqual (p ('x, y = 1, 2'), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (p ('x, 2 = 1, 2'), (',', (('@', 'x'), ('=', ('#', '2'), ('#', '1')), ('#', '2'))))
		self.assertEqual (p ('(x, y) = 1, 2'), (',', (('=', ('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1')), ('#', '2'))))
		self.assertEqual (p ('1; x, y = 1, 2'), (';', (('#', '1'), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))))
		self.assertEqual (p ('1; x, 2 = 1, 2'), (';', (('#', '1'), (',', (('@', 'x'), ('=', ('#', '2'), ('#', '1')), ('#', '2'))))))
		self.assertEqual (p ('1; (x, y) = 1, 2'), (';', (('#', '1'), (',', (('=', ('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1')), ('#', '2'))))))
		self.assertEqual (p ('f()()'), ('*', (('-ufunc', 'f', ()), ('(', (',', ())))))
		self.assertEqual (p ('f()*()'), ('*', (('-ufunc', 'f', ()), ('(', (',', ()))), {1}))
		self.assertEqual (p ('f*()*()'), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1, 2}))
		self.assertEqual (p ('f*()()'), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1}))

		self.assertEqual (p ('dy / dx'), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (p ('dy / dx z'), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z'))))
		self.assertEqual (p ('d**2 y / dx**2'), ('-diff', ('@', 'y'), 'd', (('x', 2),)))
		self.assertEqual (p ('d**2 y / dx**2 z'), ('*', (('-diff', ('@', 'y'), 'd', (('x', 2),)), ('@', 'z'))))
		self.assertEqual (p ('d**2 y / dx dy'), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (p ('d**2 y / dx dy z'), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))), ('@', 'z'))))
		self.assertEqual (p ('\\frac{dy}{dx}'), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (p ('\\frac{dy}{dx} z'), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z'))))
		self.assertEqual (p ('\\frac{d**2}{dx**2}'), ('/', ('^', ('@', 'd'), ('#', '2')), ('^', ('@', 'dx'), ('#', '2'))))
		self.assertEqual (p ('\\frac{d**2}{dx**2} z'), ('-diff', ('@', 'z'), 'd', (('x', 2),)))
		self.assertEqual (p ('\\frac{d**2}{dx dy}'), ('/', ('^', ('@', 'd'), ('#', '2')), ('*', (('@', 'dx'), ('@', 'dy')))))
		self.assertEqual (p ('\\frac{d**2}{dx dy} z'), ('-diff', ('@', 'z'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (p ('\\frac{d**2 y}{dx dy}'), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (p ('\\frac{d**2 y}{dx dy} z'), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))), ('@', 'z'))))
		self.assertEqual (p ('\\int dy / dx'), ('-intg', ('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', '')))
		self.assertEqual (p ('\\int d/dx x**2 dx'), ('-intg', ('-diff', ('^', ('@', 'x'), ('#', '2')), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (p ('\\int d/dx y(x) dx'), ('-intg', ('-diff', ('-ufunc', 'y', (('@', 'x'),)), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (p ('\\int dx dx dx'), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx'), ('@', 'dx'))))
		self.assertEqual (p ('\\int dx * dx dx'), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx'), ('@', 'dx')), {1}))
		self.assertEqual (p ('dlambda / dx : x'), ('-slice', ('-diff', ('@', 'lambda'), 'd', (('x', 1),)), ('@', 'x'), None))
		self.assertEqual (p ('d**2 lambda / dx**2 : x'), ('-slice', ('-diff', ('@', 'lambda'), 'd', (('x', 2),)), ('@', 'x'), None))
		self.assertEqual (p ('ln1.or'), ('.', ('@', 'ln1'), 'or'))
		self.assertEqual (p ('ln1. or'), None)
		self.assertEqual (p ('ln1 . or'), None)
		self.assertEqual (p ('a.b * c.d'), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd')), {1}))
		self.assertEqual (p ('a.b c.d'), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd'))))
		self.assertEqual (p ('lambda x, y, z: ln lambda x:'), (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'y'), ('-slice', ('@', 'z'), ('*', (('-log', ('@', 'lambda')), ('@', 'x'))), False))))
		self.assertEqual (p ('lambda x, y, z: ln lambda x: 1'), ('-lamb', ('-log', ('-lamb', ('#', '1'), ('x',))), ('x', 'y', 'z')))

		self.assertEqual (p ('f (x) (0)'), ('*', (('-ufunc', 'f', (('@', 'x'),)), ('(', ('#', '0')))))
		self.assertEqual (p ('f (x, y) (0, 0)'), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'))), ('(', (',', (('#', '0'), ('#', '0')))))))
		self.assertEqual (p ('f (x, y, z) (0, 0, 0)'), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('(', (',', (('#', '0'), ('#', '0'), ('#', '0')))))))
		self.assertEqual (p ("f (x)' (0)"), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (p ('\\. x+y |_{x = 1}'), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (p ('\\. x+y |_{x = 1, y = 2}'), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (p ('\\. x+y |_{x, y = 1, 2}'), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (p ('\\. x+y |_{\\substack{x = 1}}'), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}'), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (p ('\\. f(x) |_{f(x) = y}'), ('-subs', ('-ufunc', 'f', (('@', 'x'),)), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')),)))
		self.assertEqual (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}'), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}'), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}'), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}'), ('-subs', ('(', ('+', (('(', (',', (('#', '1'), ('#', '2')))), ('(', (',', (('#', '1'), ('#', '2'))))))), ((('(', (',', (('#', '1'), ('#', '2'), ('#', '1'), ('#', '2')))), ('(', (',', (('#', '3'), ('#', '4'))))),)))

		self.assertEqual (p ("f (x)' (0)"), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (p ('d / dx (f (x)) (0)'), ('-subs', ('-diff', ('-ufunc', 'f', (('@', 'x'),)), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (p ('d / dx (u (x, y)) (x, y)'), ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)))
		self.assertEqual (p ('d / dx (u (x, y)) (0, y)'), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (p ('d / dx (u (x, y)) (0, 0)'), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (p ('d**2 / dx dy (u (x, y)) (x, y)'), ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (p ('d**2 / dx dy (u (x, y)) (0, y)'), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (p ('d**2 / dx dy (u (x, y)) (0, 0)'), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})"), ('-func', 'dsolve', (('+', (('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 2), ('*', (('#', '11'), ('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 1))), ('*', (('#', '24'), ('-ufunc', 'y', (('@', 'x'),)))))), ('=', ('@', 'ics'), ('-dict', ((('-ufunc', 'y', (('#', '0'),)), ('#', '0')), (('-subs', ('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)), ('#', '-7'))))))))
		self.assertEqual (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}"), ('-subs', ('[', (('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ('-diffp', ('-ufunc', 'g', (('@', 'y'),)), 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}'), ('-subs', ('[', (('-diff', ('(', ('-ufunc', 'f', (('@', 'x'), ('@', 'y')))), 'd', (('x', 1),)), ('-diff', ('(', ('-ufunc', 'g', (('@', 'y'), ('@', 'x')))), 'd', (('x', 1),)))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}'), ('-subs', ('-diff', ('(', ('-ufunc', 'f', (('@', 'x'), ('@', 'z')))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')), (('@', 'z'), ('#', '3')))))
		self.assertEqual (p ('?() = 2'), ('=', ('-ufunc', '?', ()), ('#', '2')))
		self.assertEqual (p ('?f() = 2'), ('=', ('-ufunc', '?f', ()), ('#', '2')))
		self.assertEqual (p ('d / dx (a) b'), ('*', (('-diff', ('(', ('@', 'a')), 'd', (('x', 1),)), ('@', 'b'))))
		self.assertEqual (p ('\\frac{d}{dx} (a) b'), ('*', (('-diff', ('(', ('@', 'a')), 'd', (('x', 1),)), ('@', 'b'))))
		self.assertEqual (p ('sin (())'), ('-func', 'sin', (('(', (',', ())),)))
		self.assertEqual (p ('sin (((a))'), ('-func', 'sin', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (p ('a.b (())'), ('.', ('@', 'a'), 'b', (('(', (',', ())),)))
		self.assertEqual (p ('a.b (((a))'), ('.', ('@', 'a'), 'b', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (p ('@x'), ('-func', '@', (('@', 'x'),)))
		self.assertEqual (p ('@(x + y)'), ('-func', '@', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (p ('@(x + y)'), ('-func', '@', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (p ('%x'), ('-func', '%', (('@', 'x'),)))
		self.assertEqual (p ('%(x + y)'), ('-func', '%', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (p ('%%x'), ('-func', '%', (('-func', '%', (('@', 'x'),)),)))
		self.assertEqual (p ('%%(x + y)'), ('-func', '%', (('-func', '%', (('+', (('@', 'x'), ('@', 'y'))),)),)))
		self.assertEqual (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]'), ('-idx', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), (('-slice', False, False, None), ('-slice', ('#', '1'), False, None))))

		self.assertEqual (p ('N - N N 2'), ('+', (('@', 'N'), ('-', ('-func', 'N', (('-func', 'N', (('#', '2'),)),))))))
		self.assertEqual (p ('N N N 2'), ('-func', 'N', (('-func', 'N', (('-func', 'N', (('#', '2'),)),)),)))
		self.assertEqual (p ('sin sin sin 2'), ('-func', 'sin', (('-func', 'sin', (('-func', 'sin', (('#', '2'),)),)),)))
		self.assertEqual (p ('-N sin -N 2'), ('-', ('-func', 'N', (('-func', 'sin', (('-', ('-func', 'N', (('#', '2'),))),)),))))
		self.assertEqual (p ('sin -N sin 2'), ('-func', 'sin', (('-', ('-func', 'N', (('-func', 'sin', (('#', '2'),)),))),)))
		self.assertEqual (p ('N N sin -a [2]'), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (p ('N N sin -a.b [2]'), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))),)),)),)))
		self.assertEqual (p ('N N sin -a.b () [2]'), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),))),)),)),)))
		self.assertEqual (p ('N N sin -a.b () [2] [3]'), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),)), (('#', '3'),))),)),)),)))
		self.assertEqual (p ('sin -N () [2] [3].c [4].d () [5]'), ('-func', 'sin', (('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))),)))
		self.assertEqual (p ('sqrt -N () [2] [3].c [4].d () [5]'), ('-sqrt', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (p ('sqrt[3] -N () [2] [3].c [4].d () [5]'), ('-sqrt', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))), ('#', '3')))
		self.assertEqual (p ('log -N () [2] [3].c [4].d () [5]'), ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (p ('\\log_2 -N () [2] [3].c [4].d () [5]'), ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))), ('#', '2')))
		self.assertEqual (p ('N sin**2 ln**2 N x'), ('-func', 'N', (('^', ('-func', 'sin', (('^', ('-log', ('-func', 'N', (('@', 'x'),))), ('#', '2')),)), ('#', '2')),)))
		self.assertEqual (p ('sin ln N x'), ('-func', 'sin', (('-log', ('-func', 'N', (('@', 'x'),))),)))
		self.assertEqual (p ('sin(a)**[a][b].c'), ('^', ('-func', 'sin', (('@', 'a'),)), ('.', ('-idx', ('[', (('@', 'a'),)), (('@', 'b'),)), 'c')))
		self.assertEqual (p ('N sin N sin x'), ('-func', 'N', (('-func', 'sin', (('-func', 'N', (('-func', 'sin', (('@', 'x'),)),)),)),)))
		self.assertEqual (p ('cos**-1 0 \\log_2 8'), ('*', (('-func', 'acos', (('#', '0'),)), ('-log', ('#', '8'), ('#', '2')))))
		self.assertEqual (p ('N sin sqrt[3] \\log_2 8'), ('-func', 'N', (('-func', 'sin', (('-sqrt', ('-log', ('#', '8'), ('#', '2')), ('#', '3')),)),)))
		self.assertEqual (p ('sin(x)**-a[b][c].d'), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (p ('sin sin x [2].w'), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),)))
		self.assertEqual (p ('sin -sin x [2].w'), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (p ('sin sin (x) [2].w'), ('-func', 'sin', (('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w'),)))
		self.assertEqual (p ('sin -sin (x) [2].w'), ('-func', 'sin', (('-', ('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w')),)))
		self.assertEqual (p ('sin sin x [2].w ()'), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w', ()),)),)))
		self.assertEqual (p ('ln ln x [2].w'), ('-log', ('-log', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'))))
		self.assertEqual (p ('N N sin -a [2]'), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (p ('sin sin -x [2].w'), ('-func', 'sin', (('-func', 'sin', (('-', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w')),)),)))
		self.assertEqual (p ('sin -sin x [2].w'), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (p ('sin(a)**b[2]'), ('^', ('-func', 'sin', (('@', 'a'),)), ('-idx', ('@', 'b'), (('#', '2'),))))
		self.assertEqual (p ('sin**-a[b][c].d x'), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (p ('sin**-a[b][c].d (x)'), ('^', ('@', 'sin'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (p ('sin**-a[b][c].d {(x)}'), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (p ('sin**-a[b][c] (x)'), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (p ('\\int**-a[b][c] x'), ('-intg', ('@', 'x'), ('@', ''), ('#', '0'), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (p ('\\int**-a[b][c].d (x)'), ('-intg', None, ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (p ('\\int**-a[b][c].d {(x)}'), ('-intg', ('(', ('@', 'x'), True), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (p ('\\int**-a[b][c].d (x) y'), ('-intg', ('@', 'y'), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (p ('\\int**-a[b][c].d {(x)} y'), ('-intg', ('*', (('(', ('@', 'x'), True), ('@', 'y'))), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (p ('\\int**a.b[2] x dx'), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))))

		self.assertEqual (p ('d/dx (real = True)'), ('-diff', ('(', ('=', ('@', 'real'), ('@', 'True'))), 'd', (('x', 1),)))
		self.assertEqual (p ('f {\\left(x\\right)}'), ('-ufunc', 'f', (('@', 'x'),)))
		self.assertEqual (p ('a.b {(x)}'), ('*', (('.', ('@', 'a'), 'b'), ('(', ('@', 'x'), True))))
		self.assertEqual (p ('a.b {\\left(x\\right)}'), ('.', ('@', 'a'), 'b', (('@', 'x'),)))
		self.assertEqual (p ('\\log_{|x|} y'), ('-log', ('@', 'y'), ('|', ('@', 'x'))))
		self.assertEqual (p ('|\\int a + b dx|'), ('|', ('-intg', ('+', (('@', 'a'), ('@', 'b'))), ('@', 'dx'))))
		self.assertEqual (p ('\\int deg N dx'), ('-intg', ('-func', 'deg', (('@', 'N'),)), ('@', 'dx')))
		self.assertEqual (p ('a \\int x dx / c'), ('/', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')))), ('@', 'c')))
		self.assertEqual (p ('\\int x dx b / c'), ('/', ('*', (('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b'))), ('@', 'c')))
		self.assertEqual (p ('a \\int x dx b / c'), ('/', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b'))), ('@', 'c')))
		self.assertEqual (p ('a {\\lim_{x\\to0} \\int x dx} / b'), ('/', ('*', (('@', 'a'), ('-lim', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0')))), ('@', 'b')))
		self.assertEqual (p ('a {\\sum_{x=0}^1 \\int x dx} / b'), ('/', ('*', (('@', 'a'), ('-sum', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0'), ('#', '1')))), ('@', 'b')))
		self.assertEqual (p ('a / \\int x dx * c'), ('*', (('/', ('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx'))), ('@', 'c')), {1}))
		self.assertEqual (p ('a / b \\int x dx * c'), ('*', (('/', ('@', 'a'), ('*', (('@', 'b'), ('-intg', ('@', 'x'), ('@', 'dx'))))), ('@', 'c')), {1}))

		self.assertEqual (p ('cos'), ('@', 'cos'))
		self.assertEqual (p ('f = cos'), ('=', ('@', 'f'), ('@', 'cos')))
		self.assertEqual (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)'), ('.', ('-mat', ((('#', '0'), ('@', 'pi')), (('-', ('@', 'pi')), ('#', '0')))), 'applyfunc', (('@', 'cos'),)))
		self.assertEqual (p ('$sin (real = True)'), ('-sym', 'sin', (('real', ('@', 'True')),)))
		self.assertEqual (p ('sin = $(real = True)'), ('=', ('@', 'sin'), ('-sym', '', (('real', ('@', 'True')),))))

	def test_ast2tex (self):
		self.assertEqual (ast2tex (p ('1')), '1')
		self.assertEqual (ast2tex (p ('1.')), '1.')
		self.assertEqual (ast2tex (p ('.1')), '0.1')
		self.assertEqual (ast2tex (p ('1e20')), '1{e}{+20}')
		self.assertEqual (ast2tex (p ('1E-20')), '1{e}{-20}')
		self.assertEqual (ast2tex (p ('1.e+20')), '1.{e}{+20}')
		self.assertEqual (ast2tex (p ('.1e-20')), '0.1{e}{-20}')
		self.assertEqual (ast2tex (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')), '\\sin{\\left(-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901 \\right)}')
		self.assertEqual (ast2tex (p ('x')), 'x')
		self.assertEqual (ast2tex (p ('xy')), 'xy')
		self.assertEqual (ast2tex (p ('dx')), 'dx')
		self.assertEqual (ast2tex (p ('partialx')), '\\partial x')
		self.assertEqual (ast2tex (p ('\\partial x')), '\\partial x')
		self.assertEqual (ast2tex (p ('x d  y')), 'x\\ d\\ y')
		self.assertEqual (ast2tex (p ('x partial y')), 'x\\ \\partial\\ y')
		self.assertEqual (ast2tex (p ('x \\partial  y')), 'x\\ \\partial\\ y')
		self.assertEqual (ast2tex (p ('x dx dy y')), 'x\\ dx\\ dy\\ y')
		self.assertEqual (ast2tex (p ('x partialx partialy y')), 'x\\ \\partial x\\ \\partial y\\ y')
		self.assertEqual (ast2tex (p ('-1')), '-1')
		self.assertEqual (ast2tex (p ('-x')), '-x')
		self.assertEqual (ast2tex (p ('{x}')), 'x')
		self.assertEqual (ast2tex (p ('()')), '\\left( \\right)')
		self.assertEqual (ast2tex (p ('(x)')), '\\left(x \\right)')
		self.assertEqual (ast2tex (p ('(x,)')), '\\left(x, \\right)')
		self.assertEqual (ast2tex (p ('(x,y)')), '\\left(x, y \\right)')
		self.assertEqual (ast2tex (p ('(x,y,)')), '\\left(x, y \\right)')
		self.assertEqual (ast2tex (p ('[]')), '\\left[ \\right]')
		self.assertEqual (ast2tex (p ('[x]')), '\\left[x \\right]')
		self.assertEqual (ast2tex (p ('[x,]')), '\\left[x \\right]')
		self.assertEqual (ast2tex (p ('[x,y]')), '\\left[x, y \\right]')
		self.assertEqual (ast2tex (p ('[x,y,]')), '\\left[x, y \\right]')
		self.assertEqual (ast2tex (p ('"x\\x20\\n"')), "\\text{'x \\n'}")
		self.assertEqual (ast2tex (p ("'x\\x20\\n'")), "\\text{'x \\n'}")
		self.assertEqual (ast2tex (p ('|x|')), '\\left|x \\right|')
		self.assertEqual (ast2tex (p ('x!')), 'x!')
		self.assertEqual (ast2tex (p ('x+y')), 'x + y')
		self.assertEqual (ast2tex (p ('x-y')), 'x - y')
		self.assertEqual (ast2tex (p ('x*y')), 'x\\ y')
		self.assertEqual (ast2tex (p ('x y')), 'x\\ y')
		self.assertEqual (ast2tex (p ('x(y)')), 'x\\left(y \\right)')
		self.assertEqual (ast2tex (p ('x*(y)')), 'x \\cdot \\left(y \\right)')
		self.assertEqual (ast2tex (p ('x/y')), '\\frac{x}{y}')
		self.assertEqual (ast2tex (p ('x^y')), 'x^y')
		self.assertEqual (ast2tex (p ('log x')), '\\ln{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('log {x}')), '\\ln{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('log (x)')), '\\ln{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('\\log_2 x')), '\\log_2{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('\\log_2 {x}')), '\\log_2{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('\\log_2 (x)')), '\\log_2{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sqrt x')), '\\sqrt{x}')
		self.assertEqual (ast2tex (p ('sqrt {x}')), '\\sqrt{x}')
		self.assertEqual (ast2tex (p ('sqrt (x)')), '\\sqrt{x}')
		self.assertEqual (ast2tex (p ('sqrt {(x)}')), '\\sqrt{x}')
		self.assertEqual (ast2tex (p ('sqrt[3] x')), '\\sqrt[3]{x}')
		self.assertEqual (ast2tex (p ('sqrt[3] {x}')), '\\sqrt[3]{x}')
		self.assertEqual (ast2tex (p ('sqrt[3] {(x)}')), '\\sqrt[3]{x}')
		self.assertEqual (ast2tex (p ('sqrt[3] (x)')), '\\sqrt[3]{x}')
		self.assertEqual (ast2tex (p ('sin x')), '\\sin{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin^2 x')), '\\sin^2{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin (x)')), '\\sin{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin (x)^2')), '\\sin^2{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin {x}')), '\\sin{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin {(x)}')), '\\sin{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('{sin x}^2')), '\\sin^2{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin**2 x')), '\\sin^2{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin**-1 x')), '\\sin^{-1}{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin(x)**-1')), '\\sin{\\left(x \\right)}^{-1}')
		self.assertEqual (ast2tex (p ('acos (x)')), '\\cos^{-1}{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('\\arccos (x)')), '\\cos^{-1}{\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin(x**2)')), '\\sin{\\left(x^2 \\right)}')
		self.assertEqual (ast2tex (p ('sin(x**2)**2')), '\\sin^2{\\left(x^2 \\right)}')
		self.assertEqual (ast2tex (p ('(sin(x**2)**2)')), '\\left(\\sin^2{\\left(x^2 \\right)} \\right)')
		self.assertEqual (ast2tex (p ('ln(x**2)')), '\\ln{\\left(x^2 \\right)}')
		self.assertEqual (ast2tex (p ('ln(x**2)**2')), '\\ln{\\left(x^2 \\right)}^2')
		self.assertEqual (ast2tex (p ('(ln(x**2)**2)')), '\\left(\\ln{\\left(x^2 \\right)}^2 \\right)')
		self.assertEqual (ast2tex (p ('gamma(x**2)')), '\\Gamma{\\left(x^2 \\right)}')
		self.assertEqual (ast2tex (p ('gamma(x**2)**2')), '\\Gamma{\\left(x^2 \\right)}^2')
		self.assertEqual (ast2tex (p ('(gamma(x**2)**2)')), '\\left(\\Gamma{\\left(x^2 \\right)}^2 \\right)')
		self.assertEqual (ast2tex (p ('{gamma}[2]')), '{\\gamma}\\left[2 \\right]')
		self.assertEqual (ast2tex (p ('{Gamma}[2]')), '{\\Gamma}\\left[2 \\right]')
		self.assertEqual (ast2tex (p ('f{(x)}')), 'f \\cdot \\left(x \\right)')
		self.assertEqual (ast2tex (p ("f{(x)}'(0)")), "f \\cdot \\left(x \\right)' \\left(0 \\right)")
		self.assertEqual (ast2tex (p ("f{(x)}'{(0)}")), "f \\cdot \\left(x \\right)' \\left(0 \\right)")
		self.assertEqual (ast2tex (p ('\\operatorname{x_{1}}{\\left(x \\right)}')), 'x_{1}\\left(x \\right)')
		self.assertEqual (ast2tex (p ('\\lim_{x\\to0} 1/x')), '\\lim_{x \\to 0} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('\\lim_{x\\to0^+} 1/x')), '\\lim_{x \\to 0^+} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('\\lim_{x\\to0**-} 1/x')), '\\lim_{x \\to 0^-} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('Limit (1/x, x, 0)')), '\\lim_{x \\to 0^+} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('Limit (1/x, x, 0, "-")')), '\\lim_{x \\to 0^-} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('Limit (1/x, x, 0, dir="+-")')), '\\lim_{x \\to 0} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('limit (1/x, x, 0)')), '\\lim_{x \\to 0^+} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('limit (1/x, x, 0, "-")')), '\\lim_{x \\to 0^-} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('limit (1/x, x, 0, dir="+-")')), '\\lim_{x \\to 0} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('\\sum_{n=0}^\\infty x^n/n!')), '\\sum_{n = 0}^\\infty \\frac{x^n}{n!}')
		self.assertEqual (ast2tex (p ('Sum (x^n/n!, (n, 0, oo))')), '\\sum_{n = 0}^\\infty \\frac{x^n}{n!}')
		self.assertEqual (ast2tex (p ('summation (x^n/n!, (n, 0, oo))')), '\\sum_{n = 0}^\\infty \\frac{x^n}{n!}')
		self.assertEqual (ast2tex (p ('d/dx x**2y**2z')), '\\frac{\\partial}{\\partial x}\\left(x^2 y^2 z \\right)')
		self.assertEqual (ast2tex (p ('d^2/dx^2 x^2y**2z')), '\\frac{\\partial^2}{\\partial x^2}\\left(x^2 y^2 z \\right)')
		self.assertEqual (ast2tex (p ('d^3/dx^2dy x^2y**2z')), '\\frac{\\partial^3}{\\partial x^2 \\partial y}\\left(x^2 y^2 z \\right)')
		self.assertEqual (ast2tex (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z')), '\\frac{\\partial^4}{\\partial x^2 \\partial y \\partial z}\\left(x^2 y^2 z \\right)')
		self.assertEqual (ast2tex (p ('d**1.5 / dx dy x**2y**2')), '\\frac{d^{1.5}}{dx\\ dy\\ x^2 y^2}')
		self.assertEqual (ast2tex (p ('d**-2 / dx dy x**2y**2')), '\\frac{d^{-2}}{dx\\ dy\\ x^2 y^2}')
		self.assertEqual (ast2tex (p ('d**2 / dx**1.5 x**2y**2')), '\\frac{\\left(d^2 \\right)}{dx^{1.5} x^2 y^2}')
		self.assertEqual (ast2tex (p ('Derivative (x^2y**2z, x, 2, y, z)')), '\\frac{\\partial^4}{\\partial x^2 \\partial y \\partial z}\\left(x^2 y^2 z \\right)')
		self.assertEqual (ast2tex (p ('diff (x^2y**2z, x, 2, y, z)')), '\\frac{\\partial^4}{\\partial x^2 \\partial y \\partial z}\\left(x^2 y^2 z \\right)')
		self.assertEqual (ast2tex (p ('\\int dx')), '\\int \\ dx')
		self.assertEqual (ast2tex (p ('\\int x dx')), '\\int x \\ dx')
		self.assertEqual (ast2tex (p ('\\int_0^1 x dx')), '\\int_0^1 x \\ dx')
		self.assertEqual (ast2tex (p ('\\int_0^1 \\int y dy dx')), '\\int_0^1 \\int y \\ dy \\ dx')
		self.assertEqual (ast2tex (p ('Integral (\\int y dy, (x, 0, 1))')), '\\int_0^1 \\int y \\ dy \\ dx')
		self.assertEqual (ast2tex (p ('integrate (\\int y dy, (x, 0, 1))')), '\\int_0^1 \\int y \\ dy \\ dx')

		self.assertEqual (ast2tex (p ('\\[1,]')), '\\begin{bmatrix} 1 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[1,2]')), '\\begin{bmatrix} 1 \\\\ 2 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[1,2,]')), '\\begin{bmatrix} 1 \\\\ 2 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[1,],]')), '\\begin{bmatrix} 1 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[1,],[2,]]')), '\\begin{bmatrix} 1 \\\\ 2 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[1,],[2,],]')), '\\begin{bmatrix} 1 \\\\ 2 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]')), '\\begin{bmatrix} 1 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}')), '\\begin{bmatrix} 1 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}')), '\\begin{bmatrix} 1 & 2 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}')), '\\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}')), '\\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[1,2]!')), '\\begin{bmatrix} 1 \\\\ 2 \\end{bmatrix}!')
		self.assertEqual (ast2tex (p ('\\[[0,1],[1,0]]**x')), '{\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}}^x')
		self.assertEqual (ast2tex (p ('\\[[1,2],[3,4]]!')), '\\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}!')
		self.assertEqual (ast2tex (p ('\\[[1,2,3],[4,5,6]].T')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}.T')
		self.assertEqual (ast2tex (p ('\\[[1,2,3],[4,5,6]].T.T')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}.T.T')
		self.assertEqual (ast2tex (p ('\\[[1,2,3],[4,5,6]].T.T.T')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}.T.T.T')
		self.assertEqual (ast2tex (p ('\\[[1,2,3],[4,5,6]].transpose ()')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}.\\operatorname{transpose}\\left( \\right)')
		self.assertEqual (ast2tex (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}.\\operatorname{transpose}\\left( \\right).\\operatorname{transpose}\\left( \\right)')
		self.assertEqual (ast2tex (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}.\\operatorname{transpose}\\left( \\right).\\operatorname{transpose}\\left( \\right).\\operatorname{transpose}\\left( \\right)')
		self.assertEqual (ast2tex (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}.\\operatorname{transpose}\\left( \\right).\\operatorname{transpose}\\left( \\right).T.T.\\operatorname{transpose}\\left( \\right).\\operatorname{transpose}\\left( \\right)')
		self.assertEqual (ast2tex (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]')), '\\begin{bmatrix} A & B \\\\ C & D \\end{bmatrix} \\cdot \\begin{bmatrix} x \\\\ y \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[1, 2], [3')), '\\begin{bmatrix} 1 & 2 \\\\ 3 & {} \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[1, 2], [3]]')), '\\begin{bmatrix} 1 & 2 \\\\ 3 & {} \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[1], [2, 3]]')), '\\begin{bmatrix} 1 & {} \\\\ 2 & 3 \\end{bmatrix}')

		self.assertEqual (ast2tex (p ('-1**x')), '-1^x')
		self.assertEqual (ast2tex (p ('{-1}**x')), '\\left(-1 \\right)^x')
		self.assertEqual (ast2tex (p ('-{-1}**x')), '-\\left(-1 \\right)^x')
		self.assertEqual (ast2tex (p ('(-1)**x')), '\\left(-1 \\right)^x')
		self.assertEqual (ast2tex (p ('-(-1)**x')), '-\\left(-1 \\right)^x')
		self.assertEqual (ast2tex (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')), '\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')
		self.assertEqual (ast2tex (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')), '\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')
		self.assertEqual (ast2tex (p ('1 if x < y')), '\\begin{cases} 1 & \\text{for}\\: x < y \\end{cases}')
		self.assertEqual (ast2tex (p ('1 if x < y else 3')), '\\begin{cases} 1 & \\text{for}\\: x < y \\\\ 3 & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('1 if x < y else 3 if x < z')), '\\begin{cases} 1 & \\text{for}\\: x < y \\\\ 3 & \\text{for}\\: x < z \\end{cases}')
		self.assertEqual (ast2tex (p ('1 if x < y else 3 if x < z else 5')), '\\begin{cases} 1 & \\text{for}\\: x < y \\\\ 3 & \\text{for}\\: x < z \\\\ 5 & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}')), '\\begin{cases} 1 & \\text{for}\\: x < y \\\\ 3 & \\text{for}\\: x < z \\\\ 5 & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}')), '\\begin{cases} 1 & \\text{for}\\: x < y \\\\ 3 & \\text{for}\\: x < z \\\\ 5 & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}')), '\\begin{cases} 1 & \\text{for}\\: x < y \\\\ 3 & \\text{for}\\: x < z \\\\ 5 & \\text{for}\\: x < w \\end{cases}')
		self.assertEqual (ast2tex (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}')), '\\begin{cases} 1 & \\text{for}\\: x < y \\\\ 3 & \\text{for}\\: x < z \\\\ 5 & \\text{for}\\: x < w \\end{cases}')
		self.assertEqual (ast2tex (p ('x**y.a')), 'x^{y.a}')
		self.assertEqual (ast2tex (p ('x**y.a ()')), 'x^{y.\\operatorname{a}\\left( \\right)}')
		self.assertEqual (ast2tex (p ('x**y.a.b')), 'x^{y.a.b}')
		self.assertEqual (ast2tex (p ('x**y.a.b ()')), 'x^{y.a.\\operatorname{b}\\left( \\right)}')
		self.assertEqual (ast2tex (p ('x**y.a ().b')), 'x^{y.\\operatorname{a}\\left( \\right).b}')
		self.assertEqual (ast2tex (p ('x**y.a ().b ()')), 'x^{y.\\operatorname{a}\\left( \\right).\\operatorname{b}\\left( \\right)}')
		self.assertEqual (ast2tex (p ('{1 if x < 0 else 3} if x < 1 else 5')), '\\begin{cases} \\begin{cases} 1 & \\text{for}\\: x < 0 \\\\ 3 & \\text{otherwise} \\end{cases} & \\text{for}\\: x < 1 \\\\ 5 & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('1 if {True if x < 0 else False} else 5')), '\\begin{cases} 1 & \\text{for}\\: \\begin{cases} True & \\text{for}\\: x < 0 \\\\ False & \\text{otherwise} \\end{cases} \\\\ 5 & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}')), '\\begin{cases} 1 & \\text{for}\\: \\begin{cases} True & \\text{for}\\: x < 0 \\\\ False & \\text{otherwise} \\end{cases} \\\\ \\begin{cases} 7 & \\text{for}\\: x < 1 \\\\ 5 & \\text{otherwise} \\end{cases} & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')), '\\begin{cases} \\begin{cases} 1 & \\text{for}\\: x < 0 \\\\ 9 & \\text{otherwise} \\end{cases} & \\text{for}\\: \\begin{cases} True & \\text{for}\\: x < 1 \\\\ False & \\text{otherwise} \\end{cases} \\\\ \\begin{cases} 7 & \\text{for}\\: x < 2 \\\\ 5 & \\text{otherwise} \\end{cases} & \\text{otherwise} \\end{cases}')
		self.assertEqual (ast2tex (p ('x.y!')), 'x.y!')
		self.assertEqual (ast2tex (p ('x.y**2')), 'x.y^2')
		self.assertEqual (ast2tex (p ('x.y ()!')), 'x.\\operatorname{y}\\left( \\right)!')
		self.assertEqual (ast2tex (p ('x.y ()**2')), 'x.\\operatorname{y}\\left( \\right)^2')
		self.assertEqual (ast2tex (p ('x**y.a!')), 'x^{y.a!}')
		self.assertEqual (ast2tex (p ('x**y.a**2')), 'x^{y.a^2}')
		self.assertEqual (ast2tex (p ('x**y.a ()!')), 'x^{y.\\operatorname{a}\\left( \\right)!}')
		self.assertEqual (ast2tex (p ('x**y.a ()**2')), 'x^{y.\\operatorname{a}\\left( \\right)^2}')
		self.assertEqual (ast2tex (p ('lambda: x')), '\\left(\\left( \\right) \\mapsto x \\right)')
		self.assertEqual (ast2tex (p ('lambda x: x**2')), '\\left(x \\mapsto x^2 \\right)')
		self.assertEqual (ast2tex (p ('lambda x, y: x + y')), '\\left(\\left(x, y \\right) \\mapsto x + y \\right)')
		self.assertEqual (ast2tex (p ('lambda x, y, z: x + y + z')), '\\left(\\left(x, y, z \\right) \\mapsto x + y + z \\right)')
		self.assertEqual (ast2tex (p ('1, lambda: x')), '1, \\left(\\left( \\right) \\mapsto x \\right)')
		self.assertEqual (ast2tex (p ('1, lambda x: x**2')), '1, \\left(x \\mapsto x^2 \\right)')
		self.assertEqual (ast2tex (p ('1, lambda x, y: x + y')), '1, \\left(\\left(x, y \\right) \\mapsto x + y \\right)')
		self.assertEqual (ast2tex (p ('1, lambda x, y, z: x + y + z')), '1, \\left(\\left(x, y, z \\right) \\mapsto x + y + z \\right)')
		self.assertEqual (ast2tex (p ('f = lambda: 0')), 'f = \\left(\\left( \\right) \\mapsto 0 \\right)')
		self.assertEqual (ast2tex (p ('f = lambda x: 0')), 'f = \\left(x \\mapsto 0 \\right)')
		self.assertEqual (ast2tex (p ('f = lambda x, y: 0')), 'f = \\left(\\left(x, y \\right) \\mapsto 0 \\right)')
		self.assertEqual (ast2tex (p ('f = lambda x, y, z: 0')), 'f = \\left(\\left(x, y, z \\right) \\mapsto 0 \\right)')
		self.assertEqual (ast2tex (p ('\\left(\\left(\\right) \\mapsto x \\right)')), '\\left(\\left( \\right) \\mapsto x \\right)')
		self.assertEqual (ast2tex (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)')), '\\left(x \\mapsto x^2 \\right)')
		self.assertEqual (ast2tex (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)')), '\\left(\\left(x, y \\right) \\mapsto x + y \\right)')
		self.assertEqual (ast2tex (p ('\\lambda: x')), '\\lambda{:}x')
		self.assertEqual (ast2tex (p ('\\lambda x: x')), '\\lambda\\ x{:}x')
		self.assertEqual (ast2tex (p ('\\lambda x, y: x')), '\\lambda\\ x, y{:}x')
		self.assertEqual (ast2tex (p ('{lambda}: x')), '\\lambda{:}x')
		self.assertEqual (ast2tex (p ('{lambda} x: x')), '\\lambda\\ x{:}x')
		self.assertEqual (ast2tex (p ('{lambda} x, y: x')), '\\lambda\\ x, y{:}x')
		self.assertEqual (ast2tex (p ('$')), '\\$')
		self.assertEqual (ast2tex (p ('$s')), '\\$s')
		self.assertEqual (ast2tex (p ('$ (real = True)')), '\\$\\left(real = True \\right)')
		self.assertEqual (ast2tex (p ('$s (real = True)')), '\\$s\\left(real = True \\right)')

		self.assertEqual (ast2tex (p ('eye (2).is_diagonal ()')), '\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}.\\operatorname{is\\_diagonal}\\left( \\right)')
		self.assertEqual (ast2tex (p ('a [2]')), 'a\\left[2 \\right]')
		self.assertEqual (ast2tex (p ('a [2,3]')), 'a\\left[2, 3 \\right]')
		self.assertEqual (ast2tex (p ('a * [2]')), 'a \\cdot \\left[2 \\right]')
		self.assertEqual (ast2tex (p ('a * {-1}[x]')), 'a \\cdot \\left(-1 \\right)\\left[x \\right]')
		self.assertEqual (ast2tex (p ('a * [x][y][z]')), 'a \\cdot \\left[x \\right]\\left[y \\right]\\left[z \\right]')
		self.assertEqual (ast2tex (p ('N (1/2)')), '\\operatorname{N}{\\left(\\frac{1}{2} \\right)}')
		self.assertEqual (ast2tex (p ("S ('1/2')")), "\\operatorname{S}{\\left(\\text{'1/2'} \\right)}")
		self.assertEqual (ast2tex (p ("N (S ('1/2'))")), "\\operatorname{N}{\\left(\\operatorname{S}{\\left(\\text{'1/2'} \\right)} \\right)}")
		self.assertEqual (ast2tex (p ('S.Half')), 'S.Half')
		self.assertEqual (ast2tex (p ('N S.Half')), '\\operatorname{N}{\\left(S.Half \\right)}')
		self.assertEqual (ast2tex (p ('o [i].t')), 'o\\left[i \\right].t')
		self.assertEqual (ast2tex (p ('o [i]**2')), 'o\\left[i \\right]^2')
		self.assertEqual (ast2tex (p ('o [i]!')), 'o\\left[i \\right]!')
		self.assertEqual (ast2tex (p ("'Hello' [::-1]")), "\\text{'Hello'}\\left[{:}{:}{-1} \\right]")
		self.assertEqual (ast2tex (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}\\left[{:}, 1 \\right]')
		self.assertEqual (ast2tex (p ('\\binom96')), '\\binom{9}{6}')
		self.assertEqual (ast2tex (p ('binomial (x, y)')), '\\binom{x}{y}')
		self.assertEqual (ast2tex (p ('y - 1*x')), 'y - 1 x')
		self.assertEqual (ast2tex (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')")), "\\operatorname{Poly}{\\left(x^2 + 2 x + 1, x, domain = \\text{'ZZ'} \\right)}")
		self.assertEqual (ast2tex (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')")), "\\operatorname{Poly}{\\left(x^2 + y^2 + 2 x\\ y, x, y, domain = \\text{'CC'} \\right)}")
		self.assertEqual (ast2tex (p ('oct(10)')), '\\operatorname{oct}{\\left(10 \\right)}')
		self.assertEqual (ast2tex (p ('(1,) + (2,)')), '\\left(1, \\right) + \\left(2, \\right)')
		self.assertEqual (ast2tex (p ('[1] + [2]')), '\\left[1 \\right] + \\left[2 \\right]')
		self.assertEqual (ast2tex (p ("'a' + 'b'")), "\\text{'a'} + \\text{'b'}")
		self.assertEqual (ast2tex (p ('(1,) * 2')), '\\left(1, \\right) \\cdot 2')
		self.assertEqual (ast2tex (p ('[1] * 2')), '\\left[1 \\right] \\cdot 2')
		self.assertEqual (ast2tex (p ("'a' * 2")), "\\text{'a'} \\cdot 2")
		self.assertEqual (ast2tex (p ('Lambda (x, x**2)')), '\\left(x \\mapsto x^2 \\right)')
		self.assertEqual (ast2tex (p ('beta (2, 3)')), '\\beta{\\left(2, 3 \\right)}')
		self.assertEqual (ast2tex (p ('{x d} y')), 'x\\ d\\ y')
		self.assertEqual (ast2tex (p ('d**2e0/dx**2e0 x**3')), '\\frac{d^{2{e}{+0}}}{dx^{2{e}{+0}} x^3}')
		self.assertEqual (ast2tex (p ('ln((a)**b)')), '\\ln{\\left(\\left(a \\right)^b \\right)}')
		self.assertEqual (ast2tex (p ('a * \\int dx + {\\int dx dx}')), '{a \\int \\ dx} + {\\int \\ dx} \\cdot dx')
		self.assertEqual (ast2tex (p ('1 if {a = x if z} else 0 if y')), '\\begin{cases} 1 & \\text{for}\\: a = \\begin{cases} x & \\text{for}\\: z \\end{cases} \\\\ 0 & \\text{for}\\: y \\end{cases}')
		self.assertEqual (ast2tex (p ('a, lambda: b = 1')), 'a, \\left(\\left( \\right) \\mapsto b = 1 \\right)')
		self.assertEqual (ast2tex (p ('a * [2]')), 'a \\cdot \\left[2 \\right]')
		self.assertEqual (ast2tex (p ('sqrt(1, 2)')), '\\sqrt{\\left(1, 2 \\right)}')
		self.assertEqual (ast2tex (p ('x*[][y]')), 'x \\cdot \\left[ \\right]\\left[y \\right]')
		self.assertEqual (ast2tex (p ('lambda: x:')), '\\left(\\left( \\right) \\mapsto x{:} \\right)')
		self.assertEqual (ast2tex (p ('a*[x][y][z]')), 'a \\cdot \\left[x \\right]\\left[y \\right]\\left[z \\right]')
		self.assertEqual (ast2tex (p ('a*()**2')), 'a \\cdot \\left( \\right)^2')
		self.assertEqual (ast2tex (p ('a*().t')), 'a \\cdot \\left( \\right).t')
		self.assertEqual (ast2tex (p ('a*()[2]')), 'a \\cdot \\left( \\right)\\left[2 \\right]')
		self.assertEqual (ast2tex (p ('o.f*(a)')), 'o.f \\cdot \\left(a \\right)')
		self.assertEqual (ast2tex (p ('o.f*{1+2}')), 'o.f \\cdot \\left(1 + 2 \\right)')
		self.assertEqual (ast2tex (p ('d**2e0/dx**2e0 x**3')), '\\frac{d^{2{e}{+0}}}{dx^{2{e}{+0}} x^3}')
		self.assertEqual (ast2tex (p ('y**z [w]')), 'y^{z\\left[w \\right]}')
		self.assertEqual (ast2tex (p ('{y**z} [w]')), '{y^z}\\left[w \\right]')
		self.assertEqual (ast2tex (p ('x {y**z} [w]')), 'x {y^z}\\left[w \\right]')
		self.assertEqual (ast2tex (p ('{x y**z} [w]')), '\\left(x\\ y^z \\right)\\left[w \\right]')
		self.assertEqual (ast2tex (p ('Min (x, y, z)')), '\\operatorname{Min}{\\left(x, y, z \\right)}')
		self.assertEqual (ast2tex (p ('Max (x, y, z)')), '\\operatorname{Max}{\\left(x, y, z \\right)}')
		self.assertEqual (ast2tex (p ('\\Re (z)')), '\\Re{\\left(z \\right)}')
		self.assertEqual (ast2tex (p ('\\Im (z)')), '\\Im{\\left(z \\right)}')
		self.assertEqual (ast2tex (p ('re (z)')), '\\Re{\\left(z \\right)}')
		self.assertEqual (ast2tex (p ('im (z)')), '\\Im{\\left(z \\right)}')
		self.assertEqual (ast2tex (p ('{}')), '\\left\\{ \\right\\}')
		self.assertEqual (ast2tex (p ('{1: 2}')), '\\left\\{1{:} 2 \\right\\}')
		self.assertEqual (ast2tex (p ('{1: 2,}')), '\\left\\{1{:} 2 \\right\\}')
		self.assertEqual (ast2tex (p ('{1: 2, 3: 4}')), '\\left\\{1{:} 2, 3{:} 4 \\right\\}')
		self.assertEqual (ast2tex (p ('set ()')), '\\emptyset')
		self.assertEqual (ast2tex (p ('\\{}')), '\\emptyset')
		self.assertEqual (ast2tex (p ('\\{1}')), '\\left\\{1 \\right\\}')
		self.assertEqual (ast2tex (p ('\\{1,2}')), '\\left\\{1, 2 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2}')), '\\left\\{1, 2 \\right\\}')
		self.assertEqual (ast2tex (p ('1 in {1,2,3}')), '1 \\in \\left\\{1, 2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('1 \\in {1,2,3}')), '1 \\in \\left\\{1, 2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('4 in {1,2,3}')), '4 \\in \\left\\{1, 2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('4 \\in {1,2,3}')), '4 \\in \\left\\{1, 2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('4 not in {1,2,3}')), '4 \\notin \\left\\{1, 2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('4 \\notin {1,2,3}')), '4 \\notin \\left\\{1, 2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} - {2,3}')), '\\left\\{1, 2 \\right\\} - \\left\\{2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} || {2,3}')), '\\left\\{1, 2 \\right\\} \\cup \\left\\{2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} ^^ {2,3}')), '\\left\\{1, 2 \\right\\} \\ominus \\left\\{2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} && {2,3}')), '\\left\\{1, 2 \\right\\} \\cap \\left\\{2, 3 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} || {2,3} || {3,4}')), '\\left\\{1, 2 \\right\\} \\cup \\left\\{2, 3 \\right\\} \\cup \\left\\{3, 4 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} ^^ {2,3} ^^ {3,4}')), '\\left\\{1, 2 \\right\\} \\ominus \\left\\{2, 3 \\right\\} \\ominus \\left\\{3, 4 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} && {2,3} && {3,4}')), '\\left\\{1, 2 \\right\\} \\cap \\left\\{2, 3 \\right\\} \\cap \\left\\{3, 4 \\right\\}')
		self.assertEqual (ast2tex (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}')), '\\left\\{1, 2 \\right\\} \\cup \\left\\{2, 3 \\right\\} \\ominus \\left\\{3, 4 \\right\\} \\cap \\left\\{4, 5 \\right\\}')
		self.assertEqual (ast2tex (p ('solve (x**2 = 4)')), '\\operatorname{solve}{\\left(x^2 = 4 \\right)}')
		self.assertEqual (ast2tex (p ('Subs (x y, x, 2)')), '\\left. x\\ y \\right|_{x = 2}')
		self.assertEqual (ast2tex (p ('Subs (x y, (x, y), (2, 3))')), '\\left. x\\ y \\right|_{\\substack{x = 2 \\\\ y = 3}}')
		self.assertEqual (ast2tex (p ('(x y).subs (x, 2)')), '\\left. \\left(x\\ y \\right) \\right|_{x = 2}')
		self.assertEqual (ast2tex (p ('(x y).subs (x, 2).subs (y, 3)')), '\\left. \\left(x\\ y \\right) \\right|_{\\substack{x = 2 \\\\ y = 3}}')
		self.assertEqual (ast2tex (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])')), '\\left. \\left. \\left(x\\ y\\ z\\ w \\right) \\right|_{z = 4} \\right|_{\\substack{x = 2 \\\\ y = 3 \\\\ w = 5}}')
		self.assertEqual (ast2tex (p ('x or y')), 'x \\vee y')
		self.assertEqual (ast2tex (p ('x or y or z')), 'x \\vee y \\vee z')
		self.assertEqual (ast2tex (p ('x and y')), 'x \\wedge y')
		self.assertEqual (ast2tex (p ('x and y and z')), 'x \\wedge y \\wedge z')
		self.assertEqual (ast2tex (p ('x and y or z')), 'x \\wedge y \\vee z')
		self.assertEqual (ast2tex (p ('x and {y or z}')), 'x \\wedge \\left(y \\vee z \\right)')
		self.assertEqual (ast2tex (p ('not x or y')), '\\neg\\ x \\vee y')
		self.assertEqual (ast2tex (p ('not {x or y}')), '\\neg\\ \\left(x \\vee y \\right)')
		self.assertEqual (ast2tex (p ('not x and y')), '\\neg\\ x \\wedge y')
		self.assertEqual (ast2tex (p ('not {x and y}')), '\\neg\\ \\left(x \\wedge y \\right)')
		self.assertEqual (ast2tex (p ('x or not y')), 'x \\vee \\neg\\ y')
		self.assertEqual (ast2tex (p ('x and not y')), 'x \\wedge \\neg\\ y')
		self.assertEqual (ast2tex (p ('not x')), '\\neg\\ x')
		self.assertEqual (ast2tex (p ('not not x')), '\\neg\\ \\neg\\ x')
		self.assertEqual (ast2tex (p ('not not not x')), '\\neg\\ \\neg\\ \\neg\\ x')
		self.assertEqual (ast2tex (p ('0 or []')), '0 \\vee \\left[ \\right]')
		self.assertEqual (ast2tex (p ('0 or [1]')), '0 \\vee \\left[1 \\right]')
		self.assertEqual (ast2tex (p ('1 and []')), '1 \\wedge \\left[ \\right]')
		self.assertEqual (ast2tex (p ('1 and [1]')), '1 \\wedge \\left[1 \\right]')
		self.assertEqual (ast2tex (p ('not []')), '\\neg\\ \\left[ \\right]')
		self.assertEqual (ast2tex (p ('not [1]')), '\\neg\\ \\left[1 \\right]')
		self.assertEqual (ast2tex (p ('not None')), '\\neg\\ None')
		self.assertEqual (ast2tex (p ('True + True')), 'True + True')
		self.assertEqual (ast2tex (p ('False - True')), 'False - True')
		self.assertEqual (ast2tex (p ('True * True')), 'True\\ True')
		self.assertEqual (ast2tex (p ('(2 > 1) x')), '\\left(2 > 1 \\right) x')
		self.assertEqual (ast2tex (p ('(2 > 1) + (1 < 2)')), '\\left(2 > 1 \\right) + \\left(1 < 2 \\right)')
		self.assertEqual (ast2tex (p ('\\[{[a, b]},]')), '\\begin{bmatrix} \\left[a, b \\right] \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('{{a:b:c}:d}')), '\\left\\{\\left(a{:}b{:}c \\right){:} d \\right\\}')
		self.assertEqual (ast2tex (p ('{a:{b:c:d}}')), '\\left\\{a{:} \\left(b{:}c{:}d \\right) \\right\\}')
		self.assertEqual (ast2tex (p ('{a:b:c} = {a:b:c}')), '\\left(a{:}b{:}c \\right) = \\left(a{:}b{:}c \\right)')
		self.assertEqual (ast2tex (p ('\\[1:2:3]')), '\\begin{bmatrix} \\left(1{:}2{:}3 \\right) \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('-{not x}')), '-\\left(\\neg\\ x \\right)')
		self.assertEqual (ast2tex (p ('x < y in [y] in [[y]] != 2 > 1')), 'x < y \\in \\left[y \\right] \\in \\left[\\left[y \\right] \\right] \\ne 2 > 1')
		self.assertEqual (ast2tex (p ('x < y < z < w')), 'x < y < z < w')
		self.assertEqual (ast2tex (p ('\\[]')), '\\begin{bmatrix} \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[]]')), '\\begin{bmatrix} \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[], []]')), '\\begin{bmatrix} \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\{a:b}')), '\\left\\{\\left(a{:}b \\right) \\right\\}')
		self.assertEqual (ast2tex (p ('{-x} y / z')), '\\frac{-x\\ y}{z}')
		self.assertEqual (ast2tex (p ('d / dz {-1} a')), '\\frac{d}{dz}\\left(-1 a \\right)')
		self.assertEqual (ast2tex (p ('1 / {-2} x')), '\\frac{1}{-2 x}')
		self.assertEqual (ast2tex (p ('\\sum_{x=0}^b {-x} y')), '\\sum_{x = 0}^b -x\\ y')
		self.assertEqual (ast2tex (p ('\\lim_{x\\to0} {-x} y')), '\\lim_{x \\to 0} -x\\ y')
		self.assertEqual (ast2tex (p ('\\int a / -1 dx')), '\\int \\frac{a}{-1} \\ dx')
		self.assertEqual (ast2tex (p ('\\[[[x]]]')), '\\begin{bmatrix} \\left[x \\right] \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('\\[[[1, 2]], [[3]]]')), '\\begin{bmatrix} \\left[1, 2 \\right] \\\\ \\left[3 \\right] \\end{bmatrix}')
		self.assertEqual (ast2tex (p ('{1/x}.limit (x, 0, "-")')), '\\lim_{x \\to 0^-} \\frac{1}{x}')
		self.assertEqual (ast2tex (p ('{x^2y**2z}.diff (x, 2, y, z)')), '\\frac{\\partial^4}{\\partial x^2 \\partial y \\partial z}\\left(x^2 y^2 z \\right)')
		self.assertEqual (ast2tex (p ('{x y}.integrate ((x, 0, 1))')), '\\int_0^1 x\\ y \\ dx')
		self.assertEqual (ast2tex (p ('\\sqrt (a:b)')), '\\sqrt{\\left(a{:}b \\right)}')
		self.assertEqual (ast2tex (p ('\\sqrt[3] (a:b)')), '\\sqrt[3]{\\left(a{:}b \\right)}')
		self.assertEqual (ast2tex (p ('? ()')), '?\\left( \\right)')
		self.assertEqual (ast2tex (p ('? (x)')), '?\\left(x \\right)')
		self.assertEqual (ast2tex (p ('? (x) (2)')), '?\\left(x \\right) \\cdot \\left(2 \\right)')
		self.assertEqual (ast2tex (p ('? (2)')), '?\\left(2 \\right)')
		self.assertEqual (ast2tex (p ('?f (x, y, real = True)')), 'f\\left(x, y, real = True \\right)')
		self.assertEqual (ast2tex (p ('?\\alpha(x)')), '\\alpha\\left(x \\right)')
		self.assertEqual (ast2tex (p ('?beta(y)')), '?\\beta\\left(y \\right)')
		self.assertEqual (ast2tex (p ("Function ('f', real = True) (x, y)")), 'f\\left(x, y, real = True \\right)')
		self.assertEqual (ast2tex (p ("x'")), "x'")
		self.assertEqual (ast2tex (p ("x''")), "x''")
		self.assertEqual (ast2tex (p ("{x + y}'")), "\\left(x + y \\right)'")
		self.assertEqual (ast2tex (p ("a [b]'")), "a\\left[b \\right]'")
		self.assertEqual (ast2tex (p ("a.b ()'")), "a.\\operatorname{b}\\left( \\right)'")
		self.assertEqual (ast2tex (p ("{x/y}'")), "\\left(\\frac{x}{y} \\right)'")
		self.assertEqual (ast2tex (p ("1'['ac']")), "1'\\left[\\text{'ac'} \\right]")
		self.assertEqual (ast2tex (p ("|x|'")), "\\left|x \\right|'")
		self.assertEqual (ast2tex (p ("| 'str'|'")), "\\left|\\text{'str'} \\right|'")
		self.assertEqual (ast2tex (p ("{x**y}'")), "\\left(x^y \\right)'")
		self.assertEqual (ast2tex (p ("{{-1}'}")), "\\left(-1 \\right)'")
		self.assertEqual (ast2tex (p ("{a [b]}''")), "a\\left[b \\right]''")
		self.assertEqual (ast2tex (p ("1.'''")), "1.'''")
		self.assertEqual (ast2tex (p ('x [1]')), 'x\\left[1 \\right]')
		self.assertEqual (ast2tex (p ('1 [x]')), '1\\left[x \\right]')
		self.assertEqual (ast2tex (p ('[1, 2] [x]')), '\\left[1, 2 \\right]\\left[x \\right]')
		self.assertEqual (ast2tex (p ('{1, 2} [x]')), '\\left\\{1, 2 \\right\\}\\left[x \\right]')
		self.assertEqual (ast2tex (p ('{x: 2} [x]')), '\\left\\{x{:} 2 \\right\\}\\left[x \\right]')
		self.assertEqual (ast2tex (p ('{y: 2} [x]')), '\\left\\{y{:} 2 \\right\\}\\left[x \\right]')
		self.assertEqual (ast2tex (p ("'}'")), "\\text{'\\}'}")
		self.assertEqual (ast2tex (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}')), 'q\\ w\\ e\\ r\\ t\\ y\\ u\\ i\\ o\\ p\\ a\\ s\\ d\\ f')
		self.assertEqual (ast2tex (p ('x, y = 1, 2')), 'x, y = 1, 2')
		self.assertEqual (ast2tex (p ('x, 2 = 1, 2')), 'x, 2 = 1, 2')
		self.assertEqual (ast2tex (p ('(x, y) = 1, 2')), '\\left(x, y \\right) = 1, 2')
		self.assertEqual (ast2tex (p ('1; x, y = 1, 2')), '1;\\: x, y = 1, 2')
		self.assertEqual (ast2tex (p ('1; x, 2 = 1, 2')), '1;\\: x, 2 = 1, 2')
		self.assertEqual (ast2tex (p ('1; (x, y) = 1, 2')), '1;\\: \\left(x, y \\right) = 1, 2')
		self.assertEqual (ast2tex (p ('f()()')), 'f\\left( \\right) \\cdot \\left( \\right)')
		self.assertEqual (ast2tex (p ('f()*()')), 'f\\left( \\right) \\cdot \\left( \\right)')
		self.assertEqual (ast2tex (p ('f*()*()')), 'f \\cdot \\left( \\right) \\cdot \\left( \\right)')
		self.assertEqual (ast2tex (p ('f*()()')), 'f \\cdot \\left( \\right) \\left( \\right)')

		self.assertEqual (ast2tex (p ('dy / dx')), '\\frac{dy}{dx}')
		self.assertEqual (ast2tex (p ('dy / dx z')), '\\frac{dy}{dx} \\cdot z')
		self.assertEqual (ast2tex (p ('d**2 y / dx**2')), '\\frac{d^2 y}{dx^2}')
		self.assertEqual (ast2tex (p ('d**2 y / dx**2 z')), '\\frac{d^2 y}{dx^2} \\cdot z')
		self.assertEqual (ast2tex (p ('d**2 y / dx dy')), '\\frac{\\partial^2 y}{\\partial x \\partial y}')
		self.assertEqual (ast2tex (p ('d**2 y / dx dy z')), '\\frac{\\partial^2 y}{\\partial x \\partial y} \\cdot z')
		self.assertEqual (ast2tex (p ('\\frac{dy}{dx}')), '\\frac{dy}{dx}')
		self.assertEqual (ast2tex (p ('\\frac{dy}{dx} z')), '\\frac{dy}{dx} \\cdot z')
		self.assertEqual (ast2tex (p ('\\frac{d**2}{dx**2}')), '\\frac{\\left(d^2 \\right)}{dx^2}')
		self.assertEqual (ast2tex (p ('\\frac{d**2}{dx**2} z')), '\\frac{d^2 z}{dx^2}')
		self.assertEqual (ast2tex (p ('\\frac{d**2}{dx dy}')), '\\frac{\\left(d^2 \\right)}{dx\\ dy}')
		self.assertEqual (ast2tex (p ('\\frac{d**2}{dx dy} z')), '\\frac{\\partial^2 z}{\\partial x \\partial y}')
		self.assertEqual (ast2tex (p ('\\frac{d**2 y}{dx dy}')), '\\frac{\\partial^2 y}{\\partial x \\partial y}')
		self.assertEqual (ast2tex (p ('\\frac{d**2 y}{dx dy} z')), '\\frac{\\partial^2 y}{\\partial x \\partial y} \\cdot z')
		self.assertEqual (ast2tex (p ('\\int dy / dx')), '\\int {\\frac{dy}{dx}} \\ {}')
		self.assertEqual (ast2tex (p ('\\int d/dx x**2 dx')), '\\int {\\frac{d}{dx}\\left(x^2 \\right)} \\ dx')
		self.assertEqual (ast2tex (p ('\\int d/dx y(x) dx')), '\\int {\\frac{d}{dx}\\left(y\\left(x \\right) \\right)} \\ dx')
		self.assertEqual (ast2tex (p ('\\int dx dx dx')), '{\\int \\ dx} \\cdot dx\\ dx')
		self.assertEqual (ast2tex (p ('\\int dx * dx dx')), '{\\int \\ dx} \\cdot dx\\ dx')
		self.assertEqual (ast2tex (p ('dlambda / dx : x')), '\\frac{d\\lambda}{dx}{:}x')
		self.assertEqual (ast2tex (p ('d**2 lambda / dx**2 : x')), '\\frac{d^2 \\lambda}{dx^2}{:}x')
		self.assertEqual (ast2tex (p ('ln1.or')), 'ln_{1}.or')
		self.assertRaises (AttributeError, ast2tex, p ('ln1. or'))
		self.assertRaises (AttributeError, ast2tex, p ('ln1 . or'))
		self.assertEqual (ast2tex (p ('a.b * c.d')), 'a.b\\ c.d')
		self.assertEqual (ast2tex (p ('a.b c.d')), 'a.b\\ c.d')
		self.assertEqual (ast2tex (p ('lambda x, y, z: ln lambda x:')), '\\lambda\\ x, y, z{:}\\ln{\\left(\\lambda \\right)} x{:}')
		self.assertEqual (ast2tex (p ('lambda x, y, z: ln lambda x: 1')), '\\left(\\left(x, y, z \\right) \\mapsto \\ln{\\left(\\left(x \\mapsto 1 \\right) \\right)} \\right)')

		self.assertEqual (ast2tex (p ('f (x) (0)')), 'f\\left(x \\right) \\cdot \\left(0 \\right)')
		self.assertEqual (ast2tex (p ('f (x, y) (0, 0)')), 'f\\left(x, y \\right) \\cdot \\left(0, 0 \\right)')
		self.assertEqual (ast2tex (p ('f (x, y, z) (0, 0, 0)')), 'f\\left(x, y, z \\right) \\cdot \\left(0, 0, 0 \\right)')
		self.assertEqual (ast2tex (p ("f (x)' (0)")), "f\\left(x \\right)'\\left(0 \\right)")
		self.assertEqual (ast2tex (p ('\\. x+y |_{x = 1}')), '\\left. x + y \\right|_{x = 1}')
		self.assertEqual (ast2tex (p ('\\. x+y |_{x = 1, y = 2}')), '\\left. x + y \\right|_{\\substack{x = 1 \\\\ y = 2}}')
		self.assertEqual (ast2tex (p ('\\. x+y |_{x, y = 1, 2}')), '\\left. x + y \\right|_{\\substack{x = 1 \\\\ y = 2}}')
		self.assertEqual (ast2tex (p ('\\. x+y |_{\\substack{x = 1}}')), '\\left. x + y \\right|_{x = 1}')
		self.assertEqual (ast2tex (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}')), '\\left. x + y \\right|_{\\substack{x = 1 \\\\ y = 2}}')
		self.assertEqual (ast2tex (p ('\\. f(x) |_{f(x) = y}')), '\\left. f\\left(x \\right) \\right|_{f\\left(x \\right) = y}')
		self.assertEqual (ast2tex (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}')), '\\left. f\\left(x \\right) f\\left(y \\right) \\right|_{\\substack{f\\left(x \\right) = y \\\\ f\\left(y \\right) = z}}')
		self.assertEqual (ast2tex (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}')), '\\left. f\\left(x \\right) f\\left(y \\right) \\right|_{\\substack{f\\left(x \\right) = y \\\\ f\\left(y \\right) = z}}')
		self.assertEqual (ast2tex (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}')), '\\left. f\\left(x \\right) f\\left(y \\right) \\right|_{\\substack{f\\left(x \\right) = y \\\\ f\\left(y \\right) = z}}')
		self.assertEqual (ast2tex (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}')), '\\left. \\left(\\left(1, 2 \\right) + \\left(1, 2 \\right) \\right) \\right|_{\\left(1, 2, 1, 2 \\right) = \\left(3, 4 \\right)}')

		self.assertEqual (ast2tex (p ("f (x)' (0)")), "f\\left(x \\right)'\\left(0 \\right)")
		self.assertEqual (ast2tex (p ('d / dx (f (x)) (0)')), '\\frac{d}{dx}\\left(f\\left(x \\right) \\right)\\left(0 \\right)')
		self.assertEqual (ast2tex (p ('d / dx (u (x, y)) (x, y)')), '\\frac{\\partial}{\\partial x}\\left(u\\left(x, y \\right) \\right)')
		self.assertEqual (ast2tex (p ('d / dx (u (x, y)) (0, y)')), '\\frac{\\partial}{\\partial x}\\left(u\\left(x, y \\right) \\right)\\left(0, y \\right)')
		self.assertEqual (ast2tex (p ('d / dx (u (x, y)) (0, 0)')), '\\frac{\\partial}{\\partial x}\\left(u\\left(x, y \\right) \\right)\\left(0, 0 \\right)')
		self.assertEqual (ast2tex (p ('d**2 / dx dy (u (x, y)) (x, y)')), '\\frac{\\partial^2}{\\partial x \\partial y}\\left(u\\left(x, y \\right) \\right)')
		self.assertEqual (ast2tex (p ('d**2 / dx dy (u (x, y)) (0, y)')), '\\frac{\\partial^2}{\\partial x \\partial y}\\left(u\\left(x, y \\right) \\right)\\left(0, y \\right)')
		self.assertEqual (ast2tex (p ('d**2 / dx dy (u (x, y)) (0, 0)')), '\\frac{\\partial^2}{\\partial x \\partial y}\\left(u\\left(x, y \\right) \\right)\\left(0, 0 \\right)')
		self.assertEqual (ast2tex (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})")), "\\operatorname{dsolve}{\\left(y\\left(x \\right)'' + 11 y\\left(x \\right)' + 24 y\\left(x \\right), ics = \\left\\{y\\left(0 \\right){:} 0, y\\left(x \\right)'\\left(0 \\right){:} -7 \\right\\} \\right)}")
		self.assertEqual (ast2tex (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}")), "\\left. \\left[f\\left(x \\right)', g\\left(y \\right)' \\right] \\right|_{\\substack{x = 0 \\\\ y = 1}}")
		self.assertEqual (ast2tex (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')), '\\left. \\left[\\frac{\\partial}{\\partial x}\\left(f\\left(x, y \\right) \\right), \\frac{\\partial}{\\partial x}\\left(g\\left(y, x \\right) \\right) \\right] \\right|_{\\substack{x = 0 \\\\ y = 1}}')
		self.assertEqual (ast2tex (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')), '\\left. \\frac{\\partial^2}{\\partial x \\partial y}\\left(f\\left(x, z \\right) \\right) \\right|_{\\substack{x = 1 \\\\ y = 2 \\\\ z = 3}}')
		self.assertEqual (ast2tex (p ('?() = 2')), '?\\left( \\right) = 2')
		self.assertEqual (ast2tex (p ('?f() = 2')), '?f\\left( \\right) = 2')
		self.assertEqual (ast2tex (p ('d / dx (a) b')), '\\frac{d}{dx}\\left(a \\right) \\cdot b')
		self.assertEqual (ast2tex (p ('\\frac{d}{dx} (a) b')), '\\frac{d}{dx}\\left(a \\right) \\cdot b')
		self.assertEqual (ast2tex (p ('sin (())')), '\\sin{\\left(\\left( \\right) \\right)}')
		self.assertEqual (ast2tex (p ('sin (((a))')), '\\sin{\\left(\\left(\\left(a \\right) \\right) \\right)}')
		self.assertEqual (ast2tex (p ('a.b (())')), 'a.\\operatorname{b}\\left(\\left( \\right) \\right)')
		self.assertEqual (ast2tex (p ('a.b (((a))')), 'a.\\operatorname{b}\\left(\\left(\\left(a \\right) \\right) \\right)')
		self.assertEqual (ast2tex (p ('@x')), '@x')
		self.assertEqual (ast2tex (p ('@(x + y)')), '@{\\left(x + y \\right)}')
		self.assertEqual (ast2tex (p ('@(x + y)')), '@{\\left(x + y \\right)}')
		self.assertEqual (ast2tex (p ('%x')), '\\%x')
		self.assertEqual (ast2tex (p ('%(x + y)')), '\\%{\\left(x + y \\right)}')
		self.assertEqual (ast2tex (p ('%%x')), '\\%\\%x')
		self.assertEqual (ast2tex (p ('%%(x + y)')), '\\%\\%{\\left(x + y \\right)}')
		self.assertEqual (ast2tex (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]')), '\\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}\\left[{:}, 1{:} \\right]')

		self.assertEqual (ast2tex (p ('N - N N 2')), 'N - \\operatorname{N}{\\left(\\operatorname{N}{\\left(2 \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('N N N 2')), '\\operatorname{N}{\\left(\\operatorname{N}{\\left(\\operatorname{N}{\\left(2 \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin sin sin 2')), '\\sin{\\left(\\sin{\\left(\\sin{\\left(2 \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('-N sin -N 2')), '-\\operatorname{N}{\\left(\\sin{\\left(-\\operatorname{N}{\\left(2 \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin -N sin 2')), '\\sin{\\left(-\\operatorname{N}{\\left(\\sin{\\left(2 \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('N N sin -a [2]')), '\\operatorname{N}{\\left(\\operatorname{N}{\\left(\\sin{\\left(-a\\left[2 \\right] \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('N N sin -a.b [2]')), '\\operatorname{N}{\\left(\\operatorname{N}{\\left(\\sin{\\left(-a.b\\left[2 \\right] \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('N N sin -a.b () [2]')), '\\operatorname{N}{\\left(\\operatorname{N}{\\left(\\sin{\\left(-a.\\operatorname{b}\\left( \\right)\\left[2 \\right] \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('N N sin -a.b () [2] [3]')), '\\operatorname{N}{\\left(\\operatorname{N}{\\left(\\sin{\\left(-a.\\operatorname{b}\\left( \\right)\\left[2 \\right]\\left[3 \\right] \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin -N () [2] [3].c [4].d () [5]')), '\\sin{\\left(-\\operatorname{N}{\\left( \\right)}\\left[2 \\right]\\left[3 \\right].c\\left[4 \\right].\\operatorname{d}\\left( \\right)\\left[5 \\right] \\right)}')
		self.assertEqual (ast2tex (p ('sqrt -N () [2] [3].c [4].d () [5]')), '\\sqrt{-\\operatorname{N}{\\left( \\right)}\\left[2 \\right]\\left[3 \\right].c\\left[4 \\right].\\operatorname{d}\\left( \\right)\\left[5 \\right]}')
		self.assertEqual (ast2tex (p ('sqrt[3] -N () [2] [3].c [4].d () [5]')), '\\sqrt[3]{-\\operatorname{N}{\\left( \\right)}\\left[2 \\right]\\left[3 \\right].c\\left[4 \\right].\\operatorname{d}\\left( \\right)\\left[5 \\right]}')
		self.assertEqual (ast2tex (p ('log -N () [2] [3].c [4].d () [5]')), '\\ln{\\left(-\\operatorname{N}{\\left( \\right)}\\left[2 \\right]\\left[3 \\right].c\\left[4 \\right].\\operatorname{d}\\left( \\right)\\left[5 \\right] \\right)}')
		self.assertEqual (ast2tex (p ('\\log_2 -N () [2] [3].c [4].d () [5]')), '\\log_2{\\left(-\\operatorname{N}{\\left( \\right)}\\left[2 \\right]\\left[3 \\right].c\\left[4 \\right].\\operatorname{d}\\left( \\right)\\left[5 \\right] \\right)}')
		self.assertEqual (ast2tex (p ('N sin**2 ln**2 N x')), '\\operatorname{N}{\\left(\\sin^2{\\left(\\ln{\\left(\\operatorname{N}{\\left(x \\right)} \\right)}^2 \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin ln N x')), '\\sin{\\left(\\ln{\\left(\\operatorname{N}{\\left(x \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin(a)**[a][b].c')), '\\sin{\\left(a \\right)}^{\\left[a \\right]\\left[b \\right].c}')
		self.assertEqual (ast2tex (p ('N sin N sin x')), '\\operatorname{N}{\\left(\\sin{\\left(\\operatorname{N}{\\left(\\sin{\\left(x \\right)} \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('cos**-1 0 \\log_2 8')), '\\cos^{-1}{\\left(0 \\right)} \\log_2{\\left(8 \\right)}')
		self.assertEqual (ast2tex (p ('N sin sqrt[3] \\log_2 8')), '\\operatorname{N}{\\left(\\sin{\\left(\\sqrt[3]{\\log_2{\\left(8 \\right)}} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin(x)**-a[b][c].d')), '\\sin{\\left(x \\right)}^{-a\\left[b \\right]\\left[c \\right].d}')
		self.assertEqual (ast2tex (p ('sin sin x [2].w')), '\\sin{\\left(\\sin{\\left(x\\left[2 \\right].w \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin -sin x [2].w')), '\\sin{\\left(-\\sin{\\left(x\\left[2 \\right].w \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin sin (x) [2].w')), '\\sin{\\left(\\sin{\\left(x \\right)}\\left[2 \\right].w \\right)}')
		self.assertEqual (ast2tex (p ('sin -sin (x) [2].w')), '\\sin{\\left(-\\sin{\\left(x \\right)}\\left[2 \\right].w \\right)}')
		self.assertEqual (ast2tex (p ('sin sin x [2].w ()')), '\\sin{\\left(\\sin{\\left(x\\left[2 \\right].\\operatorname{w}\\left( \\right) \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('ln ln x [2].w')), '\\ln{\\left(\\ln{\\left(x\\left[2 \\right].w \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('N N sin -a [2]')), '\\operatorname{N}{\\left(\\operatorname{N}{\\left(\\sin{\\left(-a\\left[2 \\right] \\right)} \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin sin -x [2].w')), '\\sin{\\left(\\sin{\\left(-x\\left[2 \\right].w \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin -sin x [2].w')), '\\sin{\\left(-\\sin{\\left(x\\left[2 \\right].w \\right)} \\right)}')
		self.assertEqual (ast2tex (p ('sin(a)**b[2]')), '\\sin{\\left(a \\right)}^{b\\left[2 \\right]}')
		self.assertEqual (ast2tex (p ('sin**-a[b][c].d x')), '\\sin{\\left(x \\right)}^{-a\\left[b \\right]\\left[c \\right].d}')
		self.assertEqual (ast2tex (p ('sin**-a[b][c].d (x)')), 'sin^{-a\\left[b \\right]\\left[c \\right].\\operatorname{d}\\left(x \\right)}')
		self.assertEqual (ast2tex (p ('sin**-a[b][c].d {(x)}')), '\\sin{\\left(x \\right)}^{-a\\left[b \\right]\\left[c \\right].d}')
		self.assertEqual (ast2tex (p ('sin**-a[b][c] (x)')), '\\sin{\\left(x \\right)}^{-a\\left[b \\right]\\left[c \\right]}')
		self.assertEqual (ast2tex (p ('\\int**-a[b][c] x')), '\\int_0^{-a\\left[b \\right]\\left[c \\right]} x \\ {}')
		self.assertEqual (ast2tex (p ('\\int**-a[b][c].d (x)')), '\\int_0^{-a\\left[b \\right]\\left[c \\right].\\operatorname{d}\\left(x \\right)} \\ {}')
		self.assertEqual (ast2tex (p ('\\int**-a[b][c].d {(x)}')), '\\int_0^{-a\\left[b \\right]\\left[c \\right].d} \\left(x \\right) \\ {}')
		self.assertEqual (ast2tex (p ('\\int**-a[b][c].d (x) y')), '\\int_0^{-a\\left[b \\right]\\left[c \\right].\\operatorname{d}\\left(x \\right)} y \\ {}')
		self.assertEqual (ast2tex (p ('\\int**-a[b][c].d {(x)} y')), '\\int_0^{-a\\left[b \\right]\\left[c \\right].d} \\left(x \\right) y \\ {}')
		self.assertEqual (ast2tex (p ('\\int**a.b[2] x dx')), '\\int_0^{a.b\\left[2 \\right]} x \\ dx')

		self.assertEqual (ast2tex (p ('d/dx (real = True)')), '\\frac{d}{dx}\\left(real = True \\right)')
		self.assertEqual (ast2tex (p ('f {\\left(x\\right)}')), 'f\\left(x \\right)')
		self.assertEqual (ast2tex (p ('a.b {(x)}')), '{a.b}\\left(x \\right)')
		self.assertEqual (ast2tex (p ('a.b {\\left(x\\right)}')), 'a.\\operatorname{b}\\left(x \\right)')
		self.assertEqual (ast2tex (p ('\\log_{|x|} y')), '\\log_{\\left|x \\right|}{\\left(y \\right)}')
		self.assertEqual (ast2tex (p ('|\\int a + b dx|')), '\\left|\\int a + b \\ dx \\right|')
		self.assertEqual (ast2tex (p ('\\int deg N dx')), '\\int \\deg{\\left(N \\right)} \\ dx')
		self.assertEqual (ast2tex (p ('a \\int x dx / c')), '\\frac{a \\int x \\ dx}{c}')
		self.assertEqual (ast2tex (p ('\\int x dx b / c')), '\\frac{{\\int x \\ dx} \\cdot b}{c}')
		self.assertEqual (ast2tex (p ('a \\int x dx b / c')), '\\frac{a {\\int x \\ dx} \\cdot b}{c}')
		self.assertEqual (ast2tex (p ('a {\\lim_{x\\to0} \\int x dx} / b')), '\\frac{a \\lim_{x \\to 0} \\int x \\ dx}{b}')
		self.assertEqual (ast2tex (p ('a {\\sum_{x=0}^1 \\int x dx} / b')), '\\frac{a \\sum_{x = 0}^1 \\int x \\ dx}{b}')
		self.assertEqual (ast2tex (p ('a / \\int x dx * c')), '\\frac{a}{\\int x \\ dx} c')
		self.assertEqual (ast2tex (p ('a / b \\int x dx * c')), '\\frac{a}{b \\int x \\ dx} c')

		self.assertEqual (ast2tex (p ('cos')), 'cos')
		self.assertEqual (ast2tex (p ('f = cos')), 'f = cos')
		self.assertEqual (ast2tex (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)')), '\\begin{bmatrix} 0 & \\pi \\\\ -\\pi & 0 \\end{bmatrix}.\\operatorname{applyfunc}\\left(cos \\right)')
		self.assertEqual (ast2tex (p ('$sin (real = True)')), '\\$sin\\left(real = True \\right)')
		self.assertEqual (ast2tex (p ('sin = $(real = True)')), 'sin = \\$\\left(real = True \\right)')

	def test_ast2nat (self):
		self.assertEqual (ast2nat (p ('1')), '1')
		self.assertEqual (ast2nat (p ('1.')), '1.')
		self.assertEqual (ast2nat (p ('.1')), '0.1')
		self.assertEqual (ast2nat (p ('1e20')), '1e+20')
		self.assertEqual (ast2nat (p ('1E-20')), '1e-20')
		self.assertEqual (ast2nat (p ('1.e+20')), '1.e+20')
		self.assertEqual (ast2nat (p ('.1e-20')), '0.1e-20')
		self.assertEqual (ast2nat (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')), 'sin(-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')
		self.assertEqual (ast2nat (p ('x')), 'x')
		self.assertEqual (ast2nat (p ('xy')), 'xy')
		self.assertEqual (ast2nat (p ('dx')), 'dx')
		self.assertEqual (ast2nat (p ('partialx')), 'partialx')
		self.assertEqual (ast2nat (p ('\\partial x')), 'partialx')
		self.assertEqual (ast2nat (p ('x d  y')), 'x d y')
		self.assertEqual (ast2nat (p ('x partial y')), 'x partial y')
		self.assertEqual (ast2nat (p ('x \\partial  y')), 'x partial y')
		self.assertEqual (ast2nat (p ('x dx dy y')), 'x dx dy y')
		self.assertEqual (ast2nat (p ('x partialx partialy y')), 'x partialx partialy y')
		self.assertEqual (ast2nat (p ('-1')), '-1')
		self.assertEqual (ast2nat (p ('-x')), '-x')
		self.assertEqual (ast2nat (p ('{x}')), 'x')
		self.assertEqual (ast2nat (p ('()')), '()')
		self.assertEqual (ast2nat (p ('(x)')), '(x)')
		self.assertEqual (ast2nat (p ('(x,)')), '(x,)')
		self.assertEqual (ast2nat (p ('(x,y)')), '(x, y)')
		self.assertEqual (ast2nat (p ('(x,y,)')), '(x, y)')
		self.assertEqual (ast2nat (p ('[]')), '[]')
		self.assertEqual (ast2nat (p ('[x]')), '[x]')
		self.assertEqual (ast2nat (p ('[x,]')), '[x]')
		self.assertEqual (ast2nat (p ('[x,y]')), '[x, y]')
		self.assertEqual (ast2nat (p ('[x,y,]')), '[x, y]')
		self.assertEqual (ast2nat (p ('"x\\x20\\n"')), " 'x \\n'")
		self.assertEqual (ast2nat (p ("'x\\x20\\n'")), " 'x \\n'")
		self.assertEqual (ast2nat (p ('|x|')), '{|x|}')
		self.assertEqual (ast2nat (p ('x!')), 'x!')
		self.assertEqual (ast2nat (p ('x+y')), 'x + y')
		self.assertEqual (ast2nat (p ('x-y')), 'x - y')
		self.assertEqual (ast2nat (p ('x*y')), 'x y')
		self.assertEqual (ast2nat (p ('x y')), 'x y')
		self.assertEqual (ast2nat (p ('x(y)')), 'x(y)')
		self.assertEqual (ast2nat (p ('x*(y)')), 'x * (y)')
		self.assertEqual (ast2nat (p ('x/y')), 'x/y')
		self.assertEqual (ast2nat (p ('x^y')), 'x**y')
		self.assertEqual (ast2nat (p ('log x')), 'ln(x)')
		self.assertEqual (ast2nat (p ('log {x}')), 'ln(x)')
		self.assertEqual (ast2nat (p ('log (x)')), 'ln(x)')
		self.assertEqual (ast2nat (p ('\\log_2 x')), '\\log_2(x)')
		self.assertEqual (ast2nat (p ('\\log_2 {x}')), '\\log_2(x)')
		self.assertEqual (ast2nat (p ('\\log_2 (x)')), '\\log_2(x)')
		self.assertEqual (ast2nat (p ('sqrt x')), 'sqrt(x)')
		self.assertEqual (ast2nat (p ('sqrt {x}')), 'sqrt(x)')
		self.assertEqual (ast2nat (p ('sqrt (x)')), 'sqrt(x)')
		self.assertEqual (ast2nat (p ('sqrt {(x)}')), 'sqrt(x)')
		self.assertEqual (ast2nat (p ('sqrt[3] x')), 'sqrt[3](x)')
		self.assertEqual (ast2nat (p ('sqrt[3] {x}')), 'sqrt[3](x)')
		self.assertEqual (ast2nat (p ('sqrt[3] {(x)}')), 'sqrt[3](x)')
		self.assertEqual (ast2nat (p ('sqrt[3] (x)')), 'sqrt[3](x)')
		self.assertEqual (ast2nat (p ('sin x')), 'sin(x)')
		self.assertEqual (ast2nat (p ('sin^2 x')), 'sin**2(x)')
		self.assertEqual (ast2nat (p ('sin (x)')), 'sin(x)')
		self.assertEqual (ast2nat (p ('sin (x)^2')), 'sin**2(x)')
		self.assertEqual (ast2nat (p ('sin {x}')), 'sin(x)')
		self.assertEqual (ast2nat (p ('sin {(x)}')), 'sin(x)')
		self.assertEqual (ast2nat (p ('{sin x}^2')), 'sin**2(x)')
		self.assertEqual (ast2nat (p ('sin**2 x')), 'sin**2(x)')
		self.assertEqual (ast2nat (p ('sin**-1 x')), 'asin(x)')
		self.assertEqual (ast2nat (p ('sin(x)**-1')), 'sin(x)**-1')
		self.assertEqual (ast2nat (p ('acos (x)')), 'acos(x)')
		self.assertEqual (ast2nat (p ('\\arccos (x)')), 'acos(x)')
		self.assertEqual (ast2nat (p ('sin(x**2)')), 'sin(x**2)')
		self.assertEqual (ast2nat (p ('sin(x**2)**2')), 'sin**2(x**2)')
		self.assertEqual (ast2nat (p ('(sin(x**2)**2)')), '(sin**2(x**2))')
		self.assertEqual (ast2nat (p ('ln(x**2)')), 'ln(x**2)')
		self.assertEqual (ast2nat (p ('ln(x**2)**2')), '(ln(x**2))**2')
		self.assertEqual (ast2nat (p ('(ln(x**2)**2)')), '((ln(x**2))**2)')
		self.assertEqual (ast2nat (p ('gamma(x**2)')), 'gamma(x**2)')
		self.assertEqual (ast2nat (p ('gamma(x**2)**2')), 'gamma(x**2)**2')
		self.assertEqual (ast2nat (p ('(gamma(x**2)**2)')), '(gamma(x**2)**2)')
		self.assertEqual (ast2nat (p ('{gamma}[2]')), '{gamma}[2]')
		self.assertEqual (ast2nat (p ('{Gamma}[2]')), '{Gamma}[2]')
		self.assertEqual (ast2nat (p ('f{(x)}')), 'f * (x)')
		self.assertEqual (ast2nat (p ("f{(x)}'(0)")), "f * (x)' (0)")
		self.assertEqual (ast2nat (p ("f{(x)}'{(0)}")), "f * (x)' (0)")
		self.assertEqual (ast2nat (p ('\\operatorname{x_{1}}{\\left(x \\right)}')), 'x1(x)')
		self.assertEqual (ast2nat (p ('\\lim_{x\\to0} 1/x')), '\\lim_{x \\to 0} 1/x')
		self.assertEqual (ast2nat (p ('\\lim_{x\\to0^+} 1/x')), '\\lim_{x \\to 0**+} 1/x')
		self.assertEqual (ast2nat (p ('\\lim_{x\\to0**-} 1/x')), '\\lim_{x \\to 0**-} 1/x')
		self.assertEqual (ast2nat (p ('Limit (1/x, x, 0)')), '\\lim_{x \\to 0**+} 1/x')
		self.assertEqual (ast2nat (p ('Limit (1/x, x, 0, "-")')), '\\lim_{x \\to 0**-} 1/x')
		self.assertEqual (ast2nat (p ('Limit (1/x, x, 0, dir="+-")')), '\\lim_{x \\to 0} 1/x')
		self.assertEqual (ast2nat (p ('limit (1/x, x, 0)')), '\\lim_{x \\to 0**+} 1/x')
		self.assertEqual (ast2nat (p ('limit (1/x, x, 0, "-")')), '\\lim_{x \\to 0**-} 1/x')
		self.assertEqual (ast2nat (p ('limit (1/x, x, 0, dir="+-")')), '\\lim_{x \\to 0} 1/x')
		self.assertEqual (ast2nat (p ('\\sum_{n=0}^\\infty x^n/n!')), '\\sum_{n = 0}^{oo} x**n / n!')
		self.assertEqual (ast2nat (p ('Sum (x^n/n!, (n, 0, oo))')), '\\sum_{n = 0}^{oo} x**n / n!')
		self.assertEqual (ast2nat (p ('summation (x^n/n!, (n, 0, oo))')), 'summation(x**n / n!, (n, 0, oo))')
		self.assertEqual (ast2nat (p ('d/dx x**2y**2z')), 'd / dx (x**2 y**2 z)')
		self.assertEqual (ast2nat (p ('d^2/dx^2 x^2y**2z')), 'd**2 / dx**2 (x**2 y**2 z)')
		self.assertEqual (ast2nat (p ('d^3/dx^2dy x^2y**2z')), 'd**3 / dx**2 dy (x**2 y**2 z)')
		self.assertEqual (ast2nat (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z')), 'partial**4 / partialx**2 partialy partialz (x**2 y**2 z)')
		self.assertEqual (ast2nat (p ('d**1.5 / dx dy x**2y**2')), 'd**1.5 / dx dy x**2 y**2')
		self.assertEqual (ast2nat (p ('d**-2 / dx dy x**2y**2')), 'd**-2 / dx dy x**2 y**2')
		self.assertEqual (ast2nat (p ('d**2 / dx**1.5 x**2y**2')), '(d**2) / dx**1.5 x**2 y**2')
		self.assertEqual (ast2nat (p ('Derivative (x^2y**2z, x, 2, y, z)')), 'd**4 / dx**2 dy dz (x**2 y**2 z)')
		self.assertEqual (ast2nat (p ('diff (x^2y**2z, x, 2, y, z)')), 'diff(x**2 y**2 z, x, 2, y, z)')
		self.assertEqual (ast2nat (p ('\\int dx')), '\\int dx')
		self.assertEqual (ast2nat (p ('\\int x dx')), '\\int x dx')
		self.assertEqual (ast2nat (p ('\\int_0^1 x dx')), '\\int_0^1 x dx')
		self.assertEqual (ast2nat (p ('\\int_0^1 \\int y dy dx')), '\\int_0^1 \\int y dy dx')
		self.assertEqual (ast2nat (p ('Integral (\\int y dy, (x, 0, 1))')), '\\int_0^1 \\int y dy dx')
		self.assertEqual (ast2nat (p ('integrate (\\int y dy, (x, 0, 1))')), 'integrate(\\int y dy, (x, 0, 1))')

		self.assertEqual (ast2nat (p ('\\[1,]')), '\\[1]')
		self.assertEqual (ast2nat (p ('\\[1,2]')), '\\[1, 2]')
		self.assertEqual (ast2nat (p ('\\[1,2,]')), '\\[1, 2]')
		self.assertEqual (ast2nat (p ('\\[[1,],]')), '\\[1]')
		self.assertEqual (ast2nat (p ('\\[[1,],[2,]]')), '\\[1, 2]')
		self.assertEqual (ast2nat (p ('\\[[1,],[2,],]')), '\\[1, 2]')
		self.assertEqual (ast2nat (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]')), '\\[1]')
		self.assertEqual (ast2nat (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}')), '\\[1]')
		self.assertEqual (ast2nat (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}')), '\\[[1, 2]]')
		self.assertEqual (ast2nat (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}')), '\\[[1, 2], [3, 4]]')
		self.assertEqual (ast2nat (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}')), '\\[[1, 2], [3, 4]]')
		self.assertEqual (ast2nat (p ('\\[1,2]!')), '\\[1, 2]!')
		self.assertEqual (ast2nat (p ('\\[[0,1],[1,0]]**x')), '\\[[0, 1], [1, 0]]**x')
		self.assertEqual (ast2nat (p ('\\[[1,2],[3,4]]!')), '\\[[1, 2], [3, 4]]!')
		self.assertEqual (ast2nat (p ('\\[[1,2,3],[4,5,6]].T')), '\\[[1, 2, 3], [4, 5, 6]].T')
		self.assertEqual (ast2nat (p ('\\[[1,2,3],[4,5,6]].T.T')), '\\[[1, 2, 3], [4, 5, 6]].T.T')
		self.assertEqual (ast2nat (p ('\\[[1,2,3],[4,5,6]].T.T.T')), '\\[[1, 2, 3], [4, 5, 6]].T.T.T')
		self.assertEqual (ast2nat (p ('\\[[1,2,3],[4,5,6]].transpose ()')), '\\[[1, 2, 3], [4, 5, 6]].transpose()')
		self.assertEqual (ast2nat (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()')), '\\[[1, 2, 3], [4, 5, 6]].transpose().transpose()')
		self.assertEqual (ast2nat (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()')), '\\[[1, 2, 3], [4, 5, 6]].transpose().transpose().transpose()')
		self.assertEqual (ast2nat (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()')), '\\[[1, 2, 3], [4, 5, 6]].transpose().transpose().T.T.transpose().transpose()')
		self.assertEqual (ast2nat (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]')), '\\[[A, B], [C, D]] \\[x, y]')
		self.assertEqual (ast2nat (p ('\\[[1, 2], [3')), '\\[[1, 2], [3, ]]')
		self.assertEqual (ast2nat (p ('\\[[1, 2], [3]]')), '\\[[1, 2], [3, ]]')
		self.assertEqual (ast2nat (p ('\\[[1], [2, 3]]')), '\\[[1, ], [2, 3]]')

		self.assertEqual (ast2nat (p ('-1**x')), '-1**x')
		self.assertEqual (ast2nat (p ('{-1}**x')), '(-1)**x')
		self.assertEqual (ast2nat (p ('-{-1}**x')), '-(-1)**x')
		self.assertEqual (ast2nat (p ('(-1)**x')), '(-1)**x')
		self.assertEqual (ast2nat (p ('-(-1)**x')), '-(-1)**x')
		self.assertEqual (ast2nat (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')), 'alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')
		self.assertEqual (ast2nat (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')), 'alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')
		self.assertEqual (ast2nat (p ('1 if x < y')), '1 if x < y')
		self.assertEqual (ast2nat (p ('1 if x < y else 3')), '1 if x < y else 3')
		self.assertEqual (ast2nat (p ('1 if x < y else 3 if x < z')), '1 if x < y else 3 if x < z')
		self.assertEqual (ast2nat (p ('1 if x < y else 3 if x < z else 5')), '1 if x < y else 3 if x < z else 5')
		self.assertEqual (ast2nat (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}')), '1 if x < y else 3 if x < z else 5')
		self.assertEqual (ast2nat (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}')), '1 if x < y else 3 if x < z else 5')
		self.assertEqual (ast2nat (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}')), '1 if x < y else 3 if x < z else 5 if x < w')
		self.assertEqual (ast2nat (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}')), '1 if x < y else 3 if x < z else 5 if x < w')
		self.assertEqual (ast2nat (p ('x**y.a')), 'x**y.a')
		self.assertEqual (ast2nat (p ('x**y.a ()')), 'x**y.a()')
		self.assertEqual (ast2nat (p ('x**y.a.b')), 'x**y.a.b')
		self.assertEqual (ast2nat (p ('x**y.a.b ()')), 'x**y.a.b()')
		self.assertEqual (ast2nat (p ('x**y.a ().b')), 'x**y.a().b')
		self.assertEqual (ast2nat (p ('x**y.a ().b ()')), 'x**y.a().b()')
		self.assertEqual (ast2nat (p ('{1 if x < 0 else 3} if x < 1 else 5')), '{1 if x < 0 else 3} if x < 1 else 5')
		self.assertEqual (ast2nat (p ('1 if {True if x < 0 else False} else 5')), '1 if {True if x < 0 else False} else 5')
		self.assertEqual (ast2nat (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}')), '1 if {True if x < 0 else False} else {7 if x < 1 else 5}')
		self.assertEqual (ast2nat (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')), '{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')
		self.assertEqual (ast2nat (p ('x.y!')), 'x.y!')
		self.assertEqual (ast2nat (p ('x.y**2')), 'x.y**2')
		self.assertEqual (ast2nat (p ('x.y ()!')), 'x.y()!')
		self.assertEqual (ast2nat (p ('x.y ()**2')), 'x.y()**2')
		self.assertEqual (ast2nat (p ('x**y.a!')), 'x**y.a!')
		self.assertEqual (ast2nat (p ('x**y.a**2')), 'x**y.a**2')
		self.assertEqual (ast2nat (p ('x**y.a ()!')), 'x**y.a()!')
		self.assertEqual (ast2nat (p ('x**y.a ()**2')), 'x**y.a()**2')
		self.assertEqual (ast2nat (p ('lambda: x')), 'lambda: x')
		self.assertEqual (ast2nat (p ('lambda x: x**2')), 'lambda x: x**2')
		self.assertEqual (ast2nat (p ('lambda x, y: x + y')), 'lambda x, y: x + y')
		self.assertEqual (ast2nat (p ('lambda x, y, z: x + y + z')), 'lambda x, y, z: x + y + z')
		self.assertEqual (ast2nat (p ('1, lambda: x')), '1, lambda: x')
		self.assertEqual (ast2nat (p ('1, lambda x: x**2')), '1, lambda x: x**2')
		self.assertEqual (ast2nat (p ('1, lambda x, y: x + y')), '1, lambda x, y: x + y')
		self.assertEqual (ast2nat (p ('1, lambda x, y, z: x + y + z')), '1, lambda x, y, z: x + y + z')
		self.assertEqual (ast2nat (p ('f = lambda: 0')), 'f = lambda: 0')
		self.assertEqual (ast2nat (p ('f = lambda x: 0')), 'f = lambda x: 0')
		self.assertEqual (ast2nat (p ('f = lambda x, y: 0')), 'f = lambda x, y: 0')
		self.assertEqual (ast2nat (p ('f = lambda x, y, z: 0')), 'f = lambda x, y, z: 0')
		self.assertEqual (ast2nat (p ('\\left(\\left(\\right) \\mapsto x \\right)')), 'lambda: x')
		self.assertEqual (ast2nat (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)')), 'lambda x: x**2')
		self.assertEqual (ast2nat (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)')), 'lambda x, y: x + y')
		self.assertEqual (ast2nat (p ('\\lambda: x')), '{lambda}:x')
		self.assertEqual (ast2nat (p ('\\lambda x: x')), 'lambda * x:x')
		self.assertEqual (ast2nat (p ('\\lambda x, y: x')), 'lambda * x, y:x')
		self.assertEqual (ast2nat (p ('{lambda}: x')), '{lambda}:x')
		self.assertEqual (ast2nat (p ('{lambda} x: x')), 'lambda * x:x')
		self.assertEqual (ast2nat (p ('{lambda} x, y: x')), 'lambda * x, y:x')
		self.assertEqual (ast2nat (p ('$')), '$')
		self.assertEqual (ast2nat (p ('$s')), '$s')
		self.assertEqual (ast2nat (p ('$ (real = True)')), '$(real = True)')
		self.assertEqual (ast2nat (p ('$s (real = True)')), '$s(real = True)')

		self.assertEqual (ast2nat (p ('eye (2).is_diagonal ()')), 'eye(2).is_diagonal()')
		self.assertEqual (ast2nat (p ('a [2]')), 'a[2]')
		self.assertEqual (ast2nat (p ('a [2,3]')), 'a[2, 3]')
		self.assertEqual (ast2nat (p ('a * [2]')), 'a * [2]')
		self.assertEqual (ast2nat (p ('a * {-1}[x]')), 'a * (-1)[x]')
		self.assertEqual (ast2nat (p ('a * [x][y][z]')), 'a * [x][y][z]')
		self.assertEqual (ast2nat (p ('N (1/2)')), 'N(1/2)')
		self.assertEqual (ast2nat (p ("S ('1/2')")), "S( '1/2')")
		self.assertEqual (ast2nat (p ("N (S ('1/2'))")), "N(S( '1/2'))")
		self.assertEqual (ast2nat (p ('S.Half')), 'S.Half')
		self.assertEqual (ast2nat (p ('N S.Half')), 'N(S.Half)')
		self.assertEqual (ast2nat (p ('o [i].t')), 'o[i].t')
		self.assertEqual (ast2nat (p ('o [i]**2')), 'o[i]**2')
		self.assertEqual (ast2nat (p ('o [i]!')), 'o[i]!')
		self.assertEqual (ast2nat (p ("'Hello' [::-1]")), " 'Hello'[::-1]")
		self.assertEqual (ast2nat (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]')), '\\[[1, 2, 3], [4, 5, 6]][:, 1]')
		self.assertEqual (ast2nat (p ('\\binom96')), 'binomial(9, 6)')
		self.assertEqual (ast2nat (p ('binomial (x, y)')), 'binomial(x, y)')
		self.assertEqual (ast2nat (p ('y - 1*x')), 'y - 1 x')
		self.assertEqual (ast2nat (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')")), "Poly(x**2 + 2 x + 1, x, domain =  'ZZ')")
		self.assertEqual (ast2nat (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')")), "Poly(x**2 + y**2 + 2 x y, x, y, domain =  'CC')")
		self.assertEqual (ast2nat (p ('oct(10)')), 'oct(10)')
		self.assertEqual (ast2nat (p ('(1,) + (2,)')), '(1,) + (2,)')
		self.assertEqual (ast2nat (p ('[1] + [2]')), '[1] + [2]')
		self.assertEqual (ast2nat (p ("'a' + 'b'")), " 'a' +  'b'")
		self.assertEqual (ast2nat (p ('(1,) * 2')), '(1,) * 2')
		self.assertEqual (ast2nat (p ('[1] * 2')), '[1] * 2')
		self.assertEqual (ast2nat (p ("'a' * 2")), " 'a' * 2")
		self.assertEqual (ast2nat (p ('Lambda (x, x**2)')), 'lambda x: x**2')
		self.assertEqual (ast2nat (p ('beta (2, 3)')), 'beta(2, 3)')
		self.assertEqual (ast2nat (p ('{x d} y')), 'x d y')
		self.assertEqual (ast2nat (p ('d**2e0/dx**2e0 x**3')), 'd**2e+0 / dx**2e+0 x**3')
		self.assertEqual (ast2nat (p ('ln((a)**b)')), 'ln((a)**b)')
		self.assertEqual (ast2nat (p ('a * \\int dx + {\\int dx dx}')), '{a \\int dx} + {\\int dx} * dx')
		self.assertEqual (ast2nat (p ('1 if {a = x if z} else 0 if y')), '1 if {a = x if z} else 0 if y')
		self.assertEqual (ast2nat (p ('a, lambda: b = 1')), 'a, lambda: {b = 1}')
		self.assertEqual (ast2nat (p ('a * [2]')), 'a * [2]')
		self.assertEqual (ast2nat (p ('sqrt(1, 2)')), 'sqrt(1, 2)')
		self.assertEqual (ast2nat (p ('x*[][y]')), 'x * [][y]')
		self.assertEqual (ast2nat (p ('lambda: x:')), 'lambda: (x:)')
		self.assertEqual (ast2nat (p ('a*[x][y][z]')), 'a * [x][y][z]')
		self.assertEqual (ast2nat (p ('a*()**2')), 'a * ()**2')
		self.assertEqual (ast2nat (p ('a*().t')), 'a * ().t')
		self.assertEqual (ast2nat (p ('a*()[2]')), 'a * ()[2]')
		self.assertEqual (ast2nat (p ('o.f*(a)')), 'o.f * (a)')
		self.assertEqual (ast2nat (p ('o.f*{1+2}')), 'o.f {1 + 2}')
		self.assertEqual (ast2nat (p ('d**2e0/dx**2e0 x**3')), 'd**2e+0 / dx**2e+0 x**3')
		self.assertEqual (ast2nat (p ('y**z [w]')), 'y**z[w]')
		self.assertEqual (ast2nat (p ('{y**z} [w]')), '{y**z}[w]')
		self.assertEqual (ast2nat (p ('x {y**z} [w]')), 'x {y**z}[w]')
		self.assertEqual (ast2nat (p ('{x y**z} [w]')), '(x y**z)[w]')
		self.assertEqual (ast2nat (p ('Min (x, y, z)')), 'Min(x, y, z)')
		self.assertEqual (ast2nat (p ('Max (x, y, z)')), 'Max(x, y, z)')
		self.assertEqual (ast2nat (p ('\\Re (z)')), 're(z)')
		self.assertEqual (ast2nat (p ('\\Im (z)')), 'im(z)')
		self.assertEqual (ast2nat (p ('re (z)')), 're(z)')
		self.assertEqual (ast2nat (p ('im (z)')), 'im(z)')
		self.assertEqual (ast2nat (p ('{}')), '{}')
		self.assertEqual (ast2nat (p ('{1: 2}')), '{1: 2}')
		self.assertEqual (ast2nat (p ('{1: 2,}')), '{1: 2}')
		self.assertEqual (ast2nat (p ('{1: 2, 3: 4}')), '{1: 2, 3: 4}')
		self.assertEqual (ast2nat (p ('set ()')), 'set()')
		self.assertEqual (ast2nat (p ('\\{}')), '\\{}')
		self.assertEqual (ast2nat (p ('\\{1}')), '{1,}')
		self.assertEqual (ast2nat (p ('\\{1,2}')), '{1, 2}')
		self.assertEqual (ast2nat (p ('{1,2}')), '{1, 2}')
		self.assertEqual (ast2nat (p ('1 in {1,2,3}')), '1 in {1, 2, 3}')
		self.assertEqual (ast2nat (p ('1 \\in {1,2,3}')), '1 in {1, 2, 3}')
		self.assertEqual (ast2nat (p ('4 in {1,2,3}')), '4 in {1, 2, 3}')
		self.assertEqual (ast2nat (p ('4 \\in {1,2,3}')), '4 in {1, 2, 3}')
		self.assertEqual (ast2nat (p ('4 not in {1,2,3}')), '4 not in {1, 2, 3}')
		self.assertEqual (ast2nat (p ('4 \\notin {1,2,3}')), '4 not in {1, 2, 3}')
		self.assertEqual (ast2nat (p ('{1,2} - {2,3}')), '{1, 2} - {2, 3}')
		self.assertEqual (ast2nat (p ('{1,2} || {2,3}')), '{1, 2} || {2, 3}')
		self.assertEqual (ast2nat (p ('{1,2} ^^ {2,3}')), '{1, 2} ^^ {2, 3}')
		self.assertEqual (ast2nat (p ('{1,2} && {2,3}')), '{1, 2} && {2, 3}')
		self.assertEqual (ast2nat (p ('{1,2} || {2,3} || {3,4}')), '{1, 2} || {2, 3} || {3, 4}')
		self.assertEqual (ast2nat (p ('{1,2} ^^ {2,3} ^^ {3,4}')), '{1, 2} ^^ {2, 3} ^^ {3, 4}')
		self.assertEqual (ast2nat (p ('{1,2} && {2,3} && {3,4}')), '{1, 2} && {2, 3} && {3, 4}')
		self.assertEqual (ast2nat (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}')), '{1, 2} || {2, 3} ^^ {3, 4} && {4, 5}')
		self.assertEqual (ast2nat (p ('solve (x**2 = 4)')), 'solve(x**2 = 4)')
		self.assertEqual (ast2nat (p ('Subs (x y, x, 2)')), '\\. x y |_{x = 2}')
		self.assertEqual (ast2nat (p ('Subs (x y, (x, y), (2, 3))')), '\\. x y |_{x = 2, y = 3}')
		self.assertEqual (ast2nat (p ('(x y).subs (x, 2)')), '\\. (x y) |_{x = 2}')
		self.assertEqual (ast2nat (p ('(x y).subs (x, 2).subs (y, 3)')), '\\. (x y) |_{x = 2, y = 3}')
		self.assertEqual (ast2nat (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])')), '\\. \\. (x y z w) |_{z = 4} |_{x = 2, y = 3, w = 5}')
		self.assertEqual (ast2nat (p ('x or y')), 'x or y')
		self.assertEqual (ast2nat (p ('x or y or z')), 'x or y or z')
		self.assertEqual (ast2nat (p ('x and y')), 'x and y')
		self.assertEqual (ast2nat (p ('x and y and z')), 'x and y and z')
		self.assertEqual (ast2nat (p ('x and y or z')), 'x and y or z')
		self.assertEqual (ast2nat (p ('x and {y or z}')), 'x and (y or z)')
		self.assertEqual (ast2nat (p ('not x or y')), 'not x or y')
		self.assertEqual (ast2nat (p ('not {x or y}')), 'not (x or y)')
		self.assertEqual (ast2nat (p ('not x and y')), 'not x and y')
		self.assertEqual (ast2nat (p ('not {x and y}')), 'not (x and y)')
		self.assertEqual (ast2nat (p ('x or not y')), 'x or not y')
		self.assertEqual (ast2nat (p ('x and not y')), 'x and not y')
		self.assertEqual (ast2nat (p ('not x')), 'not x')
		self.assertEqual (ast2nat (p ('not not x')), 'not not x')
		self.assertEqual (ast2nat (p ('not not not x')), 'not not not x')
		self.assertEqual (ast2nat (p ('0 or []')), '0 or []')
		self.assertEqual (ast2nat (p ('0 or [1]')), '0 or [1]')
		self.assertEqual (ast2nat (p ('1 and []')), '1 and []')
		self.assertEqual (ast2nat (p ('1 and [1]')), '1 and [1]')
		self.assertEqual (ast2nat (p ('not []')), 'not []')
		self.assertEqual (ast2nat (p ('not [1]')), 'not [1]')
		self.assertEqual (ast2nat (p ('not None')), 'not None')
		self.assertEqual (ast2nat (p ('True + True')), 'True + True')
		self.assertEqual (ast2nat (p ('False - True')), 'False - True')
		self.assertEqual (ast2nat (p ('True * True')), 'True True')
		self.assertEqual (ast2nat (p ('(2 > 1) x')), '(2 > 1) x')
		self.assertEqual (ast2nat (p ('(2 > 1) + (1 < 2)')), '(2 > 1) + (1 < 2)')
		self.assertEqual (ast2nat (p ('\\[{[a, b]},]')), '\\[[[a, b]]]')
		self.assertEqual (ast2nat (p ('{{a:b:c}:d}')), '{(a:b:c): d}')
		self.assertEqual (ast2nat (p ('{a:{b:c:d}}')), '{a: (b:c:d)}')
		self.assertEqual (ast2nat (p ('{a:b:c} = {a:b:c}')), '(a:b:c) = (a:b:c)')
		self.assertEqual (ast2nat (p ('\\[1:2:3]')), '\\[1:2:3]')
		self.assertEqual (ast2nat (p ('-{not x}')), '-(not x)')
		self.assertEqual (ast2nat (p ('x < y in [y] in [[y]] != 2 > 1')), 'x < y in [y] in [[y]] != 2 > 1')
		self.assertEqual (ast2nat (p ('x < y < z < w')), 'x < y < z < w')
		self.assertEqual (ast2nat (p ('\\[]')), '\\[]')
		self.assertEqual (ast2nat (p ('\\[[]]')), '\\[]')
		self.assertEqual (ast2nat (p ('\\[[], []]')), '\\[]')
		self.assertEqual (ast2nat (p ('\\{a:b}')), '{(a:b),}')
		self.assertEqual (ast2nat (p ('{-x} y / z')), '{-x y} / z')
		self.assertEqual (ast2nat (p ('d / dz {-1} a')), 'd / dz (-1 a)')
		self.assertEqual (ast2nat (p ('1 / {-2} x')), '1 / -2 x')
		self.assertEqual (ast2nat (p ('\\sum_{x=0}^b {-x} y')), '\\sum_{x = 0}^b -x y')
		self.assertEqual (ast2nat (p ('\\lim_{x\\to0} {-x} y')), '\\lim_{x \\to 0} -x y')
		self.assertEqual (ast2nat (p ('\\int a / -1 dx')), '\\int a/-1 dx')
		self.assertEqual (ast2nat (p ('\\[[[x]]]')), '\\[[[x]]]')
		self.assertEqual (ast2nat (p ('\\[[[1, 2]], [[3]]]')), '\\[[[1, 2]], [[3]]]')
		self.assertEqual (ast2nat (p ('{1/x}.limit (x, 0, "-")')), "(1/x).limit(x, 0,  '-')")
		self.assertEqual (ast2nat (p ('{x^2y**2z}.diff (x, 2, y, z)')), '(x**2 y**2 z).diff(x, 2, y, z)')
		self.assertEqual (ast2nat (p ('{x y}.integrate ((x, 0, 1))')), '(x y).integrate((x, 0, 1))')
		self.assertEqual (ast2nat (p ('\\sqrt (a:b)')), 'sqrt(a:b)')
		self.assertEqual (ast2nat (p ('\\sqrt[3] (a:b)')), 'sqrt[3](a:b)')
		self.assertEqual (ast2nat (p ('? ()')), '?()')
		self.assertEqual (ast2nat (p ('? (x)')), '?(x)')
		self.assertEqual (ast2nat (p ('? (x) (2)')), '?(x) * (2)')
		self.assertEqual (ast2nat (p ('? (2)')), '?(2)')
		self.assertEqual (ast2nat (p ('?f (x, y, real = True)')), 'f(x, y, real = True)')
		self.assertEqual (ast2nat (p ('?\\alpha(x)')), 'alpha(x)')
		self.assertEqual (ast2nat (p ('?beta(y)')), '?beta(y)')
		self.assertEqual (ast2nat (p ("Function ('f', real = True) (x, y)")), 'f(x, y, real = True)')
		self.assertEqual (ast2nat (p ("x'")), "x'")
		self.assertEqual (ast2nat (p ("x''")), "x''")
		self.assertEqual (ast2nat (p ("{x + y}'")), "(x + y)'")
		self.assertEqual (ast2nat (p ("a [b]'")), "a[b]'")
		self.assertEqual (ast2nat (p ("a.b ()'")), "a.b()'")
		self.assertEqual (ast2nat (p ("{x/y}'")), "(x/y)'")
		self.assertEqual (ast2nat (p ("1'['ac']")), "1'[ 'ac']")
		self.assertEqual (ast2nat (p ("|x|'")), "{|x|}'")
		self.assertEqual (ast2nat (p ("| 'str'|'")), "{| 'str'|}'")
		self.assertEqual (ast2nat (p ("{x**y}'")), "(x**y)'")
		self.assertEqual (ast2nat (p ("{{-1}'}")), "(-1)'")
		self.assertEqual (ast2nat (p ("{a [b]}''")), "a[b]''")
		self.assertEqual (ast2nat (p ("1.'''")), "1.'''")
		self.assertEqual (ast2nat (p ('x [1]')), 'x[1]')
		self.assertEqual (ast2nat (p ('1 [x]')), '1[x]')
		self.assertEqual (ast2nat (p ('[1, 2] [x]')), '[1, 2][x]')
		self.assertEqual (ast2nat (p ('{1, 2} [x]')), '{1, 2}[x]')
		self.assertEqual (ast2nat (p ('{x: 2} [x]')), '{x: 2}[x]')
		self.assertEqual (ast2nat (p ('{y: 2} [x]')), '{y: 2}[x]')
		self.assertEqual (ast2nat (p ("'}'")), " '}'")
		self.assertEqual (ast2nat (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}')), 'q w e r t y u i o p a s d f')
		self.assertEqual (ast2nat (p ('x, y = 1, 2')), 'x, y = 1, 2')
		self.assertEqual (ast2nat (p ('x, 2 = 1, 2')), 'x, 2 = 1, 2')
		self.assertEqual (ast2nat (p ('(x, y) = 1, 2')), '(x, y) = 1, 2')
		self.assertEqual (ast2nat (p ('1; x, y = 1, 2')), '1; x, y = 1, 2')
		self.assertEqual (ast2nat (p ('1; x, 2 = 1, 2')), '1; x, 2 = 1, 2')
		self.assertEqual (ast2nat (p ('1; (x, y) = 1, 2')), '1; (x, y) = 1, 2')
		self.assertEqual (ast2nat (p ('f()()')), 'f() * ()')
		self.assertEqual (ast2nat (p ('f()*()')), 'f() * ()')
		self.assertEqual (ast2nat (p ('f*()*()')), 'f * () * ()')
		self.assertEqual (ast2nat (p ('f*()()')), 'f * () ()')

		self.assertEqual (ast2nat (p ('dy / dx')), 'dy / dx')
		self.assertEqual (ast2nat (p ('dy / dx z')), 'dy / dx * z')
		self.assertEqual (ast2nat (p ('d**2 y / dx**2')), 'd**2 y / dx**2')
		self.assertEqual (ast2nat (p ('d**2 y / dx**2 z')), 'd**2 y / dx**2 * z')
		self.assertEqual (ast2nat (p ('d**2 y / dx dy')), 'd**2 y / dx dy')
		self.assertEqual (ast2nat (p ('d**2 y / dx dy z')), 'd**2 y / dx dy * z')
		self.assertEqual (ast2nat (p ('\\frac{dy}{dx}')), 'dy / dx')
		self.assertEqual (ast2nat (p ('\\frac{dy}{dx} z')), 'dy / dx * z')
		self.assertEqual (ast2nat (p ('\\frac{d**2}{dx**2}')), '(d**2) / dx**2')
		self.assertEqual (ast2nat (p ('\\frac{d**2}{dx**2} z')), 'd**2 z / dx**2')
		self.assertEqual (ast2nat (p ('\\frac{d**2}{dx dy}')), '(d**2) / dx dy')
		self.assertEqual (ast2nat (p ('\\frac{d**2}{dx dy} z')), 'd**2 z / dx dy')
		self.assertEqual (ast2nat (p ('\\frac{d**2 y}{dx dy}')), 'd**2 y / dx dy')
		self.assertEqual (ast2nat (p ('\\frac{d**2 y}{dx dy} z')), 'd**2 y / dx dy * z')
		self.assertEqual (ast2nat (p ('\\int dy / dx')), '\\int dy / dx ')
		self.assertEqual (ast2nat (p ('\\int d/dx x**2 dx')), '\\int d / dx (x**2) dx')
		self.assertEqual (ast2nat (p ('\\int d/dx y(x) dx')), '\\int d / dx (y(x)) dx')
		self.assertEqual (ast2nat (p ('\\int dx dx dx')), '{\\int dx} * dx dx')
		self.assertEqual (ast2nat (p ('\\int dx * dx dx')), '{\\int dx} * dx dx')
		self.assertEqual (ast2nat (p ('dlambda / dx : x')), 'dlambda / dx:x')
		self.assertEqual (ast2nat (p ('d**2 lambda / dx**2 : x')), 'd**2 lambda / dx**2:x')
		self.assertEqual (ast2nat (p ('ln1.or')), 'ln1.or')
		self.assertRaises (AttributeError, ast2nat, p ('ln1. or'))
		self.assertRaises (AttributeError, ast2nat, p ('ln1 . or'))
		self.assertEqual (ast2nat (p ('a.b * c.d')), 'a.b c.d')
		self.assertEqual (ast2nat (p ('a.b c.d')), 'a.b c.d')
		self.assertEqual (ast2nat (p ('lambda x, y, z: ln lambda x:')), 'lambda * x, y, z:ln(lambda) x:')
		self.assertEqual (ast2nat (p ('lambda x, y, z: ln lambda x: 1')), 'lambda x, y, z: ln(lambda x: 1)')

		self.assertEqual (ast2nat (p ('f (x) (0)')), 'f(x) * (0)')
		self.assertEqual (ast2nat (p ('f (x, y) (0, 0)')), 'f(x, y) * (0, 0)')
		self.assertEqual (ast2nat (p ('f (x, y, z) (0, 0, 0)')), 'f(x, y, z) * (0, 0, 0)')
		self.assertEqual (ast2nat (p ("f (x)' (0)")), "f(x)'(0)")
		self.assertEqual (ast2nat (p ('\\. x+y |_{x = 1}')), '\\. x + y |_{x = 1}')
		self.assertEqual (ast2nat (p ('\\. x+y |_{x = 1, y = 2}')), '\\. x + y |_{x = 1, y = 2}')
		self.assertEqual (ast2nat (p ('\\. x+y |_{x, y = 1, 2}')), '\\. x + y |_{x = 1, y = 2}')
		self.assertEqual (ast2nat (p ('\\. x+y |_{\\substack{x = 1}}')), '\\. x + y |_{x = 1}')
		self.assertEqual (ast2nat (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}')), '\\. x + y |_{x = 1, y = 2}')
		self.assertEqual (ast2nat (p ('\\. f(x) |_{f(x) = y}')), '\\. f(x) |_{f(x) = y}')
		self.assertEqual (ast2nat (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}')), '\\. f(x) f(y) |_{f(x) = y, f(y) = z}')
		self.assertEqual (ast2nat (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}')), '\\. f(x) f(y) |_{f(x) = y, f(y) = z}')
		self.assertEqual (ast2nat (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}')), '\\. f(x) f(y) |_{f(x) = y, f(y) = z}')
		self.assertEqual (ast2nat (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}')), '\\. ((1, 2) + (1, 2)) |_{(1, 2, 1, 2) = (3, 4)}')

		self.assertEqual (ast2nat (p ("f (x)' (0)")), "f(x)'(0)")
		self.assertEqual (ast2nat (p ('d / dx (f (x)) (0)')), 'd / dx (f(x))(0)')
		self.assertEqual (ast2nat (p ('d / dx (u (x, y)) (x, y)')), 'd / dx (u(x, y))')
		self.assertEqual (ast2nat (p ('d / dx (u (x, y)) (0, y)')), 'd / dx (u(x, y))(0, y)')
		self.assertEqual (ast2nat (p ('d / dx (u (x, y)) (0, 0)')), 'd / dx (u(x, y))(0, 0)')
		self.assertEqual (ast2nat (p ('d**2 / dx dy (u (x, y)) (x, y)')), 'd**2 / dx dy (u(x, y))')
		self.assertEqual (ast2nat (p ('d**2 / dx dy (u (x, y)) (0, y)')), 'd**2 / dx dy (u(x, y))(0, y)')
		self.assertEqual (ast2nat (p ('d**2 / dx dy (u (x, y)) (0, 0)')), 'd**2 / dx dy (u(x, y))(0, 0)')
		self.assertEqual (ast2nat (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})")), "dsolve(y(x)'' + 11 y(x)' + 24 y(x), ics = {y(0): 0, y(x)'(0): -7})")
		self.assertEqual (ast2nat (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}")), "\\. [f(x)', g(y)'] |_{x = 0, y = 1}")
		self.assertEqual (ast2nat (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')), '\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')
		self.assertEqual (ast2nat (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')), '\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')
		self.assertEqual (ast2nat (p ('?() = 2')), '?() = 2')
		self.assertEqual (ast2nat (p ('?f() = 2')), '?f() = 2')
		self.assertEqual (ast2nat (p ('d / dx (a) b')), 'd / dx (a) * b')
		self.assertEqual (ast2nat (p ('\\frac{d}{dx} (a) b')), 'd / dx (a) * b')
		self.assertEqual (ast2nat (p ('sin (())')), 'sin(())')
		self.assertEqual (ast2nat (p ('sin (((a))')), 'sin(((a)))')
		self.assertEqual (ast2nat (p ('a.b (())')), 'a.b(())')
		self.assertEqual (ast2nat (p ('a.b (((a))')), 'a.b(((a)))')
		self.assertEqual (ast2nat (p ('@x')), '@x')
		self.assertEqual (ast2nat (p ('@(x + y)')), '@(x + y)')
		self.assertEqual (ast2nat (p ('@(x + y)')), '@(x + y)')
		self.assertEqual (ast2nat (p ('%x')), '%x')
		self.assertEqual (ast2nat (p ('%(x + y)')), '%(x + y)')
		self.assertEqual (ast2nat (p ('%%x')), '%%x')
		self.assertEqual (ast2nat (p ('%%(x + y)')), '%%(x + y)')
		self.assertEqual (ast2nat (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]')), '\\[[1, 2, 3], [4, 5, 6]][:, 1:]')

		self.assertEqual (ast2nat (p ('N - N N 2')), 'N - N(N(2))')
		self.assertEqual (ast2nat (p ('N N N 2')), 'N(N(N(2)))')
		self.assertEqual (ast2nat (p ('sin sin sin 2')), 'sin(sin(sin(2)))')
		self.assertEqual (ast2nat (p ('-N sin -N 2')), '-N(sin(-N(2)))')
		self.assertEqual (ast2nat (p ('sin -N sin 2')), 'sin(-N(sin(2)))')
		self.assertEqual (ast2nat (p ('N N sin -a [2]')), 'N(N(sin(-a[2])))')
		self.assertEqual (ast2nat (p ('N N sin -a.b [2]')), 'N(N(sin(-a.b[2])))')
		self.assertEqual (ast2nat (p ('N N sin -a.b () [2]')), 'N(N(sin(-a.b()[2])))')
		self.assertEqual (ast2nat (p ('N N sin -a.b () [2] [3]')), 'N(N(sin(-a.b()[2][3])))')
		self.assertEqual (ast2nat (p ('sin -N () [2] [3].c [4].d () [5]')), 'sin(-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2nat (p ('sqrt -N () [2] [3].c [4].d () [5]')), 'sqrt(-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2nat (p ('sqrt[3] -N () [2] [3].c [4].d () [5]')), 'sqrt[3](-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2nat (p ('log -N () [2] [3].c [4].d () [5]')), 'ln(-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2nat (p ('\\log_2 -N () [2] [3].c [4].d () [5]')), '\\log_2(-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2nat (p ('N sin**2 ln**2 N x')), 'N(sin**2((ln(N(x)))**2))')
		self.assertEqual (ast2nat (p ('sin ln N x')), 'sin(ln(N(x)))')
		self.assertEqual (ast2nat (p ('sin(a)**[a][b].c')), 'sin(a)**[a][b].c')
		self.assertEqual (ast2nat (p ('N sin N sin x')), 'N(sin(N(sin(x))))')
		self.assertEqual (ast2nat (p ('cos**-1 0 \\log_2 8')), 'acos(0) \\log_2(8)')
		self.assertEqual (ast2nat (p ('N sin sqrt[3] \\log_2 8')), 'N(sin(sqrt[3](\\log_2(8))))')
		self.assertEqual (ast2nat (p ('sin(x)**-a[b][c].d')), 'sin(x)**-a[b][c].d')
		self.assertEqual (ast2nat (p ('sin sin x [2].w')), 'sin(sin(x[2].w))')
		self.assertEqual (ast2nat (p ('sin -sin x [2].w')), 'sin(-sin(x[2].w))')
		self.assertEqual (ast2nat (p ('sin sin (x) [2].w')), 'sin(sin(x)[2].w)')
		self.assertEqual (ast2nat (p ('sin -sin (x) [2].w')), 'sin(-sin(x)[2].w)')
		self.assertEqual (ast2nat (p ('sin sin x [2].w ()')), 'sin(sin(x[2].w()))')
		self.assertEqual (ast2nat (p ('ln ln x [2].w')), 'ln(ln(x[2].w))')
		self.assertEqual (ast2nat (p ('N N sin -a [2]')), 'N(N(sin(-a[2])))')
		self.assertEqual (ast2nat (p ('sin sin -x [2].w')), 'sin(sin(-x[2].w))')
		self.assertEqual (ast2nat (p ('sin -sin x [2].w')), 'sin(-sin(x[2].w))')
		self.assertEqual (ast2nat (p ('sin(a)**b[2]')), 'sin(a)**b[2]')
		self.assertEqual (ast2nat (p ('sin**-a[b][c].d x')), 'sin(x)**-a[b][c].d')
		self.assertEqual (ast2nat (p ('sin**-a[b][c].d (x)')), 'sin**-a[b][c].d(x)')
		self.assertEqual (ast2nat (p ('sin**-a[b][c].d {(x)}')), 'sin(x)**-a[b][c].d')
		self.assertEqual (ast2nat (p ('sin**-a[b][c] (x)')), 'sin(x)**-a[b][c]')
		self.assertEqual (ast2nat (p ('\\int**-a[b][c] x')), '\\int_0^{-a[b][c]} x ')
		self.assertEqual (ast2nat (p ('\\int**-a[b][c].d (x)')), '\\int_0^{-a[b][c].d(x)} ')
		self.assertEqual (ast2nat (p ('\\int**-a[b][c].d {(x)}')), '\\int_0^{-a[b][c].d} (x) ')
		self.assertEqual (ast2nat (p ('\\int**-a[b][c].d (x) y')), '\\int_0^{-a[b][c].d(x)} y ')
		self.assertEqual (ast2nat (p ('\\int**-a[b][c].d {(x)} y')), '\\int_0^{-a[b][c].d} (x) y ')
		self.assertEqual (ast2nat (p ('\\int**a.b[2] x dx')), '\\int_0^{a.b[2]} x dx')

		self.assertEqual (ast2nat (p ('d/dx (real = True)')), 'd / dx (real = True)')
		self.assertEqual (ast2nat (p ('f {\\left(x\\right)}')), 'f(x)')
		self.assertEqual (ast2nat (p ('a.b {(x)}')), 'a.b{(x)}')
		self.assertEqual (ast2nat (p ('a.b {\\left(x\\right)}')), 'a.b(x)')
		self.assertEqual (ast2nat (p ('\\log_{|x|} y')), '\\log_{|x|}(y)')
		self.assertEqual (ast2nat (p ('|\\int a + b dx|')), '{|\\int a + b dx|}')
		self.assertEqual (ast2nat (p ('\\int deg N dx')), '\\int deg(N) dx')
		self.assertEqual (ast2nat (p ('a \\int x dx / c')), 'a \\int x dx / c')
		self.assertEqual (ast2nat (p ('\\int x dx b / c')), '{{\\int x dx} * b} / c')
		self.assertEqual (ast2nat (p ('a \\int x dx b / c')), '{a {\\int x dx} * b} / c')
		self.assertEqual (ast2nat (p ('a {\\lim_{x\\to0} \\int x dx} / b')), '{a \\lim_{x \\to 0} \\int x dx} / b')
		self.assertEqual (ast2nat (p ('a {\\sum_{x=0}^1 \\int x dx} / b')), '{a \\sum_{x = 0}^1 \\int x dx} / b')
		self.assertEqual (ast2nat (p ('a / \\int x dx * c')), 'a / {\\int x dx} * c')
		self.assertEqual (ast2nat (p ('a / b \\int x dx * c')), 'a / b \\int x dx * c')

		self.assertEqual (ast2nat (p ('cos')), 'cos')
		self.assertEqual (ast2nat (p ('f = cos')), 'f = cos')
		self.assertEqual (ast2nat (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)')), '\\[[0, pi], [-pi, 0]].applyfunc(cos)')
		self.assertEqual (ast2nat (p ('$sin (real = True)')), '$sin(real = True)')
		self.assertEqual (ast2nat (p ('sin = $(real = True)')), 'sin = $(real = True)')

	def test_ast2py (self):
		self.assertEqual (ast2py (p ('1')), '1')
		self.assertEqual (ast2py (p ('1.')), '1.')
		self.assertEqual (ast2py (p ('.1')), '0.1')
		self.assertEqual (ast2py (p ('1e20')), '1e+20')
		self.assertEqual (ast2py (p ('1E-20')), '1e-20')
		self.assertEqual (ast2py (p ('1.e+20')), '1.e+20')
		self.assertEqual (ast2py (p ('.1e-20')), '0.1e-20')
		self.assertEqual (ast2py (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')), 'sin(-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')
		self.assertEqual (ast2py (p ('x')), 'x')
		self.assertEqual (ast2py (p ('xy')), 'xy')
		self.assertEqual (ast2py (p ('dx')), 'dx')
		self.assertEqual (ast2py (p ('partialx')), 'partialx')
		self.assertEqual (ast2py (p ('\\partial x')), 'partialx')
		self.assertEqual (ast2py (p ('x d  y')), 'x*d*y')
		self.assertEqual (ast2py (p ('x partial y')), 'x*partial*y')
		self.assertEqual (ast2py (p ('x \\partial  y')), 'x*partial*y')
		self.assertEqual (ast2py (p ('x dx dy y')), 'x*dx*dy*y')
		self.assertEqual (ast2py (p ('x partialx partialy y')), 'x*partialx*partialy*y')
		self.assertEqual (ast2py (p ('-1')), '-1')
		self.assertEqual (ast2py (p ('-x')), '-x')
		self.assertEqual (ast2py (p ('{x}')), 'x')
		self.assertEqual (ast2py (p ('()')), '()')
		self.assertEqual (ast2py (p ('(x)')), '(x)')
		self.assertEqual (ast2py (p ('(x,)')), '(x,)')
		self.assertEqual (ast2py (p ('(x,y)')), '(x, y)')
		self.assertEqual (ast2py (p ('(x,y,)')), '(x, y)')
		self.assertEqual (ast2py (p ('[]')), '[]')
		self.assertEqual (ast2py (p ('[x]')), '[x]')
		self.assertEqual (ast2py (p ('[x,]')), '[x]')
		self.assertEqual (ast2py (p ('[x,y]')), '[x, y]')
		self.assertEqual (ast2py (p ('[x,y,]')), '[x, y]')
		self.assertEqual (ast2py (p ('"x\\x20\\n"')), "'x \\n'")
		self.assertEqual (ast2py (p ("'x\\x20\\n'")), "'x \\n'")
		self.assertEqual (ast2py (p ('|x|')), 'abs(x)')
		self.assertEqual (ast2py (p ('x!')), 'factorial(x)')
		self.assertEqual (ast2py (p ('x+y')), 'x + y')
		self.assertEqual (ast2py (p ('x-y')), 'x - y')
		self.assertEqual (ast2py (p ('x*y')), 'x*y')
		self.assertEqual (ast2py (p ('x y')), 'x*y')
		self.assertEqual (ast2py (p ('x(y)')), "Function('x')(y)")
		self.assertEqual (ast2py (p ('x*(y)')), 'x*(y)')
		self.assertEqual (ast2py (p ('x/y')), 'x/y')
		self.assertEqual (ast2py (p ('x^y')), 'x**y')
		self.assertEqual (ast2py (p ('log x')), 'ln(x)')
		self.assertEqual (ast2py (p ('log {x}')), 'ln(x)')
		self.assertEqual (ast2py (p ('log (x)')), 'ln(x)')
		self.assertEqual (ast2py (p ('\\log_2 x')), 'ln(x) / ln(2)')
		self.assertEqual (ast2py (p ('\\log_2 {x}')), 'ln(x) / ln(2)')
		self.assertEqual (ast2py (p ('\\log_2 (x)')), 'ln(x) / ln(2)')
		self.assertEqual (ast2py (p ('sqrt x')), 'sqrt(x)')
		self.assertEqual (ast2py (p ('sqrt {x}')), 'sqrt(x)')
		self.assertEqual (ast2py (p ('sqrt (x)')), 'sqrt(x)')
		self.assertEqual (ast2py (p ('sqrt {(x)}')), 'sqrt(x)')
		self.assertEqual (ast2py (p ('sqrt[3] x')), 'x**(1/3)')
		self.assertEqual (ast2py (p ('sqrt[3] {x}')), 'x**(1/3)')
		self.assertEqual (ast2py (p ('sqrt[3] {(x)}')), 'x**(1/3)')
		self.assertEqual (ast2py (p ('sqrt[3] (x)')), 'x**(1/3)')
		self.assertEqual (ast2py (p ('sin x')), 'sin(x)')
		self.assertEqual (ast2py (p ('sin^2 x')), 'sin(x)**2')
		self.assertEqual (ast2py (p ('sin (x)')), 'sin(x)')
		self.assertEqual (ast2py (p ('sin (x)^2')), 'sin(x)**2')
		self.assertEqual (ast2py (p ('sin {x}')), 'sin(x)')
		self.assertEqual (ast2py (p ('sin {(x)}')), 'sin(x)')
		self.assertEqual (ast2py (p ('{sin x}^2')), 'sin(x)**2')
		self.assertEqual (ast2py (p ('sin**2 x')), 'sin(x)**2')
		self.assertEqual (ast2py (p ('sin**-1 x')), 'asin(x)')
		self.assertEqual (ast2py (p ('sin(x)**-1')), 'sin(x)**-1')
		self.assertEqual (ast2py (p ('acos (x)')), 'acos(x)')
		self.assertEqual (ast2py (p ('\\arccos (x)')), 'acos(x)')
		self.assertEqual (ast2py (p ('sin(x**2)')), 'sin(x**2)')
		self.assertEqual (ast2py (p ('sin(x**2)**2')), 'sin(x**2)**2')
		self.assertEqual (ast2py (p ('(sin(x**2)**2)')), '(sin(x**2)**2)')
		self.assertEqual (ast2py (p ('ln(x**2)')), 'ln(x**2)')
		self.assertEqual (ast2py (p ('ln(x**2)**2')), 'ln(x**2)**2')
		self.assertEqual (ast2py (p ('(ln(x**2)**2)')), '(ln(x**2)**2)')
		self.assertEqual (ast2py (p ('gamma(x**2)')), 'gamma(x**2)')
		self.assertEqual (ast2py (p ('gamma(x**2)**2')), 'gamma(x**2)**2')
		self.assertEqual (ast2py (p ('(gamma(x**2)**2)')), '(gamma(x**2)**2)')
		self.assertEqual (ast2py (p ('{gamma}[2]')), '(gamma)[2]')
		self.assertEqual (ast2py (p ('{Gamma}[2]')), '(Gamma)[2]')
		self.assertEqual (ast2py (p ('f{(x)}')), 'f*(x)')
		self.assertEqual (ast2py (p ("f{(x)}'(0)")), 'f*diff((x))*(0)')
		self.assertEqual (ast2py (p ("f{(x)}'{(0)}")), 'f*diff((x))*(0)')
		self.assertEqual (ast2py (p ('\\operatorname{x_{1}}{\\left(x \\right)}')), "Function('x1')(x)")
		self.assertEqual (ast2py (p ('\\lim_{x\\to0} 1/x')), "Limit(1/x, x, 0, dir = '+-')")
		self.assertEqual (ast2py (p ('\\lim_{x\\to0^+} 1/x')), 'Limit(1/x, x, 0)')
		self.assertEqual (ast2py (p ('\\lim_{x\\to0**-} 1/x')), "Limit(1/x, x, 0, dir = '-')")
		self.assertEqual (ast2py (p ('Limit (1/x, x, 0)')), 'Limit(1/x, x, 0)')
		self.assertEqual (ast2py (p ('Limit (1/x, x, 0, "-")')), "Limit(1/x, x, 0, dir = '-')")
		self.assertEqual (ast2py (p ('Limit (1/x, x, 0, dir="+-")')), "Limit(1/x, x, 0, dir = '+-')")
		self.assertEqual (ast2py (p ('limit (1/x, x, 0)')), 'limit(1/x, x, 0)')
		self.assertEqual (ast2py (p ('limit (1/x, x, 0, "-")')), "limit(1/x, x, 0, '-')")
		self.assertEqual (ast2py (p ('limit (1/x, x, 0, dir="+-")')), "limit(1/x, x, 0, dir = '+-')")
		self.assertEqual (ast2py (p ('\\sum_{n=0}^\\infty x^n/n!')), 'Sum(x**n / factorial(n), (n, 0, oo))')
		self.assertEqual (ast2py (p ('Sum (x^n/n!, (n, 0, oo))')), 'Sum(x**n / factorial(n), (n, 0, oo))')
		self.assertEqual (ast2py (p ('summation (x^n/n!, (n, 0, oo))')), 'summation(x**n / factorial(n), (n, 0, oo))')
		self.assertEqual (ast2py (p ('d/dx x**2y**2z')), 'Derivative(x**2*y**2*z, x)')
		self.assertEqual (ast2py (p ('d^2/dx^2 x^2y**2z')), 'Derivative(x**2*y**2*z, x, 2)')
		self.assertEqual (ast2py (p ('d^3/dx^2dy x^2y**2z')), 'Derivative(x**2*y**2*z, x, 2, y)')
		self.assertEqual (ast2py (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z')), 'Derivative(x**2*y**2*z, x, 2, y, z)')
		self.assertEqual (ast2py (p ('d**1.5 / dx dy x**2y**2')), 'd**1.5 / (dx*dy*x**2*y**2)')
		self.assertEqual (ast2py (p ('d**-2 / dx dy x**2y**2')), 'd**-2 / (dx*dy*x**2*y**2)')
		self.assertEqual (ast2py (p ('d**2 / dx**1.5 x**2y**2')), 'd**2 / (dx**1.5*x**2*y**2)')
		self.assertEqual (ast2py (p ('Derivative (x^2y**2z, x, 2, y, z)')), 'Derivative(x**2*y**2*z, x, 2, y, z)')
		self.assertEqual (ast2py (p ('diff (x^2y**2z, x, 2, y, z)')), 'diff(x**2*y**2*z, x, 2, y, z)')
		self.assertEqual (ast2py (p ('\\int dx')), 'Integral(1, x)')
		self.assertEqual (ast2py (p ('\\int x dx')), 'Integral(x, x)')
		self.assertEqual (ast2py (p ('\\int_0^1 x dx')), 'Integral(x, (x, 0, 1))')
		self.assertEqual (ast2py (p ('\\int_0^1 \\int y dy dx')), 'Integral(y, y, (x, 0, 1))')
		self.assertEqual (ast2py (p ('Integral (\\int y dy, (x, 0, 1))')), 'Integral(y, y, (x, 0, 1))')
		self.assertEqual (ast2py (p ('integrate (\\int y dy, (x, 0, 1))')), 'integrate(Integral(y, y), (x, 0, 1))')

		self.assertEqual (ast2py (p ('\\[1,]')), 'Matrix([1])')
		self.assertEqual (ast2py (p ('\\[1,2]')), 'Matrix([1, 2])')
		self.assertEqual (ast2py (p ('\\[1,2,]')), 'Matrix([1, 2])')
		self.assertEqual (ast2py (p ('\\[[1,],]')), 'Matrix([1])')
		self.assertEqual (ast2py (p ('\\[[1,],[2,]]')), 'Matrix([1, 2])')
		self.assertEqual (ast2py (p ('\\[[1,],[2,],]')), 'Matrix([1, 2])')
		self.assertEqual (ast2py (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]')), 'Matrix([1])')
		self.assertEqual (ast2py (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}')), 'Matrix([1])')
		self.assertEqual (ast2py (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}')), 'Matrix([[1, 2]])')
		self.assertEqual (ast2py (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}')), 'Matrix([[1, 2], [3, 4]])')
		self.assertEqual (ast2py (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}')), 'Matrix([[1, 2], [3, 4]])')
		self.assertEqual (ast2py (p ('\\[1,2]!')), 'factorial(Matrix([1, 2]))')
		self.assertEqual (ast2py (p ('\\[[0,1],[1,0]]**x')), 'Matrix([[0, 1], [1, 0]])**x')
		self.assertEqual (ast2py (p ('\\[[1,2],[3,4]]!')), 'factorial(Matrix([[1, 2], [3, 4]]))')
		self.assertEqual (ast2py (p ('\\[[1,2,3],[4,5,6]].T')), 'Matrix([[1, 2, 3], [4, 5, 6]]).T')
		self.assertEqual (ast2py (p ('\\[[1,2,3],[4,5,6]].T.T')), 'Matrix([[1, 2, 3], [4, 5, 6]]).T.T')
		self.assertEqual (ast2py (p ('\\[[1,2,3],[4,5,6]].T.T.T')), 'Matrix([[1, 2, 3], [4, 5, 6]]).T.T.T')
		self.assertEqual (ast2py (p ('\\[[1,2,3],[4,5,6]].transpose ()')), 'Matrix([[1, 2, 3], [4, 5, 6]]).transpose()')
		self.assertEqual (ast2py (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()')), 'Matrix([[1, 2, 3], [4, 5, 6]]).transpose().transpose()')
		self.assertEqual (ast2py (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()')), 'Matrix([[1, 2, 3], [4, 5, 6]]).transpose().transpose().transpose()')
		self.assertEqual (ast2py (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()')), 'Matrix([[1, 2, 3], [4, 5, 6]]).transpose().transpose().T.T.transpose().transpose()')
		self.assertEqual (ast2py (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]')), 'Matrix([[A, B], [C, D]])*Matrix([x, y])')
		self.assertEqual (ast2py (p ('\\[[1, 2], [3')), 'Matrix([[1, 2], [3, ]])')
		self.assertEqual (ast2py (p ('\\[[1, 2], [3]]')), 'Matrix([[1, 2], [3, ]])')
		self.assertEqual (ast2py (p ('\\[[1], [2, 3]]')), 'Matrix([[1, ], [2, 3]])')

		self.assertEqual (ast2py (p ('-1**x')), '-1**x')
		self.assertEqual (ast2py (p ('{-1}**x')), '(-1)**x')
		self.assertEqual (ast2py (p ('-{-1}**x')), '-(-1)**x')
		self.assertEqual (ast2py (p ('(-1)**x')), '(-1)**x')
		self.assertEqual (ast2py (p ('-(-1)**x')), '-(-1)**x')
		self.assertEqual (ast2py (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')), 'alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')
		self.assertEqual (ast2py (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')), 'alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')
		self.assertEqual (ast2py (p ('1 if x < y')), 'Piecewise((1, Lt(x, y)))')
		self.assertEqual (ast2py (p ('1 if x < y else 3')), 'Piecewise((1, Lt(x, y)), (3, True))')
		self.assertEqual (ast2py (p ('1 if x < y else 3 if x < z')), 'Piecewise((1, Lt(x, y)), (3, Lt(x, z)))')
		self.assertEqual (ast2py (p ('1 if x < y else 3 if x < z else 5')), 'Piecewise((1, Lt(x, y)), (3, Lt(x, z)), (5, True))')
		self.assertEqual (ast2py (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}')), 'Piecewise((1, Lt(x, y)), (3, Lt(x, z)), (5, True))')
		self.assertEqual (ast2py (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}')), 'Piecewise((1, Lt(x, y)), (3, Lt(x, z)), (5, True))')
		self.assertEqual (ast2py (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}')), 'Piecewise((1, Lt(x, y)), (3, Lt(x, z)), (5, Lt(x, w)))')
		self.assertEqual (ast2py (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}')), 'Piecewise((1, Lt(x, y)), (3, Lt(x, z)), (5, Lt(x, w)))')
		self.assertEqual (ast2py (p ('x**y.a')), 'x**y.a')
		self.assertEqual (ast2py (p ('x**y.a ()')), 'x**y.a()')
		self.assertEqual (ast2py (p ('x**y.a.b')), 'x**y.a.b')
		self.assertEqual (ast2py (p ('x**y.a.b ()')), 'x**y.a.b()')
		self.assertEqual (ast2py (p ('x**y.a ().b')), 'x**y.a().b')
		self.assertEqual (ast2py (p ('x**y.a ().b ()')), 'x**y.a().b()')
		self.assertEqual (ast2py (p ('{1 if x < 0 else 3} if x < 1 else 5')), 'Piecewise((Piecewise((1, Lt(x, 0)), (3, True)), Lt(x, 1)), (5, True))')
		self.assertEqual (ast2py (p ('1 if {True if x < 0 else False} else 5')), 'Piecewise((1, Piecewise((True, Lt(x, 0)), (False, True))), (5, True))')
		self.assertEqual (ast2py (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}')), 'Piecewise((1, Piecewise((True, Lt(x, 0)), (False, True))), (Piecewise((7, Lt(x, 1)), (5, True)), True))')
		self.assertEqual (ast2py (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')), 'Piecewise((Piecewise((1, Lt(x, 0)), (9, True)), Piecewise((True, Lt(x, 1)), (False, True))), (Piecewise((7, Lt(x, 2)), (5, True)), True))')
		self.assertEqual (ast2py (p ('x.y!')), 'factorial(x.y)')
		self.assertEqual (ast2py (p ('x.y**2')), 'x.y**2')
		self.assertEqual (ast2py (p ('x.y ()!')), 'factorial(x.y())')
		self.assertEqual (ast2py (p ('x.y ()**2')), 'x.y()**2')
		self.assertEqual (ast2py (p ('x**y.a!')), 'x**factorial(y.a)')
		self.assertEqual (ast2py (p ('x**y.a**2')), 'x**y.a**2')
		self.assertEqual (ast2py (p ('x**y.a ()!')), 'x**factorial(y.a())')
		self.assertEqual (ast2py (p ('x**y.a ()**2')), 'x**y.a()**2')
		self.assertEqual (ast2py (p ('lambda: x')), 'Lambda((), x)')
		self.assertEqual (ast2py (p ('lambda x: x**2')), 'Lambda(x, x**2)')
		self.assertEqual (ast2py (p ('lambda x, y: x + y')), 'Lambda((x, y), x + y)')
		self.assertEqual (ast2py (p ('lambda x, y, z: x + y + z')), 'Lambda((x, y, z), x + y + z)')
		self.assertEqual (ast2py (p ('1, lambda: x')), '1, Lambda((), x)')
		self.assertEqual (ast2py (p ('1, lambda x: x**2')), '1, Lambda(x, x**2)')
		self.assertEqual (ast2py (p ('1, lambda x, y: x + y')), '1, Lambda((x, y), x + y)')
		self.assertEqual (ast2py (p ('1, lambda x, y, z: x + y + z')), '1, Lambda((x, y, z), x + y + z)')
		self.assertEqual (ast2py (p ('f = lambda: 0')), 'f = Lambda((), 0)')
		self.assertEqual (ast2py (p ('f = lambda x: 0')), 'f = Lambda(x, 0)')
		self.assertEqual (ast2py (p ('f = lambda x, y: 0')), 'f = Lambda((x, y), 0)')
		self.assertEqual (ast2py (p ('f = lambda x, y, z: 0')), 'f = Lambda((x, y, z), 0)')
		self.assertEqual (ast2py (p ('\\left(\\left(\\right) \\mapsto x \\right)')), 'Lambda((), x)')
		self.assertEqual (ast2py (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)')), 'Lambda(x, x**2)')
		self.assertEqual (ast2py (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)')), 'Lambda((x, y), x + y)')
		self.assertEqual (ast2py (p ('\\lambda: x')), 'slice(lambda, x)')
		self.assertEqual (ast2py (p ('\\lambda x: x')), 'slice(lambda*x, x)')
		self.assertEqual (ast2py (p ('\\lambda x, y: x')), 'lambda*x, slice(y, x)')
		self.assertEqual (ast2py (p ('{lambda}: x')), 'slice(lambda, x)')
		self.assertEqual (ast2py (p ('{lambda} x: x')), 'slice(lambda*x, x)')
		self.assertEqual (ast2py (p ('{lambda} x, y: x')), 'lambda*x, slice(y, x)')
		self.assertEqual (ast2py (p ('$')), "Symbol('')")
		self.assertEqual (ast2py (p ('$s')), "Symbol('s')")
		self.assertEqual (ast2py (p ('$ (real = True)')), "Symbol('', real = True)")
		self.assertEqual (ast2py (p ('$s (real = True)')), "Symbol('s', real = True)")

		self.assertEqual (ast2py (p ('eye (2).is_diagonal ()')), 'eye(2).is_diagonal()')
		self.assertEqual (ast2py (p ('a [2]')), 'a[2]')
		self.assertEqual (ast2py (p ('a [2,3]')), 'a[2, 3]')
		self.assertEqual (ast2py (p ('a * [2]')), 'a*[2]')
		self.assertEqual (ast2py (p ('a * {-1}[x]')), 'a*(-1)[x]')
		self.assertEqual (ast2py (p ('a * [x][y][z]')), 'a*[x][y][z]')
		self.assertEqual (ast2py (p ('N (1/2)')), 'N(1/2)')
		self.assertEqual (ast2py (p ("S ('1/2')")), "S('1/2')")
		self.assertEqual (ast2py (p ("N (S ('1/2'))")), "N(S('1/2'))")
		self.assertEqual (ast2py (p ('S.Half')), 'S.Half')
		self.assertEqual (ast2py (p ('N S.Half')), 'N(S.Half)')
		self.assertEqual (ast2py (p ('o [i].t')), 'o[i].t')
		self.assertEqual (ast2py (p ('o [i]**2')), 'o[i]**2')
		self.assertEqual (ast2py (p ('o [i]!')), 'factorial(o[i])')
		self.assertEqual (ast2py (p ("'Hello' [::-1]")), "'Hello'[::-1]")
		self.assertEqual (ast2py (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]')), 'Matrix([[1, 2, 3], [4, 5, 6]])[:, 1]')
		self.assertEqual (ast2py (p ('\\binom96')), 'binomial(9, 6)')
		self.assertEqual (ast2py (p ('binomial (x, y)')), 'binomial(x, y)')
		self.assertEqual (ast2py (p ('y - 1*x')), 'y - 1*x')
		self.assertEqual (ast2py (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')")), "Poly(x**2 + 2*x + 1, x, domain = 'ZZ')")
		self.assertEqual (ast2py (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')")), "Poly(x**2 + y**2 + 2*x*y, x, y, domain = 'CC')")
		self.assertEqual (ast2py (p ('oct(10)')), 'oct(10)')
		self.assertEqual (ast2py (p ('(1,) + (2,)')), '(1,) + (2,)')
		self.assertEqual (ast2py (p ('[1] + [2]')), '[1] + [2]')
		self.assertEqual (ast2py (p ("'a' + 'b'")), "'a' + 'b'")
		self.assertEqual (ast2py (p ('(1,) * 2')), '(1,)*2')
		self.assertEqual (ast2py (p ('[1] * 2')), '[1]*2')
		self.assertEqual (ast2py (p ("'a' * 2")), "'a'*2")
		self.assertEqual (ast2py (p ('Lambda (x, x**2)')), 'Lambda(x, x**2)')
		self.assertEqual (ast2py (p ('beta (2, 3)')), 'beta(2, 3)')
		self.assertEqual (ast2py (p ('{x d} y')), 'x*d*y')
		self.assertEqual (ast2py (p ('d**2e0/dx**2e0 x**3')), 'd**2e+0 / (dx**2e+0*x**3)')
		self.assertEqual (ast2py (p ('ln((a)**b)')), 'ln((a)**b)')
		self.assertEqual (ast2py (p ('a * \\int dx + {\\int dx dx}')), 'a*Integral(1, x) + Integral(1, x)*dx')
		self.assertEqual (ast2py (p ('1 if {a = x if z} else 0 if y')), 'Piecewise((1, Eq(a, Piecewise((x, z)))), (0, y))')
		self.assertEqual (ast2py (p ('a, lambda: b = 1')), 'a, Lambda((), Eq(b, 1))')
		self.assertEqual (ast2py (p ('a * [2]')), 'a*[2]')
		self.assertEqual (ast2py (p ('sqrt(1, 2)')), 'sqrt(1, 2)')
		self.assertEqual (ast2py (p ('x*[][y]')), 'x*[][y]')
		self.assertEqual (ast2py (p ('lambda: x:')), 'Lambda((), slice(x, None))')
		self.assertEqual (ast2py (p ('a*[x][y][z]')), 'a*[x][y][z]')
		self.assertEqual (ast2py (p ('a*()**2')), 'a*()**2')
		self.assertEqual (ast2py (p ('a*().t')), 'a*().t')
		self.assertEqual (ast2py (p ('a*()[2]')), 'a*()[2]')
		self.assertEqual (ast2py (p ('o.f*(a)')), 'o.f*(a)')
		self.assertEqual (ast2py (p ('o.f*{1+2}')), 'o.f*(1 + 2)')
		self.assertEqual (ast2py (p ('d**2e0/dx**2e0 x**3')), 'd**2e+0 / (dx**2e+0*x**3)')
		self.assertEqual (ast2py (p ('y**z [w]')), 'y**z[w]')
		self.assertEqual (ast2py (p ('{y**z} [w]')), '(y**z)[w]')
		self.assertEqual (ast2py (p ('x {y**z} [w]')), 'x*(y**z)[w]')
		self.assertEqual (ast2py (p ('{x y**z} [w]')), '(x*y**z)[w]')
		self.assertEqual (ast2py (p ('Min (x, y, z)')), 'Min(x, y, z)')
		self.assertEqual (ast2py (p ('Max (x, y, z)')), 'Max(x, y, z)')
		self.assertEqual (ast2py (p ('\\Re (z)')), 're(z)')
		self.assertEqual (ast2py (p ('\\Im (z)')), 'im(z)')
		self.assertEqual (ast2py (p ('re (z)')), 're(z)')
		self.assertEqual (ast2py (p ('im (z)')), 'im(z)')
		self.assertEqual (ast2py (p ('{}')), '{}')
		self.assertEqual (ast2py (p ('{1: 2}')), '{1: 2}')
		self.assertEqual (ast2py (p ('{1: 2,}')), '{1: 2}')
		self.assertEqual (ast2py (p ('{1: 2, 3: 4}')), '{1: 2, 3: 4}')
		self.assertEqual (ast2py (p ('set ()')), 'set()')
		self.assertEqual (ast2py (p ('\\{}')), 'FiniteSet()')
		self.assertEqual (ast2py (p ('\\{1}')), 'FiniteSet(1)')
		self.assertEqual (ast2py (p ('\\{1,2}')), 'FiniteSet(1, 2)')
		self.assertEqual (ast2py (p ('{1,2}')), 'FiniteSet(1, 2)')
		self.assertEqual (ast2py (p ('1 in {1,2,3}')), '1 in FiniteSet(1, 2, 3)')
		self.assertEqual (ast2py (p ('1 \\in {1,2,3}')), '1 in FiniteSet(1, 2, 3)')
		self.assertEqual (ast2py (p ('4 in {1,2,3}')), '4 in FiniteSet(1, 2, 3)')
		self.assertEqual (ast2py (p ('4 \\in {1,2,3}')), '4 in FiniteSet(1, 2, 3)')
		self.assertEqual (ast2py (p ('4 not in {1,2,3}')), '4 not in FiniteSet(1, 2, 3)')
		self.assertEqual (ast2py (p ('4 \\notin {1,2,3}')), '4 not in FiniteSet(1, 2, 3)')
		self.assertEqual (ast2py (p ('{1,2} - {2,3}')), 'FiniteSet(1, 2) - FiniteSet(2, 3)')
		self.assertEqual (ast2py (p ('{1,2} || {2,3}')), 'Union(FiniteSet(1, 2), FiniteSet(2, 3))')
		self.assertEqual (ast2py (p ('{1,2} ^^ {2,3}')), 'SymmetricDifference(FiniteSet(1, 2), FiniteSet(2, 3))')
		self.assertEqual (ast2py (p ('{1,2} && {2,3}')), 'Intersection(FiniteSet(1, 2), FiniteSet(2, 3))')
		self.assertEqual (ast2py (p ('{1,2} || {2,3} || {3,4}')), 'Union(FiniteSet(1, 2), FiniteSet(2, 3), FiniteSet(3, 4))')
		self.assertEqual (ast2py (p ('{1,2} ^^ {2,3} ^^ {3,4}')), 'SymmetricDifference(SymmetricDifference(FiniteSet(1, 2), FiniteSet(2, 3)), FiniteSet(3, 4))')
		self.assertEqual (ast2py (p ('{1,2} && {2,3} && {3,4}')), 'Intersection(FiniteSet(1, 2), FiniteSet(2, 3), FiniteSet(3, 4))')
		self.assertEqual (ast2py (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}')), 'Union(FiniteSet(1, 2), SymmetricDifference(FiniteSet(2, 3), Intersection(FiniteSet(3, 4), FiniteSet(4, 5))))')
		self.assertEqual (ast2py (p ('solve (x**2 = 4)')), 'solve(Eq(x**2, 4))')
		self.assertEqual (ast2py (p ('Subs (x y, x, 2)')), 'Subs(x*y, x, 2)')
		self.assertEqual (ast2py (p ('Subs (x y, (x, y), (2, 3))')), 'Subs(x*y, (x, y), (2, 3))')
		self.assertEqual (ast2py (p ('(x y).subs (x, 2)')), 'Subs((x*y), x, 2)')
		self.assertEqual (ast2py (p ('(x y).subs (x, 2).subs (y, 3)')), 'Subs((x*y), (x, y), (2, 3))')
		self.assertEqual (ast2py (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])')), 'Subs(Subs((x*y*z*w), z, 4), (x, y, w), (2, 3, 5))')
		self.assertEqual (ast2py (p ('x or y')), 'Or(x, y)')
		self.assertEqual (ast2py (p ('x or y or z')), 'Or(x, y, z)')
		self.assertEqual (ast2py (p ('x and y')), 'And(x, y)')
		self.assertEqual (ast2py (p ('x and y and z')), 'And(x, y, z)')
		self.assertEqual (ast2py (p ('x and y or z')), 'Or(And(x, y), z)')
		self.assertEqual (ast2py (p ('x and {y or z}')), 'And(x, Or(y, z))')
		self.assertEqual (ast2py (p ('not x or y')), 'Or(Not(x), y)')
		self.assertEqual (ast2py (p ('not {x or y}')), 'Not(Or(x, y))')
		self.assertEqual (ast2py (p ('not x and y')), 'And(Not(x), y)')
		self.assertEqual (ast2py (p ('not {x and y}')), 'Not(And(x, y))')
		self.assertEqual (ast2py (p ('x or not y')), 'Or(x, Not(y))')
		self.assertEqual (ast2py (p ('x and not y')), 'And(x, Not(y))')
		self.assertEqual (ast2py (p ('not x')), 'Not(x)')
		self.assertEqual (ast2py (p ('not not x')), 'Not(Not(x))')
		self.assertEqual (ast2py (p ('not not not x')), 'Not(Not(Not(x)))')
		self.assertEqual (ast2py (p ('0 or []')), 'Or(0, [])')
		self.assertEqual (ast2py (p ('0 or [1]')), 'Or(0, [1])')
		self.assertEqual (ast2py (p ('1 and []')), 'And(1, [])')
		self.assertEqual (ast2py (p ('1 and [1]')), 'And(1, [1])')
		self.assertEqual (ast2py (p ('not []')), 'Not([])')
		self.assertEqual (ast2py (p ('not [1]')), 'Not([1])')
		self.assertEqual (ast2py (p ('not None')), 'Not(None)')
		self.assertEqual (ast2py (p ('True + True')), 'True + True')
		self.assertEqual (ast2py (p ('False - True')), 'False - True')
		self.assertEqual (ast2py (p ('True * True')), 'True*True')
		self.assertEqual (ast2py (p ('(2 > 1) x')), '(Gt(2, 1))*x')
		self.assertEqual (ast2py (p ('(2 > 1) + (1 < 2)')), '(Gt(2, 1)) + (Lt(1, 2))')
		self.assertEqual (ast2py (p ('\\[{[a, b]},]')), 'Matrix([[[a, b]]])')
		self.assertEqual (ast2py (p ('{{a:b:c}:d}')), '{slice(a, b, c): d}')
		self.assertEqual (ast2py (p ('{a:{b:c:d}}')), '{a: slice(b, c, d)}')
		self.assertEqual (ast2py (p ('{a:b:c} = {a:b:c}')), 'Eq(slice(a, b, c), slice(a, b, c))')
		self.assertEqual (ast2py (p ('\\[1:2:3]')), 'Matrix([slice(1, 2, 3)])')
		self.assertEqual (ast2py (p ('-{not x}')), '-Not(x)')
		self.assertEqual (ast2py (p ('x < y in [y] in [[y]] != 2 > 1')), 'And(Lt(x, y), y in [y], [y] in [[y]], Ne([[y]], 2), Gt(2, 1))')
		self.assertEqual (ast2py (p ('x < y < z < w')), 'And(Lt(x, y), Lt(y, z), Lt(z, w))')
		self.assertEqual (ast2py (p ('\\[]')), 'Matrix()')
		self.assertEqual (ast2py (p ('\\[[]]')), 'Matrix()')
		self.assertEqual (ast2py (p ('\\[[], []]')), 'Matrix()')
		self.assertEqual (ast2py (p ('\\{a:b}')), 'FiniteSet(slice(a, b))')
		self.assertEqual (ast2py (p ('{-x} y / z')), '(-x*y) / z')
		self.assertEqual (ast2py (p ('d / dz {-1} a')), 'Derivative(-1*a, z)')
		self.assertEqual (ast2py (p ('1 / {-2} x')), '1 / (-2*x)')
		self.assertEqual (ast2py (p ('\\sum_{x=0}^b {-x} y')), 'Sum(-x*y, (x, 0, b))')
		self.assertEqual (ast2py (p ('\\lim_{x\\to0} {-x} y')), "Limit(-x*y, x, 0, dir = '+-')")
		self.assertEqual (ast2py (p ('\\int a / -1 dx')), 'Integral(a/-1, x)')
		self.assertEqual (ast2py (p ('\\[[[x]]]')), 'Matrix([[[x]]])')
		self.assertEqual (ast2py (p ('\\[[[1, 2]], [[3]]]')), 'Matrix([[[1, 2]], [[3]]])')
		self.assertEqual (ast2py (p ('{1/x}.limit (x, 0, "-")')), "(1/x).limit(x, 0, '-')")
		self.assertEqual (ast2py (p ('{x^2y**2z}.diff (x, 2, y, z)')), '(x**2*y**2*z).diff(x, 2, y, z)')
		self.assertEqual (ast2py (p ('{x y}.integrate ((x, 0, 1))')), '(x*y).integrate((x, 0, 1))')
		self.assertEqual (ast2py (p ('\\sqrt (a:b)')), 'sqrt(slice(a, b))')
		self.assertEqual (ast2py (p ('\\sqrt[3] (a:b)')), 'slice(a, b)**(1/3)')
		self.assertEqual (ast2py (p ('? ()')), "Function('')")
		self.assertEqual (ast2py (p ('? (x)')), "Function('')(x)")
		self.assertEqual (ast2py (p ('? (x) (2)')), "Function('')(x)*(2)")
		self.assertEqual (ast2py (p ('? (2)')), "Function('')(2)")
		self.assertEqual (ast2py (p ('?f (x, y, real = True)')), "Function('f', real = True)(x, y)")
		self.assertEqual (ast2py (p ('?\\alpha(x)')), "Function('alpha')(x)")
		self.assertEqual (ast2py (p ('?beta(y)')), "Function('beta')(y)")
		self.assertEqual (ast2py (p ("Function ('f', real = True) (x, y)")), "Function('f', real = True)(x, y)")
		self.assertEqual (ast2py (p ("x'")), 'diff(x)')
		self.assertEqual (ast2py (p ("x''")), 'diff(diff(x))')
		self.assertEqual (ast2py (p ("{x + y}'")), 'diff(x + y)')
		self.assertEqual (ast2py (p ("a [b]'")), 'diff(a[b])')
		self.assertEqual (ast2py (p ("a.b ()'")), 'diff(a.b())')
		self.assertEqual (ast2py (p ("{x/y}'")), 'diff(x/y)')
		self.assertEqual (ast2py (p ("1'['ac']")), "diff(1)['ac']")
		self.assertEqual (ast2py (p ("|x|'")), 'diff(abs(x))')
		self.assertEqual (ast2py (p ("| 'str'|'")), "diff(abs('str'))")
		self.assertEqual (ast2py (p ("{x**y}'")), 'diff(x**y)')
		self.assertEqual (ast2py (p ("{{-1}'}")), 'diff(-1)')
		self.assertEqual (ast2py (p ("{a [b]}''")), 'diff(diff(a[b]))')
		self.assertEqual (ast2py (p ("1.'''")), 'diff(diff(diff(1.)))')
		self.assertEqual (ast2py (p ('x [1]')), 'x[1]')
		self.assertEqual (ast2py (p ('1 [x]')), '1[x]')
		self.assertEqual (ast2py (p ('[1, 2] [x]')), '[1, 2][x]')
		self.assertEqual (ast2py (p ('{1, 2} [x]')), 'FiniteSet(1, 2)[x]')
		self.assertEqual (ast2py (p ('{x: 2} [x]')), '{x: 2}[x]')
		self.assertEqual (ast2py (p ('{y: 2} [x]')), '{y: 2}[x]')
		self.assertEqual (ast2py (p ("'}'")), "'}'")
		self.assertEqual (ast2py (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}')), 'q*w*e*r*t*y*u*i*o*p*a*s*d*f')
		self.assertEqual (ast2py (p ('x, y = 1, 2')), 'x, y = 1, 2')
		self.assertEqual (ast2py (p ('x, 2 = 1, 2')), 'x, Eq(2, 1), 2')
		self.assertEqual (ast2py (p ('(x, y) = 1, 2')), 'Eq((x, y), 1), 2')
		self.assertEqual (ast2py (p ('1; x, y = 1, 2')), '1; x, y = 1, 2')
		self.assertEqual (ast2py (p ('1; x, 2 = 1, 2')), '1; x, Eq(2, 1), 2')
		self.assertEqual (ast2py (p ('1; (x, y) = 1, 2')), '1; Eq((x, y), 1), 2')
		self.assertEqual (ast2py (p ('f()()')), "Function('f')*()")
		self.assertEqual (ast2py (p ('f()*()')), "Function('f')*()")
		self.assertEqual (ast2py (p ('f*()*()')), 'f*()*()')
		self.assertEqual (ast2py (p ('f*()()')), 'f*()*()')

		self.assertEqual (ast2py (p ('dy / dx')), 'Derivative(y, x)')
		self.assertEqual (ast2py (p ('dy / dx z')), 'Derivative(y, x)*z')
		self.assertEqual (ast2py (p ('d**2 y / dx**2')), 'Derivative(y, x, 2)')
		self.assertEqual (ast2py (p ('d**2 y / dx**2 z')), 'Derivative(y, x, 2)*z')
		self.assertEqual (ast2py (p ('d**2 y / dx dy')), 'Derivative(y, x, y)')
		self.assertEqual (ast2py (p ('d**2 y / dx dy z')), 'Derivative(y, x, y)*z')
		self.assertEqual (ast2py (p ('\\frac{dy}{dx}')), 'Derivative(y, x)')
		self.assertEqual (ast2py (p ('\\frac{dy}{dx} z')), 'Derivative(y, x)*z')
		self.assertEqual (ast2py (p ('\\frac{d**2}{dx**2}')), 'd**2 / dx**2')
		self.assertEqual (ast2py (p ('\\frac{d**2}{dx**2} z')), 'Derivative(z, x, 2)')
		self.assertEqual (ast2py (p ('\\frac{d**2}{dx dy}')), 'd**2 / (dx*dy)')
		self.assertEqual (ast2py (p ('\\frac{d**2}{dx dy} z')), 'Derivative(z, x, y)')
		self.assertEqual (ast2py (p ('\\frac{d**2 y}{dx dy}')), 'Derivative(y, x, y)')
		self.assertEqual (ast2py (p ('\\frac{d**2 y}{dx dy} z')), 'Derivative(y, x, y)*z')
		self.assertEqual (ast2py (p ('\\int dy / dx')), 'Integral(Derivative(y, x), )')
		self.assertEqual (ast2py (p ('\\int d/dx x**2 dx')), 'Integral(Derivative(x**2, x), x)')
		self.assertEqual (ast2py (p ('\\int d/dx y(x) dx')), "Integral(Derivative(Function('y')(x), x), x)")
		self.assertEqual (ast2py (p ('\\int dx dx dx')), 'Integral(1, x)*dx*dx')
		self.assertEqual (ast2py (p ('\\int dx * dx dx')), 'Integral(1, x)*dx*dx')
		self.assertEqual (ast2py (p ('dlambda / dx : x')), 'slice(Derivative(lambda, x), x)')
		self.assertEqual (ast2py (p ('d**2 lambda / dx**2 : x')), 'slice(Derivative(lambda, x, 2), x)')
		self.assertEqual (ast2py (p ('ln1.or')), 'ln1.or')
		self.assertRaises (AttributeError, ast2py, p ('ln1. or'))
		self.assertRaises (AttributeError, ast2py, p ('ln1 . or'))
		self.assertEqual (ast2py (p ('a.b * c.d')), 'a.b*c.d')
		self.assertEqual (ast2py (p ('a.b c.d')), 'a.b*c.d')
		self.assertEqual (ast2py (p ('lambda x, y, z: ln lambda x:')), 'lambda*x, y, slice(z, ln(lambda)*x)')
		self.assertEqual (ast2py (p ('lambda x, y, z: ln lambda x: 1')), 'Lambda((x, y, z), ln(Lambda(x, 1)))')

		self.assertEqual (ast2py (p ('f (x) (0)')), "Function('f')(x)*(0)")
		self.assertEqual (ast2py (p ('f (x, y) (0, 0)')), "Function('f')(x, y)*(0, 0)")
		self.assertEqual (ast2py (p ('f (x, y, z) (0, 0, 0)')), "Function('f')(x, y, z)*(0, 0, 0)")
		self.assertEqual (ast2py (p ("f (x)' (0)")), "Subs(diff(Function('f')(x)), x, 0)")
		self.assertEqual (ast2py (p ('\\. x+y |_{x = 1}')), 'Subs(x + y, x, 1)')
		self.assertEqual (ast2py (p ('\\. x+y |_{x = 1, y = 2}')), 'Subs(x + y, (x, y), (1, 2))')
		self.assertEqual (ast2py (p ('\\. x+y |_{x, y = 1, 2}')), 'Subs(x + y, (x, y), (1, 2))')
		self.assertEqual (ast2py (p ('\\. x+y |_{\\substack{x = 1}}')), 'Subs(x + y, x, 1)')
		self.assertEqual (ast2py (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}')), 'Subs(x + y, (x, y), (1, 2))')
		self.assertEqual (ast2py (p ('\\. f(x) |_{f(x) = y}')), "Subs(Function('f')(x), Function('f')(x), y)")
		self.assertEqual (ast2py (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}')), "Subs(Function('f')(x)*Function('f')(y), (Function('f')(x), Function('f')(y)), (y, z))")
		self.assertEqual (ast2py (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}')), "Subs(Function('f')(x)*Function('f')(y), (Function('f')(x), Function('f')(y)), (y, z))")
		self.assertEqual (ast2py (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}')), "Subs(Function('f')(x)*Function('f')(y), (Function('f')(x), Function('f')(y)), (y, z))")
		self.assertEqual (ast2py (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}')), 'Subs(((1, 2) + (1, 2)), ((1, 2, 1, 2),), ((3, 4),))')

		self.assertEqual (ast2py (p ("f (x)' (0)")), "Subs(diff(Function('f')(x)), x, 0)")
		self.assertEqual (ast2py (p ('d / dx (f (x)) (0)')), "Subs(Derivative(Function('f')(x), x), x, 0)")
		self.assertEqual (ast2py (p ('d / dx (u (x, y)) (x, y)')), "Derivative(Function('u')(x, y), x)")
		self.assertEqual (ast2py (p ('d / dx (u (x, y)) (0, y)')), "Subs(Derivative(Function('u')(x, y), x), x, 0)")
		self.assertEqual (ast2py (p ('d / dx (u (x, y)) (0, 0)')), "Subs(Derivative(Function('u')(x, y), x), (x, y), (0, 0))")
		self.assertEqual (ast2py (p ('d**2 / dx dy (u (x, y)) (x, y)')), "Derivative(Function('u')(x, y), x, y)")
		self.assertEqual (ast2py (p ('d**2 / dx dy (u (x, y)) (0, y)')), "Subs(Derivative(Function('u')(x, y), x, y), x, 0)")
		self.assertEqual (ast2py (p ('d**2 / dx dy (u (x, y)) (0, 0)')), "Subs(Derivative(Function('u')(x, y), x, y), (x, y), (0, 0))")
		self.assertEqual (ast2py (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})")), "dsolve(diff(diff(Function('y')(x))) + 11*diff(Function('y')(x)) + 24*Function('y')(x), ics = {Function('y')(0): 0, Subs(diff(Function('y')(x)), x, 0): -7})")
		self.assertEqual (ast2py (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}")), "Subs([diff(Function('f')(x)), diff(Function('g')(y))], (x, y), (0, 1))")
		self.assertEqual (ast2py (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')), "Subs([Derivative(Function('f')(x, y), x), Derivative(Function('g')(y, x), x)], (x, y), (0, 1))")
		self.assertEqual (ast2py (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')), "Subs(Derivative(Function('f')(x, z), x, y), (x, y, z), (1, 2, 3))")
		self.assertEqual (ast2py (p ('?() = 2')), "Eq(Function(''), 2)")
		self.assertEqual (ast2py (p ('?f() = 2')), "Eq(Function('f'), 2)")
		self.assertEqual (ast2py (p ('d / dx (a) b')), 'Derivative(a, x)*b')
		self.assertEqual (ast2py (p ('\\frac{d}{dx} (a) b')), 'Derivative(a, x)*b')
		self.assertEqual (ast2py (p ('sin (())')), 'sin(())')
		self.assertEqual (ast2py (p ('sin (((a))')), 'sin(((a)))')
		self.assertEqual (ast2py (p ('a.b (())')), 'a.b(())')
		self.assertEqual (ast2py (p ('a.b (((a))')), 'a.b(((a)))')
		self.assertEqual (ast2py (p ('@x')), 'x')
		self.assertEqual (ast2py (p ('@(x + y)')), 'x + y')
		self.assertEqual (ast2py (p ('@(x + y)')), 'x + y')
		self.assertEqual (ast2py (p ('%x')), 'x')
		self.assertEqual (ast2py (p ('%(x + y)')), 'x + y')
		self.assertEqual (ast2py (p ('%%x')), 'x')
		self.assertEqual (ast2py (p ('%%(x + y)')), 'x + y')
		self.assertEqual (ast2py (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]')), 'Matrix([[1, 2, 3], [4, 5, 6]])[:, 1:]')

		self.assertEqual (ast2py (p ('N - N N 2')), 'N - N(N(2))')
		self.assertEqual (ast2py (p ('N N N 2')), 'N(N(N(2)))')
		self.assertEqual (ast2py (p ('sin sin sin 2')), 'sin(sin(sin(2)))')
		self.assertEqual (ast2py (p ('-N sin -N 2')), '-N(sin(-N(2)))')
		self.assertEqual (ast2py (p ('sin -N sin 2')), 'sin(-N(sin(2)))')
		self.assertEqual (ast2py (p ('N N sin -a [2]')), 'N(N(sin(-a[2])))')
		self.assertEqual (ast2py (p ('N N sin -a.b [2]')), 'N(N(sin(-a.b[2])))')
		self.assertEqual (ast2py (p ('N N sin -a.b () [2]')), 'N(N(sin(-a.b()[2])))')
		self.assertEqual (ast2py (p ('N N sin -a.b () [2] [3]')), 'N(N(sin(-a.b()[2][3])))')
		self.assertEqual (ast2py (p ('sin -N () [2] [3].c [4].d () [5]')), 'sin(-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2py (p ('sqrt -N () [2] [3].c [4].d () [5]')), 'sqrt(-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2py (p ('sqrt[3] -N () [2] [3].c [4].d () [5]')), '(-N()[2][3].c[4].d()[5])**(1/3)')
		self.assertEqual (ast2py (p ('log -N () [2] [3].c [4].d () [5]')), 'ln(-N()[2][3].c[4].d()[5])')
		self.assertEqual (ast2py (p ('\\log_2 -N () [2] [3].c [4].d () [5]')), 'ln(-N()[2][3].c[4].d()[5]) / ln(2)')
		self.assertEqual (ast2py (p ('N sin**2 ln**2 N x')), 'N(sin(ln(N(x))**2)**2)')
		self.assertEqual (ast2py (p ('sin ln N x')), 'sin(ln(N(x)))')
		self.assertEqual (ast2py (p ('sin(a)**[a][b].c')), 'sin(a)**[a][b].c')
		self.assertEqual (ast2py (p ('N sin N sin x')), 'N(sin(N(sin(x))))')
		self.assertEqual (ast2py (p ('cos**-1 0 \\log_2 8')), 'acos(0)*(ln(8) / ln(2))')
		self.assertEqual (ast2py (p ('N sin sqrt[3] \\log_2 8')), 'N(sin((ln(8) / ln(2))**(1/3)))')
		self.assertEqual (ast2py (p ('sin(x)**-a[b][c].d')), 'sin(x)**-a[b][c].d')
		self.assertEqual (ast2py (p ('sin sin x [2].w')), 'sin(sin(x[2].w))')
		self.assertEqual (ast2py (p ('sin -sin x [2].w')), 'sin(-sin(x[2].w))')
		self.assertEqual (ast2py (p ('sin sin (x) [2].w')), 'sin(sin(x)[2].w)')
		self.assertEqual (ast2py (p ('sin -sin (x) [2].w')), 'sin(-sin(x)[2].w)')
		self.assertEqual (ast2py (p ('sin sin x [2].w ()')), 'sin(sin(x[2].w()))')
		self.assertEqual (ast2py (p ('ln ln x [2].w')), 'ln(ln(x[2].w))')
		self.assertEqual (ast2py (p ('N N sin -a [2]')), 'N(N(sin(-a[2])))')
		self.assertEqual (ast2py (p ('sin sin -x [2].w')), 'sin(sin(-x[2].w))')
		self.assertEqual (ast2py (p ('sin -sin x [2].w')), 'sin(-sin(x[2].w))')
		self.assertEqual (ast2py (p ('sin(a)**b[2]')), 'sin(a)**b[2]')
		self.assertEqual (ast2py (p ('sin**-a[b][c].d x')), 'sin(x)**-a[b][c].d')
		self.assertEqual (ast2py (p ('sin**-a[b][c].d (x)')), 'sin**-a[b][c].d(x)')
		self.assertEqual (ast2py (p ('sin**-a[b][c].d {(x)}')), 'sin(x)**-a[b][c].d')
		self.assertEqual (ast2py (p ('sin**-a[b][c] (x)')), 'sin(x)**-a[b][c]')
		self.assertEqual (ast2py (p ('\\int**-a[b][c] x')), 'Integral(x, (, 0, -a[b][c]))')
		self.assertEqual (ast2py (p ('\\int**-a[b][c].d (x)')), 'Integral(1, (, 0, -a[b][c].d(x)))')
		self.assertEqual (ast2py (p ('\\int**-a[b][c].d {(x)}')), 'Integral((x), (, 0, -a[b][c].d))')
		self.assertEqual (ast2py (p ('\\int**-a[b][c].d (x) y')), 'Integral(y, (, 0, -a[b][c].d(x)))')
		self.assertEqual (ast2py (p ('\\int**-a[b][c].d {(x)} y')), 'Integral((x)*y, (, 0, -a[b][c].d))')
		self.assertEqual (ast2py (p ('\\int**a.b[2] x dx')), 'Integral(x, (x, 0, a.b[2]))')

		self.assertEqual (ast2py (p ('d/dx (real = True)')), 'Derivative(Eq(real, True), x)')
		self.assertEqual (ast2py (p ('f {\\left(x\\right)}')), "Function('f')(x)")
		self.assertEqual (ast2py (p ('a.b {(x)}')), 'a.b*(x)')
		self.assertEqual (ast2py (p ('a.b {\\left(x\\right)}')), 'a.b(x)')
		self.assertEqual (ast2py (p ('\\log_{|x|} y')), 'ln(y) / ln(abs(x))')
		self.assertEqual (ast2py (p ('|\\int a + b dx|')), 'abs(Integral(a + b, x))')
		self.assertEqual (ast2py (p ('\\int deg N dx')), 'Integral(deg(N), x)')
		self.assertEqual (ast2py (p ('a \\int x dx / c')), '(a*Integral(x, x)) / c')
		self.assertEqual (ast2py (p ('\\int x dx b / c')), '(Integral(x, x)*b) / c')
		self.assertEqual (ast2py (p ('a \\int x dx b / c')), '(a*Integral(x, x)*b) / c')
		self.assertEqual (ast2py (p ('a {\\lim_{x\\to0} \\int x dx} / b')), "(a*Limit(Integral(x, x), x, 0, dir = '+-')) / b")
		self.assertEqual (ast2py (p ('a {\\sum_{x=0}^1 \\int x dx} / b')), '(a*Sum(Integral(x, x), (x, 0, 1))) / b')
		self.assertEqual (ast2py (p ('a / \\int x dx * c')), 'a / Integral(x, x)*c')
		self.assertEqual (ast2py (p ('a / b \\int x dx * c')), 'a / (b*Integral(x, x))*c')

		self.assertEqual (ast2py (p ('cos')), 'cos')
		self.assertEqual (ast2py (p ('f = cos')), 'f = cos')
		self.assertEqual (ast2py (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)')), 'Matrix([[0, pi], [-pi, 0]]).applyfunc(cos)')
		self.assertEqual (ast2py (p ('$sin (real = True)')), "Symbol('sin', real = True)")
		self.assertEqual (ast2py (p ('sin = $(real = True)')), "sin = Symbol('', real = True)")

	def test_ast2tex2ast (self):
		self.assertEqual (ast2tex2ast (p ('1')), ('#', '1'))
		self.assertEqual (ast2tex2ast (p ('1.')), ('#', '1.'))
		self.assertEqual (ast2tex2ast (p ('.1')), ('#', '0.1'))
		self.assertEqual (ast2tex2ast (p ('1e20')), ('#', '1e+20'))
		self.assertEqual (ast2tex2ast (p ('1E-20')), ('#', '1e-20'))
		self.assertEqual (ast2tex2ast (p ('1.e+20')), ('#', '1.e+20'))
		self.assertEqual (ast2tex2ast (p ('.1e-20')), ('#', '0.1e-20'))
		self.assertEqual (ast2tex2ast (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')), ('-func', 'sin', (('#', '-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901'),)))
		self.assertEqual (ast2tex2ast (p ('x')), ('@', 'x'))
		self.assertEqual (ast2tex2ast (p ('xy')), ('@', 'xy'))
		self.assertEqual (ast2tex2ast (p ('dx')), ('@', 'dx'))
		self.assertEqual (ast2tex2ast (p ('partialx')), ('@', 'partialx'))
		self.assertEqual (ast2tex2ast (p ('\\partial x')), ('@', 'partialx'))
		self.assertEqual (ast2tex2ast (p ('x d  y')), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x partial y')), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x \\partial  y')), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x dx dy y')), ('*', (('@', 'x'), ('@', 'dx'), ('@', 'dy'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x partialx partialy y')), ('*', (('@', 'x'), ('@', 'partialx'), ('@', 'partialy'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('-1')), ('#', '-1'))
		self.assertEqual (ast2tex2ast (p ('-x')), ('-', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('{x}')), ('@', 'x'))
		self.assertEqual (ast2tex2ast (p ('()')), ('(', (',', ())))
		self.assertEqual (ast2tex2ast (p ('(x)')), ('(', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('(x,)')), ('(', (',', (('@', 'x'),))))
		self.assertEqual (ast2tex2ast (p ('(x,y)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2tex2ast (p ('(x,y,)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2tex2ast (p ('[]')), ('[', ()))
		self.assertEqual (ast2tex2ast (p ('[x]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('[x,]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('[x,y]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('[x,y,]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('"x\\x20\\n"')), ('"', 'x \n'))
		self.assertEqual (ast2tex2ast (p ("'x\\x20\\n'")), ('"', 'x \n'))
		self.assertEqual (ast2tex2ast (p ('|x|')), ('|', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('x!')), ('!', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('x+y')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x-y')), ('+', (('@', 'x'), ('-', ('@', 'y')))))
		self.assertEqual (ast2tex2ast (p ('x*y')), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x y')), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x(y)')), ('-ufunc', 'x', (('@', 'y'),)))
		self.assertEqual (ast2tex2ast (p ('x*(y)')), ('*', (('@', 'x'), ('(', ('@', 'y'))), {1}))
		self.assertEqual (ast2tex2ast (p ('x/y')), ('/', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2tex2ast (p ('x^y')), ('^', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2tex2ast (p ('log x')), ('-log', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('log {x}')), ('-log', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('log (x)')), ('-log', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('\\log_2 x')), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('\\log_2 {x}')), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('\\log_2 (x)')), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('sqrt x')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('sqrt {x}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('sqrt (x)')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('sqrt {(x)}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('sqrt[3] x')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2tex2ast (p ('sqrt[3] {x}')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2tex2ast (p ('sqrt[3] {(x)}')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2tex2ast (p ('sqrt[3] (x)')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2tex2ast (p ('sin x')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('sin^2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('sin (x)')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('sin (x)^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('sin {x}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('sin {(x)}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('{sin x}^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('sin**2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('sin**-1 x')), ('-func', 'asin', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('sin(x)**-1')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '-1')))
		self.assertEqual (ast2tex2ast (p ('acos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('\\arccos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('sin(x**2)')), ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('sin(x**2)**2')), ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('(sin(x**2)**2)')), ('(', ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('ln(x**2)')), ('-log', ('^', ('@', 'x'), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('ln(x**2)**2')), ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('(ln(x**2)**2)')), ('(', ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('gamma(x**2)')), ('-func', 'Gamma', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('gamma(x**2)**2')), ('^', ('-func', 'Gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('(gamma(x**2)**2)')), ('(', ('^', ('-func', 'Gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('{gamma}[2]')), ('-idx', ('@', 'gamma'), (('#', '2'),)))
		self.assertEqual (ast2tex2ast (p ('{Gamma}[2]')), ('-idx', ('@', 'Gamma'), (('#', '2'),)))
		self.assertEqual (ast2tex2ast (p ('f{(x)}')), ('*', (('@', 'f'), ('(', ('@', 'x'))), {1}))
		self.assertEqual (ast2tex2ast (p ("f{(x)}'(0)")), ('*', (('@', 'f'), ('-diffp', ('(', ('@', 'x')), 1), ('(', ('#', '0'))), {1}))
		self.assertEqual (ast2tex2ast (p ("f{(x)}'{(0)}")), ('*', (('@', 'f'), ('-diffp', ('(', ('@', 'x')), 1), ('(', ('#', '0'))), {1}))
		self.assertEqual (ast2tex2ast (p ('\\operatorname{x_{1}}{\\left(x \\right)}')), ('-ufunc', 'x1', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('\\lim_{x\\to0} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2tex2ast (p ('\\lim_{x\\to0^+} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2tex2ast (p ('\\lim_{x\\to0**-} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2tex2ast (p ('Limit (1/x, x, 0)')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2tex2ast (p ('Limit (1/x, x, 0, "-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2tex2ast (p ('Limit (1/x, x, 0, dir="+-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2tex2ast (p ('limit (1/x, x, 0)')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2tex2ast (p ('limit (1/x, x, 0, "-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2tex2ast (p ('limit (1/x, x, 0, dir="+-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2tex2ast (p ('\\sum_{n=0}^\\infty x^n/n!')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2tex2ast (p ('Sum (x^n/n!, (n, 0, oo))')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2tex2ast (p ('summation (x^n/n!, (n, 0, oo))')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2tex2ast (p ('d/dx x**2y**2z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 1),)))
		self.assertEqual (ast2tex2ast (p ('d^2/dx^2 x^2y**2z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 2),)))
		self.assertEqual (ast2tex2ast (p ('d^3/dx^2dy x^2y**2z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 2), ('y', 1))))
		self.assertEqual (ast2tex2ast (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2tex2ast (p ('d**1.5 / dx dy x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '1.5')), ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2tex2ast (p ('d**-2 / dx dy x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '-2')), ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2tex2ast (p ('d**2 / dx**1.5 x**2y**2')), ('/', ('(', ('^', ('@', 'd'), ('#', '2')), True), ('*', (('^', ('@', 'dx'), ('#', '1.5')), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2tex2ast (p ('Derivative (x^2y**2z, x, 2, y, z)')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2tex2ast (p ('diff (x^2y**2z, x, 2, y, z)')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2tex2ast (p ('\\int dx')), ('-intg', None, ('@', 'dx')))
		self.assertEqual (ast2tex2ast (p ('\\int x dx')), ('-intg', ('@', 'x'), ('@', 'dx')))
		self.assertEqual (ast2tex2ast (p ('\\int_0^1 x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2tex2ast (p ('\\int_0^1 \\int y dy dx')), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2tex2ast (p ('Integral (\\int y dy, (x, 0, 1))')), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2tex2ast (p ('integrate (\\int y dy, (x, 0, 1))')), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))

		self.assertEqual (ast2tex2ast (p ('\\[1,]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2tex2ast (p ('\\[1,2]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2tex2ast (p ('\\[1,2,]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2tex2ast (p ('\\[[1,],]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2tex2ast (p ('\\[[1,],[2,]]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2tex2ast (p ('\\[[1,],[2,],]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2tex2ast (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2tex2ast (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2tex2ast (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}')), ('-mat', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2tex2ast (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2tex2ast (p ('\\[1,2]!')), ('!', ('-mat', ((('#', '1'),), (('#', '2'),)))))
		self.assertEqual (ast2tex2ast (p ('\\[[0,1],[1,0]]**x')), ('^', ('-mat', ((('#', '0'), ('#', '1')), (('#', '1'), ('#', '0')))), ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2],[3,4]]!')), ('!', ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2,3],[4,5,6]].T')), ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2,3],[4,5,6]].T.T')), ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'), 'T'))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2,3],[4,5,6]].T.T.T')), ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'), 'T'), 'T'))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2,3],[4,5,6]].transpose ()')), ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()')), ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()')), ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2tex2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()')), ('.', ('.', ('.', ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()), 'T'), 'T'), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2tex2ast (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]')), ('*', (('-mat', ((('@', 'A'), ('@', 'B')), (('@', 'C'), ('@', 'D')))), ('-mat', ((('@', 'x'),), (('@', 'y'),)))), {1}))
		self.assertEqual (ast2tex2ast (p ('\\[[1, 2], [3')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('-dict', ())))))
		self.assertEqual (ast2tex2ast (p ('\\[[1, 2], [3]]')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('-dict', ())))))
		self.assertEqual (ast2tex2ast (p ('\\[[1], [2, 3]]')), ('-mat', ((('#', '1'), ('-dict', ())), (('#', '2'), ('#', '3')))))

		self.assertEqual (ast2tex2ast (p ('-1**x')), ('-', ('^', ('#', '1'), ('@', 'x'))))
		self.assertEqual (ast2tex2ast (p ('{-1}**x')), ('^', ('(', ('#', '-1')), ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('-{-1}**x')), ('-', ('^', ('(', ('#', '-1')), ('@', 'x'))))
		self.assertEqual (ast2tex2ast (p ('(-1)**x')), ('^', ('(', ('#', '-1')), ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('-(-1)**x')), ('-', ('^', ('(', ('#', '-1')), ('@', 'x'))))
		self.assertEqual (ast2tex2ast (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (ast2tex2ast (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (ast2tex2ast (p ('1 if x < y')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))),)))
		self.assertEqual (ast2tex2ast (p ('1 if x < y else 3')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), True))))
		self.assertEqual (ast2tex2ast (p ('1 if x < y else 3 if x < z')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))))))
		self.assertEqual (ast2tex2ast (p ('1 if x < y else 3 if x < z else 5')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2tex2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2tex2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2tex2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'x'), (('<', ('@', 'w')),))))))
		self.assertEqual (ast2tex2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'x'), (('<', ('@', 'w')),))))))
		self.assertEqual (ast2tex2ast (p ('x**y.a')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a')))
		self.assertEqual (ast2tex2ast (p ('x**y.a ()')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a', ())))
		self.assertEqual (ast2tex2ast (p ('x**y.a.b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b')))
		self.assertEqual (ast2tex2ast (p ('x**y.a.b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b', ())))
		self.assertEqual (ast2tex2ast (p ('x**y.a ().b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b')))
		self.assertEqual (ast2tex2ast (p ('x**y.a ().b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b', ())))
		self.assertEqual (ast2tex2ast (p ('{1 if x < 0 else 3} if x < 1 else 5')), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '3'), True))), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))))
		self.assertEqual (ast2tex2ast (p ('1 if {True if x < 0 else False} else 5')), ('-piece', ((('#', '1'), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('@', 'False'), True)))), (('#', '5'), True))))
		self.assertEqual (ast2tex2ast (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}')), ('-piece', ((('#', '1'), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('@', 'False'), True)))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))), True))))
		self.assertEqual (ast2tex2ast (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '9'), True))), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('@', 'False'), True)))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '2')),))), (('#', '5'), True))), True))))
		self.assertEqual (ast2tex2ast (p ('x.y!')), ('!', ('.', ('@', 'x'), 'y')))
		self.assertEqual (ast2tex2ast (p ('x.y**2')), ('^', ('.', ('@', 'x'), 'y'), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('x.y ()!')), ('!', ('.', ('@', 'x'), 'y', ())))
		self.assertEqual (ast2tex2ast (p ('x.y ()**2')), ('^', ('.', ('@', 'x'), 'y', ()), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('x**y.a!')), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a'))))
		self.assertEqual (ast2tex2ast (p ('x**y.a**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a'), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('x**y.a ()!')), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a', ()))))
		self.assertEqual (ast2tex2ast (p ('x**y.a ()**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a', ()), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('lambda: x')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2tex2ast (p ('lambda x: x**2')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2tex2ast (p ('lambda x, y: x + y')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2tex2ast (p ('lambda x, y, z: x + y + z')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))
		self.assertEqual (ast2tex2ast (p ('1, lambda: x')), (',', (('#', '1'), ('-lamb', ('@', 'x'), ()))))
		self.assertEqual (ast2tex2ast (p ('1, lambda x: x**2')), (',', (('#', '1'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))))
		self.assertEqual (ast2tex2ast (p ('1, lambda x, y: x + y')), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))))
		self.assertEqual (ast2tex2ast (p ('1, lambda x, y, z: x + y + z')), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))))
		self.assertEqual (ast2tex2ast (p ('f = lambda: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ())))
		self.assertEqual (ast2tex2ast (p ('f = lambda x: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x',))))
		self.assertEqual (ast2tex2ast (p ('f = lambda x, y: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y'))))
		self.assertEqual (ast2tex2ast (p ('f = lambda x, y, z: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y', 'z'))))
		self.assertEqual (ast2tex2ast (p ('\\left(\\left(\\right) \\mapsto x \\right)')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2tex2ast (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2tex2ast (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2tex2ast (p ('\\lambda: x')), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (ast2tex2ast (p ('\\lambda x: x')), ('-slice', ('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'x'), None))
		self.assertEqual (ast2tex2ast (p ('\\lambda x, y: x')), (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('-slice', ('@', 'y'), ('@', 'x'), None))))
		self.assertEqual (ast2tex2ast (p ('{lambda}: x')), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (ast2tex2ast (p ('{lambda} x: x')), ('-slice', ('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'x'), None))
		self.assertEqual (ast2tex2ast (p ('{lambda} x, y: x')), (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('-slice', ('@', 'y'), ('@', 'x'), None))))
		self.assertEqual (ast2tex2ast (p ('$')), ('-sym', ''))
		self.assertEqual (ast2tex2ast (p ('$s')), ('-sym', 's'))
		self.assertEqual (ast2tex2ast (p ('$ (real = True)')), ('-sym', '', (('real', ('@', 'True')),)))
		self.assertEqual (ast2tex2ast (p ('$s (real = True)')), ('-sym', 's', (('real', ('@', 'True')),)))

		self.assertEqual (ast2tex2ast (p ('eye (2).is_diagonal ()')), ('.', ('-mat', ((('#', '1'), ('#', '0')), (('#', '0'), ('#', '1')))), 'is_diagonal', ()))
		self.assertEqual (ast2tex2ast (p ('a [2]')), ('-idx', ('@', 'a'), (('#', '2'),)))
		self.assertEqual (ast2tex2ast (p ('a [2,3]')), ('-idx', ('@', 'a'), (('#', '2'), ('#', '3'))))
		self.assertEqual (ast2tex2ast (p ('a * [2]')), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (ast2tex2ast (p ('a * {-1}[x]')), ('*', (('@', 'a'), ('-idx', ('(', ('#', '-1')), (('@', 'x'),))), {1}))
		self.assertEqual (ast2tex2ast (p ('a * [x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (ast2tex2ast (p ('N (1/2)')), ('-func', 'N', (('/', ('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ("S ('1/2')")), ('-func', 'S', (('"', '1/2'),)))
		self.assertEqual (ast2tex2ast (p ("N (S ('1/2'))")), ('-func', 'N', (('-func', 'S', (('"', '1/2'),)),)))
		self.assertEqual (ast2tex2ast (p ('S.Half')), ('.', ('@', 'S'), 'Half'))
		self.assertEqual (ast2tex2ast (p ('N S.Half')), ('-func', 'N', (('.', ('@', 'S'), 'Half'),)))
		self.assertEqual (ast2tex2ast (p ('o [i].t')), ('.', ('-idx', ('@', 'o'), (('@', 'i'),)), 't'))
		self.assertEqual (ast2tex2ast (p ('o [i]**2')), ('^', ('-idx', ('@', 'o'), (('@', 'i'),)), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('o [i]!')), ('!', ('-idx', ('@', 'o'), (('@', 'i'),))))
		self.assertEqual (ast2tex2ast (p ("'Hello' [::-1]")), ('-idx', ('"', 'Hello'), (('-slice', False, False, ('#', '-1')),)))
		self.assertEqual (ast2tex2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]')), ('-idx', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), (('-slice', False, False, None), ('#', '1'))))
		self.assertEqual (ast2tex2ast (p ('\\binom96')), ('-func', 'binomial', (('#', '9'), ('#', '6'))))
		self.assertEqual (ast2tex2ast (p ('binomial (x, y)')), ('-func', 'binomial', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('y - 1*x')), ('+', (('@', 'y'), ('-', ('*', (('#', '1'), ('@', 'x')))))))
		self.assertEqual (ast2tex2ast (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'))), ('#', '1'))), ('@', 'x'), ('=', ('@', 'domain'), ('"', 'ZZ')))))
		self.assertEqual (ast2tex2ast (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'), ('@', 'y'))))), ('@', 'x'), ('@', 'y'), ('=', ('@', 'domain'), ('"', 'CC')))))
		self.assertEqual (ast2tex2ast (p ('oct(10)')), ('-func', 'oct', (('#', '10'),)))
		self.assertEqual (ast2tex2ast (p ('(1,) + (2,)')), ('+', (('(', (',', (('#', '1'),))), ('(', (',', (('#', '2'),))))))
		self.assertEqual (ast2tex2ast (p ('[1] + [2]')), ('+', (('[', (('#', '1'),)), ('[', (('#', '2'),)))))
		self.assertEqual (ast2tex2ast (p ("'a' + 'b'")), ('+', (('"', 'a'), ('"', 'b'))))
		self.assertEqual (ast2tex2ast (p ('(1,) * 2')), ('*', (('(', (',', (('#', '1'),))), ('#', '2')), {1}))
		self.assertEqual (ast2tex2ast (p ('[1] * 2')), ('*', (('[', (('#', '1'),)), ('#', '2')), {1}))
		self.assertEqual (ast2tex2ast (p ("'a' * 2")), ('*', (('"', 'a'), ('#', '2')), {1}))
		self.assertEqual (ast2tex2ast (p ('Lambda (x, x**2)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2tex2ast (p ('beta (2, 3)')), ('-func', 'beta', (('#', '2'), ('#', '3'))))
		self.assertEqual (ast2tex2ast (p ('{x d} y')), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (ast2tex2ast (p ('ln((a)**b)')), ('-log', ('^', ('(', ('@', 'a')), ('@', 'b'))))
		self.assertEqual (ast2tex2ast (p ('a * \\int dx + {\\int dx dx}')), ('+', (('*', (('@', 'a'), ('-intg', None, ('@', 'dx')))), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx')), {1}))))
		self.assertEqual (ast2tex2ast (p ('1 if {a = x if z} else 0 if y')), ('-piece', ((('#', '1'), ('=', ('@', 'a'), ('-piece', ((('@', 'x'), ('@', 'z')),)))), (('#', '0'), ('@', 'y')))))
		self.assertEqual (ast2tex2ast (p ('a, lambda: b = 1')), (',', (('@', 'a'), ('-lamb', ('=', ('@', 'b'), ('#', '1')), ()))))
		self.assertEqual (ast2tex2ast (p ('a * [2]')), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (ast2tex2ast (p ('sqrt(1, 2)')), ('-sqrt', (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (ast2tex2ast (p ('x*[][y]')), ('*', (('@', 'x'), ('-idx', ('[', ()), (('@', 'y'),))), {1}))
		self.assertEqual (ast2tex2ast (p ('lambda: x:')), ('-lamb', ('-slice', ('@', 'x'), False, None), ()))
		self.assertEqual (ast2tex2ast (p ('a*[x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (ast2tex2ast (p ('a*()**2')), ('*', (('@', 'a'), ('^', ('(', (',', ())), ('#', '2'))), {1}))
		self.assertEqual (ast2tex2ast (p ('a*().t')), ('*', (('@', 'a'), ('.', ('(', (',', ())), 't')), {1}))
		self.assertEqual (ast2tex2ast (p ('a*()[2]')), ('*', (('@', 'a'), ('-idx', ('(', (',', ())), (('#', '2'),))), {1}))
		self.assertEqual (ast2tex2ast (p ('o.f*(a)')), ('*', (('.', ('@', 'o'), 'f'), ('(', ('@', 'a'))), {1}))
		self.assertEqual (ast2tex2ast (p ('o.f*{1+2}')), ('*', (('.', ('@', 'o'), 'f'), ('(', ('+', (('#', '1'), ('#', '2'))))), {1}))
		self.assertEqual (ast2tex2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (ast2tex2ast (p ('y**z [w]')), ('^', ('@', 'y'), ('-idx', ('@', 'z'), (('@', 'w'),))))
		self.assertEqual (ast2tex2ast (p ('{y**z} [w]')), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))
		self.assertEqual (ast2tex2ast (p ('x {y**z} [w]')), ('*', (('@', 'x'), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))))
		self.assertEqual (ast2tex2ast (p ('{x y**z} [w]')), ('-idx', ('(', ('*', (('@', 'x'), ('^', ('@', 'y'), ('@', 'z'))))), (('@', 'w'),)))
		self.assertEqual (ast2tex2ast (p ('Min (x, y, z)')), ('-func', 'Min', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2tex2ast (p ('Max (x, y, z)')), ('-func', 'Max', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2tex2ast (p ('\\Re (z)')), ('-func', 'Re', (('@', 'z'),)))
		self.assertEqual (ast2tex2ast (p ('\\Im (z)')), ('-func', 'Im', (('@', 'z'),)))
		self.assertEqual (ast2tex2ast (p ('re (z)')), ('-func', 'Re', (('@', 'z'),)))
		self.assertEqual (ast2tex2ast (p ('im (z)')), ('-func', 'Im', (('@', 'z'),)))
		self.assertEqual (ast2tex2ast (p ('{}')), ('-dict', ()))
		self.assertEqual (ast2tex2ast (p ('{1: 2}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('{1: 2,}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('{1: 2, 3: 4}')), ('-dict', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2tex2ast (p ('set ()')), ('-set', ()))
		self.assertEqual (ast2tex2ast (p ('\\{}')), ('-set', ()))
		self.assertEqual (ast2tex2ast (p ('\\{1}')), ('-set', (('#', '1'),)))
		self.assertEqual (ast2tex2ast (p ('\\{1,2}')), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('{1,2}')), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('1 in {1,2,3}')), ('<>', ('#', '1'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2tex2ast (p ('1 \\in {1,2,3}')), ('<>', ('#', '1'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2tex2ast (p ('4 in {1,2,3}')), ('<>', ('#', '4'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2tex2ast (p ('4 \\in {1,2,3}')), ('<>', ('#', '4'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2tex2ast (p ('4 not in {1,2,3}')), ('<>', ('#', '4'), (('notin', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2tex2ast (p ('4 \\notin {1,2,3}')), ('<>', ('#', '4'), (('notin', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2tex2ast (p ('{1,2} - {2,3}')), ('+', (('-set', (('#', '1'), ('#', '2'))), ('-', ('-set', (('#', '2'), ('#', '3')))))))
		self.assertEqual (ast2tex2ast (p ('{1,2} || {2,3}')), ('||', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2tex2ast (p ('{1,2} ^^ {2,3}')), ('^^', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2tex2ast (p ('{1,2} && {2,3}')), ('&&', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2tex2ast (p ('{1,2} || {2,3} || {3,4}')), ('||', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2tex2ast (p ('{1,2} ^^ {2,3} ^^ {3,4}')), ('^^', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2tex2ast (p ('{1,2} && {2,3} && {3,4}')), ('&&', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2tex2ast (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}')), ('||', (('-set', (('#', '1'), ('#', '2'))), ('^^', (('-set', (('#', '2'), ('#', '3'))), ('&&', (('-set', (('#', '3'), ('#', '4'))), ('-set', (('#', '4'), ('#', '5'))))))))))
		self.assertEqual (ast2tex2ast (p ('solve (x**2 = 4)')), ('-func', 'solve', (('=', ('^', ('@', 'x'), ('#', '2')), ('#', '4')),)))
		self.assertEqual (ast2tex2ast (p ('Subs (x y, x, 2)')), ('-subs', ('*', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('Subs (x y, (x, y), (2, 3))')), ('-subs', ('*', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))))
		self.assertEqual (ast2tex2ast (p ('(x y).subs (x, 2)')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y')))), ((('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('(x y).subs (x, 2).subs (y, 3)')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y')))), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))))
		self.assertEqual (ast2tex2ast (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y'), ('@', 'z'), ('@', 'w')))), ((('@', 'z'), ('#', '4')), (('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')), (('@', 'w'), ('#', '5')))))
		self.assertEqual (ast2tex2ast (p ('x or y')), ('-or', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x or y or z')), ('-or', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2tex2ast (p ('x and y')), ('-and', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('x and y and z')), ('-and', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2tex2ast (p ('x and y or z')), ('-or', (('-and', (('@', 'x'), ('@', 'y'))), ('@', 'z'))))
		self.assertEqual (ast2tex2ast (p ('x and {y or z}')), ('-and', (('@', 'x'), ('(', ('-or', (('@', 'y'), ('@', 'z')))))))
		self.assertEqual (ast2tex2ast (p ('not x or y')), ('-or', (('-not', ('@', 'x')), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('not {x or y}')), ('-not', ('(', ('-or', (('@', 'x'), ('@', 'y'))))))
		self.assertEqual (ast2tex2ast (p ('not x and y')), ('-and', (('-not', ('@', 'x')), ('@', 'y'))))
		self.assertEqual (ast2tex2ast (p ('not {x and y}')), ('-not', ('(', ('-and', (('@', 'x'), ('@', 'y'))))))
		self.assertEqual (ast2tex2ast (p ('x or not y')), ('-or', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (ast2tex2ast (p ('x and not y')), ('-and', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (ast2tex2ast (p ('not x')), ('-not', ('@', 'x')))
		self.assertEqual (ast2tex2ast (p ('not not x')), ('-not', ('-not', ('@', 'x'))))
		self.assertEqual (ast2tex2ast (p ('not not not x')), ('-not', ('-not', ('-not', ('@', 'x')))))
		self.assertEqual (ast2tex2ast (p ('0 or []')), ('-or', (('#', '0'), ('[', ()))))
		self.assertEqual (ast2tex2ast (p ('0 or [1]')), ('-or', (('#', '0'), ('[', (('#', '1'),)))))
		self.assertEqual (ast2tex2ast (p ('1 and []')), ('-and', (('#', '1'), ('[', ()))))
		self.assertEqual (ast2tex2ast (p ('1 and [1]')), ('-and', (('#', '1'), ('[', (('#', '1'),)))))
		self.assertEqual (ast2tex2ast (p ('not []')), ('-not', ('[', ())))
		self.assertEqual (ast2tex2ast (p ('not [1]')), ('-not', ('[', (('#', '1'),))))
		self.assertEqual (ast2tex2ast (p ('not None')), ('-not', ('@', 'None')))
		self.assertEqual (ast2tex2ast (p ('True + True')), ('+', (('@', 'True'), ('@', 'True'))))
		self.assertEqual (ast2tex2ast (p ('False - True')), ('+', (('@', 'False'), ('-', ('@', 'True')))))
		self.assertEqual (ast2tex2ast (p ('True * True')), ('*', (('@', 'True'), ('@', 'True'))))
		self.assertEqual (ast2tex2ast (p ('(2 > 1) x')), ('*', (('(', ('<>', ('#', '2'), (('>', ('#', '1')),))), ('@', 'x'))))
		self.assertEqual (ast2tex2ast (p ('(2 > 1) + (1 < 2)')), ('+', (('(', ('<>', ('#', '2'), (('>', ('#', '1')),))), ('(', ('<>', ('#', '1'), (('<', ('#', '2')),))))))
		self.assertEqual (ast2tex2ast (p ('\\[{[a, b]},]')), ('-mat', ((('[', (('@', 'a'), ('@', 'b'))),),)))
		self.assertEqual (ast2tex2ast (p ('{{a:b:c}:d}')), ('-dict', ((('(', ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c'))), ('@', 'd')),)))
		self.assertEqual (ast2tex2ast (p ('{a:{b:c:d}}')), ('-dict', ((('@', 'a'), ('(', ('-slice', ('@', 'b'), ('@', 'c'), ('@', 'd')))),)))
		self.assertEqual (ast2tex2ast (p ('{a:b:c} = {a:b:c}')), ('=', ('(', ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c'))), ('(', ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c')))))
		self.assertEqual (ast2tex2ast (p ('\\[1:2:3]')), ('-mat', ((('(', ('-slice', ('#', '1'), ('#', '2'), ('#', '3'))),),)))
		self.assertEqual (ast2tex2ast (p ('-{not x}')), ('-', ('(', ('-not', ('@', 'x')))))
		self.assertEqual (ast2tex2ast (p ('x < y in [y] in [[y]] != 2 > 1')), ('<>', ('@', 'x'), (('<', ('@', 'y')), ('in', ('[', (('@', 'y'),))), ('in', ('[', (('[', (('@', 'y'),)),))), ('!=', ('#', '2')), ('>', ('#', '1')))))
		self.assertEqual (ast2tex2ast (p ('x < y < z < w')), ('<>', ('@', 'x'), (('<', ('@', 'y')), ('<', ('@', 'z')), ('<', ('@', 'w')))))
		self.assertEqual (ast2tex2ast (p ('\\[]')), ('-mat', ()))
		self.assertEqual (ast2tex2ast (p ('\\[[]]')), ('-mat', ()))
		self.assertEqual (ast2tex2ast (p ('\\[[], []]')), ('-mat', ()))
		self.assertEqual (ast2tex2ast (p ('\\{a:b}')), ('-set', (('(', ('-slice', ('@', 'a'), ('@', 'b'), None)),)))
		self.assertEqual (ast2tex2ast (p ('{-x} y / z')), ('/', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'z')))
		self.assertEqual (ast2tex2ast (p ('d / dz {-1} a')), ('-diff', ('(', ('*', (('#', '-1'), ('@', 'a')))), 'd', (('z', 1),)))
		self.assertEqual (ast2tex2ast (p ('1 / {-2} x')), ('/', ('#', '1'), ('*', (('#', '-2'), ('@', 'x')))))
		self.assertEqual (ast2tex2ast (p ('\\sum_{x=0}^b {-x} y')), ('-sum', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'x'), ('#', '0'), ('@', 'b')))
		self.assertEqual (ast2tex2ast (p ('\\lim_{x\\to0} {-x} y')), ('-lim', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2tex2ast (p ('\\int a / -1 dx')), ('-intg', ('/', ('@', 'a'), ('#', '-1')), ('@', 'dx')))
		self.assertEqual (ast2tex2ast (p ('\\[[[x]]]')), ('-mat', ((('[', (('@', 'x'),)),),)))
		self.assertEqual (ast2tex2ast (p ('\\[[[1, 2]], [[3]]]')), ('-mat', ((('[', (('#', '1'), ('#', '2'))),), (('[', (('#', '3'),)),))))
		self.assertEqual (ast2tex2ast (p ('{1/x}.limit (x, 0, "-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2tex2ast (p ('{x^2y**2z}.diff (x, 2, y, z)')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2tex2ast (p ('{x y}.integrate ((x, 0, 1))')), ('-intg', ('*', (('@', 'x'), ('@', 'y'))), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2tex2ast (p ('\\sqrt (a:b)')), ('-sqrt', ('-slice', ('@', 'a'), ('@', 'b'), None)))
		self.assertEqual (ast2tex2ast (p ('\\sqrt[3] (a:b)')), ('-sqrt', ('-slice', ('@', 'a'), ('@', 'b'), None), ('#', '3')))
		self.assertEqual (ast2tex2ast (p ('? ()')), ('-ufunc', '?', ()))
		self.assertEqual (ast2tex2ast (p ('? (x)')), ('-ufunc', '?', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('? (x) (2)')), ('*', (('-ufunc', '?', (('@', 'x'),)), ('(', ('#', '2'))), {1}))
		self.assertEqual (ast2tex2ast (p ('? (2)')), ('-ufunc', '?', (('#', '2'),)))
		self.assertEqual (ast2tex2ast (p ('?f (x, y, real = True)')), ('-ufunc', 'f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2tex2ast (p ('?\\alpha(x)')), ('-ufunc', 'alpha', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('?beta(y)')), ('-ufunc', '?beta', (('@', 'y'),)))
		self.assertEqual (ast2tex2ast (p ("Function ('f', real = True) (x, y)")), ('-ufunc', 'f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2tex2ast (p ("x'")), ('-diffp', ('@', 'x'), 1))
		self.assertEqual (ast2tex2ast (p ("x''")), ('-diffp', ('@', 'x'), 2))
		self.assertEqual (ast2tex2ast (p ("{x + y}'")), ('-diffp', ('(', ('+', (('@', 'x'), ('@', 'y')))), 1))
		self.assertEqual (ast2tex2ast (p ("a [b]'")), ('-diffp', ('-idx', ('@', 'a'), (('@', 'b'),)), 1))
		self.assertEqual (ast2tex2ast (p ("a.b ()'")), ('-diffp', ('.', ('@', 'a'), 'b', ()), 1))
		self.assertEqual (ast2tex2ast (p ("{x/y}'")), ('-diffp', ('(', ('/', ('@', 'x'), ('@', 'y'))), 1))
		self.assertEqual (ast2tex2ast (p ("1'['ac']")), ('-idx', ('-diffp', ('#', '1'), 1), (('"', 'ac'),)))
		self.assertEqual (ast2tex2ast (p ("|x|'")), ('-diffp', ('|', ('@', 'x')), 1))
		self.assertEqual (ast2tex2ast (p ("| 'str'|'")), ('-diffp', ('|', ('"', 'str')), 1))
		self.assertEqual (ast2tex2ast (p ("{x**y}'")), ('-diffp', ('(', ('^', ('@', 'x'), ('@', 'y'))), 1))
		self.assertEqual (ast2tex2ast (p ("{{-1}'}")), ('-diffp', ('(', ('#', '-1')), 1))
		self.assertEqual (ast2tex2ast (p ("{a [b]}''")), ('-diffp', ('-idx', ('@', 'a'), (('@', 'b'),)), 2))
		self.assertEqual (ast2tex2ast (p ("1.'''")), ('-diffp', ('#', '1.'), 3))
		self.assertEqual (ast2tex2ast (p ('x [1]')), ('-idx', ('@', 'x'), (('#', '1'),)))
		self.assertEqual (ast2tex2ast (p ('1 [x]')), ('-idx', ('#', '1'), (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('[1, 2] [x]')), ('-idx', ('[', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('{1, 2} [x]')), ('-idx', ('-set', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('{x: 2} [x]')), ('-idx', ('-dict', ((('@', 'x'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('{y: 2} [x]')), ('-idx', ('-dict', ((('@', 'y'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ("'}'")), ('"', '}'))
		self.assertEqual (ast2tex2ast (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}')), ('*', (('@', 'q'), ('@', 'w'), ('@', 'e'), ('@', 'r'), ('@', 't'), ('@', 'y'), ('@', 'u'), ('@', 'i'), ('@', 'o'), ('@', 'p'), ('@', 'a'), ('@', 's'), ('@', 'd'), ('@', 'f'))))
		self.assertEqual (ast2tex2ast (p ('x, y = 1, 2')), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (ast2tex2ast (p ('x, 2 = 1, 2')), (',', (('@', 'x'), ('=', ('#', '2'), ('#', '1')), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('(x, y) = 1, 2')), (',', (('=', ('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1')), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('1; x, y = 1, 2')), (';', (('#', '1'), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))))
		self.assertEqual (ast2tex2ast (p ('1; x, 2 = 1, 2')), (';', (('#', '1'), (',', (('@', 'x'), ('=', ('#', '2'), ('#', '1')), ('#', '2'))))))
		self.assertEqual (ast2tex2ast (p ('1; (x, y) = 1, 2')), (';', (('#', '1'), (',', (('=', ('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1')), ('#', '2'))))))
		self.assertEqual (ast2tex2ast (p ('f()()')), ('*', (('-ufunc', 'f', ()), ('(', (',', ()))), {1}))
		self.assertEqual (ast2tex2ast (p ('f()*()')), ('*', (('-ufunc', 'f', ()), ('(', (',', ()))), {1}))
		self.assertEqual (ast2tex2ast (p ('f*()*()')), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1, 2}))
		self.assertEqual (ast2tex2ast (p ('f*()()')), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1}))

		self.assertEqual (ast2tex2ast (p ('dy / dx')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2tex2ast (p ('dy / dx z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z')), {1}))
		self.assertEqual (ast2tex2ast (p ('d**2 y / dx**2')), ('-diff', ('@', 'y'), 'd', (('x', 2),)))
		self.assertEqual (ast2tex2ast (p ('d**2 y / dx**2 z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 2),)), ('@', 'z')), {1}))
		self.assertEqual (ast2tex2ast (p ('d**2 y / dx dy')), ('-diff', ('@', 'y'), 'partial', (('x', 1), ('y', 1))))
		self.assertEqual (ast2tex2ast (p ('d**2 y / dx dy z')), ('*', (('-diff', ('@', 'y'), 'partial', (('x', 1), ('y', 1))), ('@', 'z')), {1}))
		self.assertEqual (ast2tex2ast (p ('\\frac{dy}{dx}')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2tex2ast (p ('\\frac{dy}{dx} z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z')), {1}))
		self.assertEqual (ast2tex2ast (p ('\\frac{d**2}{dx**2}')), ('/', ('(', ('^', ('@', 'd'), ('#', '2')), True), ('^', ('@', 'dx'), ('#', '2'))))
		self.assertEqual (ast2tex2ast (p ('\\frac{d**2}{dx**2} z')), ('-diff', ('@', 'z'), 'd', (('x', 2),)))
		self.assertEqual (ast2tex2ast (p ('\\frac{d**2}{dx dy}')), ('/', ('(', ('^', ('@', 'd'), ('#', '2')), True), ('*', (('@', 'dx'), ('@', 'dy')))))
		self.assertEqual (ast2tex2ast (p ('\\frac{d**2}{dx dy} z')), ('-diff', ('@', 'z'), 'partial', (('x', 1), ('y', 1))))
		self.assertEqual (ast2tex2ast (p ('\\frac{d**2 y}{dx dy}')), ('-diff', ('@', 'y'), 'partial', (('x', 1), ('y', 1))))
		self.assertEqual (ast2tex2ast (p ('\\frac{d**2 y}{dx dy} z')), ('*', (('-diff', ('@', 'y'), 'partial', (('x', 1), ('y', 1))), ('@', 'z')), {1}))
		self.assertEqual (ast2tex2ast (p ('\\int dy / dx')), ('-intg', ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('-dict', ()))), ('@', '')))
		self.assertEqual (ast2tex2ast (p ('\\int d/dx x**2 dx')), ('-intg', ('-diff', ('(', ('^', ('@', 'x'), ('#', '2'))), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (ast2tex2ast (p ('\\int d/dx y(x) dx')), ('-intg', ('-diff', ('(', ('-ufunc', 'y', (('@', 'x'),))), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (ast2tex2ast (p ('\\int dx dx dx')), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx'), ('@', 'dx')), {1}))
		self.assertEqual (ast2tex2ast (p ('\\int dx * dx dx')), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx'), ('@', 'dx')), {1}))
		self.assertEqual (ast2tex2ast (p ('dlambda / dx : x')), ('-diff', ('-lamb', ('@', 'x'), ()), 'd', (('x', 1),)))
		self.assertEqual (ast2tex2ast (p ('d**2 lambda / dx**2 : x')), ('-slice', ('-diff', ('@', 'lambda'), 'd', (('x', 2),)), ('@', 'x'), None))
		self.assertEqual (ast2tex2ast (p ('ln1.or')), ('.', ('@', 'ln1'), 'or'))
		self.assertRaises (AttributeError, ast2tex2ast, p ('ln1. or'))
		self.assertRaises (AttributeError, ast2tex2ast, p ('ln1 . or'))
		self.assertEqual (ast2tex2ast (p ('a.b * c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd'))))
		self.assertEqual (ast2tex2ast (p ('a.b c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd'))))
		self.assertEqual (ast2tex2ast (p ('lambda x, y, z: ln lambda x:')), (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'y'), ('-slice', ('@', 'z'), ('*', (('-log', ('@', 'lambda')), ('@', 'x'))), False))))
		self.assertEqual (ast2tex2ast (p ('lambda x, y, z: ln lambda x: 1')), ('-lamb', ('-log', ('-lamb', ('#', '1'), ('x',))), ('x', 'y', 'z')))

		self.assertEqual (ast2tex2ast (p ('f (x) (0)')), ('*', (('-ufunc', 'f', (('@', 'x'),)), ('(', ('#', '0'))), {1}))
		self.assertEqual (ast2tex2ast (p ('f (x, y) (0, 0)')), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'))), ('(', (',', (('#', '0'), ('#', '0'))))), {1}))
		self.assertEqual (ast2tex2ast (p ('f (x, y, z) (0, 0, 0)')), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('(', (',', (('#', '0'), ('#', '0'), ('#', '0'))))), {1}))
		self.assertEqual (ast2tex2ast (p ("f (x)' (0)")), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2tex2ast (p ('\\. x+y |_{x = 1}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (ast2tex2ast (p ('\\. x+y |_{x = 1, y = 2}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2tex2ast (p ('\\. x+y |_{x, y = 1, 2}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2tex2ast (p ('\\. x+y |_{\\substack{x = 1}}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (ast2tex2ast (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2tex2ast (p ('\\. f(x) |_{f(x) = y}')), ('-subs', ('-ufunc', 'f', (('@', 'x'),)), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')),)))
		self.assertEqual (ast2tex2ast (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}')), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2tex2ast (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}')), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2tex2ast (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}')), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2tex2ast (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}')), ('-subs', ('(', ('+', (('(', (',', (('#', '1'), ('#', '2')))), ('(', (',', (('#', '1'), ('#', '2'))))))), ((('(', (',', (('#', '1'), ('#', '2'), ('#', '1'), ('#', '2')))), ('(', (',', (('#', '3'), ('#', '4'))))),)))

		self.assertEqual (ast2tex2ast (p ("f (x)' (0)")), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2tex2ast (p ('d / dx (f (x)) (0)')), ('-subs', ('-diff', ('-ufunc', 'f', (('@', 'x'),)), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2tex2ast (p ('d / dx (u (x, y)) (x, y)')), ('-diff', ('(', ('-ufunc', 'u', (('@', 'x'), ('@', 'y')))), 'partial', (('x', 1),)))
		self.assertEqual (ast2tex2ast (p ('d / dx (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'partial', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2tex2ast (p ('d / dx (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'partial', (('x', 1),)), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2tex2ast (p ('d**2 / dx dy (u (x, y)) (x, y)')), ('-diff', ('(', ('-ufunc', 'u', (('@', 'x'), ('@', 'y')))), 'partial', (('x', 1), ('y', 1))))
		self.assertEqual (ast2tex2ast (p ('d**2 / dx dy (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'partial', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2tex2ast (p ('d**2 / dx dy (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'partial', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2tex2ast (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})")), ('-func', 'dsolve', (('+', (('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 2), ('*', (('#', '11'), ('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 1))), ('*', (('#', '24'), ('-ufunc', 'y', (('@', 'x'),)))))), ('=', ('@', 'ics'), ('-dict', ((('-ufunc', 'y', (('#', '0'),)), ('#', '0')), (('-subs', ('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)), ('#', '-7'))))))))
		self.assertEqual (ast2tex2ast (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}")), ('-subs', ('[', (('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ('-diffp', ('-ufunc', 'g', (('@', 'y'),)), 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (ast2tex2ast (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')), ('-subs', ('[', (('-diff', ('(', ('-ufunc', 'f', (('@', 'x'), ('@', 'y')))), 'partial', (('x', 1),)), ('-diff', ('(', ('-ufunc', 'g', (('@', 'y'), ('@', 'x')))), 'partial', (('x', 1),)))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (ast2tex2ast (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')), ('-subs', ('-diff', ('(', ('-ufunc', 'f', (('@', 'x'), ('@', 'z')))), 'partial', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')), (('@', 'z'), ('#', '3')))))
		self.assertEqual (ast2tex2ast (p ('?() = 2')), ('=', ('-ufunc', '?', ()), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('?f() = 2')), ('=', ('-ufunc', '?f', ()), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('d / dx (a) b')), ('*', (('-diff', ('(', ('@', 'a')), 'd', (('x', 1),)), ('@', 'b')), {1}))
		self.assertEqual (ast2tex2ast (p ('\\frac{d}{dx} (a) b')), ('*', (('-diff', ('(', ('@', 'a')), 'd', (('x', 1),)), ('@', 'b')), {1}))
		self.assertEqual (ast2tex2ast (p ('sin (())')), ('-func', 'sin', (('(', (',', ())),)))
		self.assertEqual (ast2tex2ast (p ('sin (((a))')), ('-func', 'sin', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (ast2tex2ast (p ('a.b (())')), ('.', ('@', 'a'), 'b', (('(', (',', ())),)))
		self.assertEqual (ast2tex2ast (p ('a.b (((a))')), ('.', ('@', 'a'), 'b', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (ast2tex2ast (p ('@x')), ('-func', '@', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('@(x + y)')), ('-func', '@', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2tex2ast (p ('@(x + y)')), ('-func', '@', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2tex2ast (p ('%x')), ('-func', '%', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('%(x + y)')), ('-func', '%', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2tex2ast (p ('%%x')), ('-func', '%', (('-func', '%', (('@', 'x'),)),)))
		self.assertEqual (ast2tex2ast (p ('%%(x + y)')), ('-func', '%', (('-func', '%', (('+', (('@', 'x'), ('@', 'y'))),)),)))
		self.assertEqual (ast2tex2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]')), ('-idx', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), (('-slice', False, False, None), ('-slice', ('#', '1'), False, None))))

		self.assertEqual (ast2tex2ast (p ('N - N N 2')), ('+', (('@', 'N'), ('-', ('-func', 'N', (('-func', 'N', (('#', '2'),)),))))))
		self.assertEqual (ast2tex2ast (p ('N N N 2')), ('-func', 'N', (('-func', 'N', (('-func', 'N', (('#', '2'),)),)),)))
		self.assertEqual (ast2tex2ast (p ('sin sin sin 2')), ('-func', 'sin', (('-func', 'sin', (('-func', 'sin', (('#', '2'),)),)),)))
		self.assertEqual (ast2tex2ast (p ('-N sin -N 2')), ('-', ('-func', 'N', (('-func', 'sin', (('-', ('-func', 'N', (('#', '2'),))),)),))))
		self.assertEqual (ast2tex2ast (p ('sin -N sin 2')), ('-func', 'sin', (('-', ('-func', 'N', (('-func', 'sin', (('#', '2'),)),))),)))
		self.assertEqual (ast2tex2ast (p ('N N sin -a [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2tex2ast (p ('N N sin -a.b [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2tex2ast (p ('N N sin -a.b () [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2tex2ast (p ('N N sin -a.b () [2] [3]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),)), (('#', '3'),))),)),)),)))
		self.assertEqual (ast2tex2ast (p ('sin -N () [2] [3].c [4].d () [5]')), ('-func', 'sin', (('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))),)))
		self.assertEqual (ast2tex2ast (p ('sqrt -N () [2] [3].c [4].d () [5]')), ('-sqrt', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (ast2tex2ast (p ('sqrt[3] -N () [2] [3].c [4].d () [5]')), ('-sqrt', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))), ('#', '3')))
		self.assertEqual (ast2tex2ast (p ('log -N () [2] [3].c [4].d () [5]')), ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (ast2tex2ast (p ('\\log_2 -N () [2] [3].c [4].d () [5]')), ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))), ('#', '2')))
		self.assertEqual (ast2tex2ast (p ('N sin**2 ln**2 N x')), ('-func', 'N', (('^', ('-func', 'sin', (('^', ('-log', ('-func', 'N', (('@', 'x'),))), ('#', '2')),)), ('#', '2')),)))
		self.assertEqual (ast2tex2ast (p ('sin ln N x')), ('-func', 'sin', (('-log', ('-func', 'N', (('@', 'x'),))),)))
		self.assertEqual (ast2tex2ast (p ('sin(a)**[a][b].c')), ('^', ('-func', 'sin', (('@', 'a'),)), ('.', ('-idx', ('[', (('@', 'a'),)), (('@', 'b'),)), 'c')))
		self.assertEqual (ast2tex2ast (p ('N sin N sin x')), ('-func', 'N', (('-func', 'sin', (('-func', 'N', (('-func', 'sin', (('@', 'x'),)),)),)),)))
		self.assertEqual (ast2tex2ast (p ('cos**-1 0 \\log_2 8')), ('*', (('-func', 'acos', (('#', '0'),)), ('-log', ('#', '8'), ('#', '2')))))
		self.assertEqual (ast2tex2ast (p ('N sin sqrt[3] \\log_2 8')), ('-func', 'N', (('-func', 'sin', (('-sqrt', ('-log', ('#', '8'), ('#', '2')), ('#', '3')),)),)))
		self.assertEqual (ast2tex2ast (p ('sin(x)**-a[b][c].d')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2tex2ast (p ('sin sin x [2].w')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),)))
		self.assertEqual (ast2tex2ast (p ('sin -sin x [2].w')), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (ast2tex2ast (p ('sin sin (x) [2].w')), ('-func', 'sin', (('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w'),)))
		self.assertEqual (ast2tex2ast (p ('sin -sin (x) [2].w')), ('-func', 'sin', (('-', ('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w')),)))
		self.assertEqual (ast2tex2ast (p ('sin sin x [2].w ()')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w', ()),)),)))
		self.assertEqual (ast2tex2ast (p ('ln ln x [2].w')), ('-log', ('-log', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'))))
		self.assertEqual (ast2tex2ast (p ('N N sin -a [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2tex2ast (p ('sin sin -x [2].w')), ('-func', 'sin', (('-func', 'sin', (('-', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w')),)),)))
		self.assertEqual (ast2tex2ast (p ('sin -sin x [2].w')), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (ast2tex2ast (p ('sin(a)**b[2]')), ('^', ('-func', 'sin', (('@', 'a'),)), ('-idx', ('@', 'b'), (('#', '2'),))))
		self.assertEqual (ast2tex2ast (p ('sin**-a[b][c].d x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2tex2ast (p ('sin**-a[b][c].d (x)')), ('^', ('@', 'sin'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2tex2ast (p ('sin**-a[b][c].d {(x)}')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2tex2ast (p ('sin**-a[b][c] (x)')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (ast2tex2ast (p ('\\int**-a[b][c] x')), ('-intg', ('*', (('@', 'x'), ('-dict', ()))), ('@', ''), ('#', '0'), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (ast2tex2ast (p ('\\int**-a[b][c].d (x)')), ('-intg', ('-dict', ()), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2tex2ast (p ('\\int**-a[b][c].d {(x)}')), ('-intg', ('*', (('(', ('@', 'x')), ('-dict', ()))), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2tex2ast (p ('\\int**-a[b][c].d (x) y')), ('-intg', ('*', (('@', 'y'), ('-dict', ()))), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2tex2ast (p ('\\int**-a[b][c].d {(x)} y')), ('-intg', ('*', (('(', ('@', 'x')), ('@', 'y'), ('-dict', ()))), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2tex2ast (p ('\\int**a.b[2] x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))))

		self.assertEqual (ast2tex2ast (p ('d/dx (real = True)')), ('-diff', ('(', ('=', ('@', 'real'), ('@', 'True'))), 'd', (('x', 1),)))
		self.assertEqual (ast2tex2ast (p ('f {\\left(x\\right)}')), ('-ufunc', 'f', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('a.b {(x)}')), ('*', (('.', ('@', 'a'), 'b'), ('(', ('@', 'x')))))
		self.assertEqual (ast2tex2ast (p ('a.b {\\left(x\\right)}')), ('.', ('@', 'a'), 'b', (('@', 'x'),)))
		self.assertEqual (ast2tex2ast (p ('\\log_{|x|} y')), ('-log', ('@', 'y'), ('|', ('@', 'x'))))
		self.assertEqual (ast2tex2ast (p ('|\\int a + b dx|')), ('|', ('-intg', ('+', (('@', 'a'), ('@', 'b'))), ('@', 'dx'))))
		self.assertEqual (ast2tex2ast (p ('\\int deg N dx')), ('-intg', ('-func', 'deg', (('@', 'N'),)), ('@', 'dx')))
		self.assertEqual (ast2tex2ast (p ('a \\int x dx / c')), ('/', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')))), ('@', 'c')))
		self.assertEqual (ast2tex2ast (p ('\\int x dx b / c')), ('/', ('*', (('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b')), {1}), ('@', 'c')))
		self.assertEqual (ast2tex2ast (p ('a \\int x dx b / c')), ('/', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b')), {2}), ('@', 'c')))
		self.assertEqual (ast2tex2ast (p ('a {\\lim_{x\\to0} \\int x dx} / b')), ('/', ('*', (('@', 'a'), ('-lim', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0')))), ('@', 'b')))
		self.assertEqual (ast2tex2ast (p ('a {\\sum_{x=0}^1 \\int x dx} / b')), ('/', ('*', (('@', 'a'), ('-sum', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0'), ('#', '1')))), ('@', 'b')))
		self.assertEqual (ast2tex2ast (p ('a / \\int x dx * c')), ('*', (('/', ('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx'))), ('@', 'c'))))
		self.assertEqual (ast2tex2ast (p ('a / b \\int x dx * c')), ('*', (('/', ('@', 'a'), ('*', (('@', 'b'), ('-intg', ('@', 'x'), ('@', 'dx'))))), ('@', 'c'))))

		self.assertEqual (ast2tex2ast (p ('cos')), ('@', 'cos'))
		self.assertEqual (ast2tex2ast (p ('f = cos')), ('=', ('@', 'f'), ('@', 'cos')))
		self.assertEqual (ast2tex2ast (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)')), ('.', ('-mat', ((('#', '0'), ('@', 'pi')), (('-', ('@', 'pi')), ('#', '0')))), 'applyfunc', (('@', 'cos'),)))
		self.assertEqual (ast2tex2ast (p ('$sin (real = True)')), ('-sym', 'sin', (('real', ('@', 'True')),)))
		self.assertEqual (ast2tex2ast (p ('sin = $(real = True)')), ('=', ('@', 'sin'), ('-sym', '', (('real', ('@', 'True')),))))

	def test_ast2nat2ast (self):
		self.assertEqual (ast2nat2ast (p ('1')), ('#', '1'))
		self.assertEqual (ast2nat2ast (p ('1.')), ('#', '1.'))
		self.assertEqual (ast2nat2ast (p ('.1')), ('#', '0.1'))
		self.assertEqual (ast2nat2ast (p ('1e20')), ('#', '1e+20'))
		self.assertEqual (ast2nat2ast (p ('1E-20')), ('#', '1e-20'))
		self.assertEqual (ast2nat2ast (p ('1.e+20')), ('#', '1.e+20'))
		self.assertEqual (ast2nat2ast (p ('.1e-20')), ('#', '0.1e-20'))
		self.assertEqual (ast2nat2ast (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')), ('-func', 'sin', (('#', '-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901'),)))
		self.assertEqual (ast2nat2ast (p ('x')), ('@', 'x'))
		self.assertEqual (ast2nat2ast (p ('xy')), ('@', 'xy'))
		self.assertEqual (ast2nat2ast (p ('dx')), ('@', 'dx'))
		self.assertEqual (ast2nat2ast (p ('partialx')), ('@', 'partialx'))
		self.assertEqual (ast2nat2ast (p ('\\partial x')), ('@', 'partialx'))
		self.assertEqual (ast2nat2ast (p ('x d  y')), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x partial y')), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x \\partial  y')), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x dx dy y')), ('*', (('@', 'x'), ('@', 'dx'), ('@', 'dy'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x partialx partialy y')), ('*', (('@', 'x'), ('@', 'partialx'), ('@', 'partialy'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('-1')), ('#', '-1'))
		self.assertEqual (ast2nat2ast (p ('-x')), ('-', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('{x}')), ('@', 'x'))
		self.assertEqual (ast2nat2ast (p ('()')), ('(', (',', ())))
		self.assertEqual (ast2nat2ast (p ('(x)')), ('(', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('(x,)')), ('(', (',', (('@', 'x'),))))
		self.assertEqual (ast2nat2ast (p ('(x,y)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2nat2ast (p ('(x,y,)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2nat2ast (p ('[]')), ('[', ()))
		self.assertEqual (ast2nat2ast (p ('[x]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('[x,]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('[x,y]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('[x,y,]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('"x\\x20\\n"')), ('"', 'x \n'))
		self.assertEqual (ast2nat2ast (p ("'x\\x20\\n'")), ('"', 'x \n'))
		self.assertEqual (ast2nat2ast (p ('|x|')), ('|', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('x!')), ('!', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('x+y')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x-y')), ('+', (('@', 'x'), ('-', ('@', 'y')))))
		self.assertEqual (ast2nat2ast (p ('x*y')), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x y')), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x(y)')), ('-ufunc', 'x', (('@', 'y'),)))
		self.assertEqual (ast2nat2ast (p ('x*(y)')), ('*', (('@', 'x'), ('(', ('@', 'y'))), {1}))
		self.assertEqual (ast2nat2ast (p ('x/y')), ('/', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2nat2ast (p ('x^y')), ('^', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2nat2ast (p ('log x')), ('-log', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('log {x}')), ('-log', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('log (x)')), ('-log', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('\\log_2 x')), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('\\log_2 {x}')), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('\\log_2 (x)')), ('-log', ('@', 'x'), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('sqrt x')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('sqrt {x}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('sqrt (x)')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('sqrt {(x)}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('sqrt[3] x')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2nat2ast (p ('sqrt[3] {x}')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2nat2ast (p ('sqrt[3] {(x)}')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2nat2ast (p ('sqrt[3] (x)')), ('-sqrt', ('@', 'x'), ('#', '3')))
		self.assertEqual (ast2nat2ast (p ('sin x')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('sin^2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('sin (x)')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('sin (x)^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('sin {x}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('sin {(x)}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('{sin x}^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('sin**2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('sin**-1 x')), ('-func', 'asin', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('sin(x)**-1')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '-1')))
		self.assertEqual (ast2nat2ast (p ('acos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('\\arccos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('sin(x**2)')), ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('sin(x**2)**2')), ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('(sin(x**2)**2)')), ('(', ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('ln(x**2)')), ('-log', ('^', ('@', 'x'), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('ln(x**2)**2')), ('^', ('(', ('-log', ('^', ('@', 'x'), ('#', '2')))), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('(ln(x**2)**2)')), ('(', ('^', ('(', ('-log', ('^', ('@', 'x'), ('#', '2')))), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('gamma(x**2)')), ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('gamma(x**2)**2')), ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('(gamma(x**2)**2)')), ('(', ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('{gamma}[2]')), ('-idx', ('@', 'gamma'), (('#', '2'),)))
		self.assertEqual (ast2nat2ast (p ('{Gamma}[2]')), ('-idx', ('@', 'Gamma'), (('#', '2'),)))
		self.assertEqual (ast2nat2ast (p ('f{(x)}')), ('*', (('@', 'f'), ('(', ('@', 'x'))), {1}))
		self.assertEqual (ast2nat2ast (p ("f{(x)}'(0)")), ('*', (('@', 'f'), ('-diffp', ('(', ('@', 'x')), 1), ('(', ('#', '0'))), {1}))
		self.assertEqual (ast2nat2ast (p ("f{(x)}'{(0)}")), ('*', (('@', 'f'), ('-diffp', ('(', ('@', 'x')), 1), ('(', ('#', '0'))), {1}))
		self.assertEqual (ast2nat2ast (p ('\\operatorname{x_{1}}{\\left(x \\right)}')), ('-ufunc', 'x1', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('\\lim_{x\\to0} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2nat2ast (p ('\\lim_{x\\to0^+} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2nat2ast (p ('\\lim_{x\\to0**-} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2nat2ast (p ('Limit (1/x, x, 0)')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2nat2ast (p ('Limit (1/x, x, 0, "-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2nat2ast (p ('Limit (1/x, x, 0, dir="+-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2nat2ast (p ('limit (1/x, x, 0)')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2nat2ast (p ('limit (1/x, x, 0, "-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2nat2ast (p ('limit (1/x, x, 0, dir="+-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2nat2ast (p ('\\sum_{n=0}^\\infty x^n/n!')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2nat2ast (p ('Sum (x^n/n!, (n, 0, oo))')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2nat2ast (p ('summation (x^n/n!, (n, 0, oo))')), ('-func', 'summation', (('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('(', (',', (('@', 'n'), ('#', '0'), ('@', 'oo')))))))
		self.assertEqual (ast2nat2ast (p ('d/dx x**2y**2z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'd', (('x', 1),)))
		self.assertEqual (ast2nat2ast (p ('d^2/dx^2 x^2y**2z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'd', (('x', 2),)))
		self.assertEqual (ast2nat2ast (p ('d^3/dx^2dy x^2y**2z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'd', (('x', 2), ('y', 1))))
		self.assertEqual (ast2nat2ast (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'partial', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2nat2ast (p ('d**1.5 / dx dy x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '1.5')), ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2nat2ast (p ('d**-2 / dx dy x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '-2')), ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2nat2ast (p ('d**2 / dx**1.5 x**2y**2')), ('/', ('(', ('^', ('@', 'd'), ('#', '2'))), ('*', (('^', ('@', 'dx'), ('#', '1.5')), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2nat2ast (p ('Derivative (x^2y**2z, x, 2, y, z)')), ('-diff', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'd', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2nat2ast (p ('diff (x^2y**2z, x, 2, y, z)')), ('-func', 'diff', (('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z'))), ('@', 'x'), ('#', '2'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2nat2ast (p ('\\int dx')), ('-intg', None, ('@', 'dx')))
		self.assertEqual (ast2nat2ast (p ('\\int x dx')), ('-intg', ('@', 'x'), ('@', 'dx')))
		self.assertEqual (ast2nat2ast (p ('\\int_0^1 x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2nat2ast (p ('\\int_0^1 \\int y dy dx')), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2nat2ast (p ('Integral (\\int y dy, (x, 0, 1))')), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2nat2ast (p ('integrate (\\int y dy, (x, 0, 1))')), ('-func', 'integrate', (('-intg', ('@', 'y'), ('@', 'dy')), ('(', (',', (('@', 'x'), ('#', '0'), ('#', '1')))))))

		self.assertEqual (ast2nat2ast (p ('\\[1,]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2nat2ast (p ('\\[1,2]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2nat2ast (p ('\\[1,2,]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2nat2ast (p ('\\[[1,],]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2nat2ast (p ('\\[[1,],[2,]]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2nat2ast (p ('\\[[1,],[2,],]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2nat2ast (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2nat2ast (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2nat2ast (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}')), ('-mat', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2nat2ast (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2nat2ast (p ('\\[1,2]!')), ('!', ('-mat', ((('#', '1'),), (('#', '2'),)))))
		self.assertEqual (ast2nat2ast (p ('\\[[0,1],[1,0]]**x')), ('^', ('-mat', ((('#', '0'), ('#', '1')), (('#', '1'), ('#', '0')))), ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2],[3,4]]!')), ('!', ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2,3],[4,5,6]].T')), ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2,3],[4,5,6]].T.T')), ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'), 'T'))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2,3],[4,5,6]].T.T.T')), ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'T'), 'T'), 'T'))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2,3],[4,5,6]].transpose ()')), ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()')), ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()')), ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2nat2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()')), ('.', ('.', ('.', ('.', ('.', ('.', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), 'transpose', ()), 'transpose', ()), 'T'), 'T'), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2nat2ast (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]')), ('*', (('-mat', ((('@', 'A'), ('@', 'B')), (('@', 'C'), ('@', 'D')))), ('-mat', ((('@', 'x'),), (('@', 'y'),))))))
		self.assertEqual (ast2nat2ast (p ('\\[[1, 2], [3')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('@', '')))))
		self.assertEqual (ast2nat2ast (p ('\\[[1, 2], [3]]')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('@', '')))))
		self.assertEqual (ast2nat2ast (p ('\\[[1], [2, 3]]')), ('-mat', ((('#', '1'), ('@', '')), (('#', '2'), ('#', '3')))))

		self.assertEqual (ast2nat2ast (p ('-1**x')), ('-', ('^', ('#', '1'), ('@', 'x'))))
		self.assertEqual (ast2nat2ast (p ('{-1}**x')), ('^', ('(', ('#', '-1')), ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('-{-1}**x')), ('-', ('^', ('(', ('#', '-1')), ('@', 'x'))))
		self.assertEqual (ast2nat2ast (p ('(-1)**x')), ('^', ('(', ('#', '-1')), ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('-(-1)**x')), ('-', ('^', ('(', ('#', '-1')), ('@', 'x'))))
		self.assertEqual (ast2nat2ast (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (ast2nat2ast (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (ast2nat2ast (p ('1 if x < y')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))),)))
		self.assertEqual (ast2nat2ast (p ('1 if x < y else 3')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), True))))
		self.assertEqual (ast2nat2ast (p ('1 if x < y else 3 if x < z')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))))))
		self.assertEqual (ast2nat2ast (p ('1 if x < y else 3 if x < z else 5')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2nat2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2nat2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2nat2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'x'), (('<', ('@', 'w')),))))))
		self.assertEqual (ast2nat2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'x'), (('<', ('@', 'w')),))))))
		self.assertEqual (ast2nat2ast (p ('x**y.a')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a')))
		self.assertEqual (ast2nat2ast (p ('x**y.a ()')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a', ())))
		self.assertEqual (ast2nat2ast (p ('x**y.a.b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b')))
		self.assertEqual (ast2nat2ast (p ('x**y.a.b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b', ())))
		self.assertEqual (ast2nat2ast (p ('x**y.a ().b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b')))
		self.assertEqual (ast2nat2ast (p ('x**y.a ().b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b', ())))
		self.assertEqual (ast2nat2ast (p ('{1 if x < 0 else 3} if x < 1 else 5')), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '3'), True))), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))))
		self.assertEqual (ast2nat2ast (p ('1 if {True if x < 0 else False} else 5')), ('-piece', ((('#', '1'), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('@', 'False'), True)))), (('#', '5'), True))))
		self.assertEqual (ast2nat2ast (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}')), ('-piece', ((('#', '1'), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('@', 'False'), True)))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))), True))))
		self.assertEqual (ast2nat2ast (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '9'), True))), ('-piece', ((('@', 'True'), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('@', 'False'), True)))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '2')),))), (('#', '5'), True))), True))))
		self.assertEqual (ast2nat2ast (p ('x.y!')), ('!', ('.', ('@', 'x'), 'y')))
		self.assertEqual (ast2nat2ast (p ('x.y**2')), ('^', ('.', ('@', 'x'), 'y'), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('x.y ()!')), ('!', ('.', ('@', 'x'), 'y', ())))
		self.assertEqual (ast2nat2ast (p ('x.y ()**2')), ('^', ('.', ('@', 'x'), 'y', ()), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('x**y.a!')), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a'))))
		self.assertEqual (ast2nat2ast (p ('x**y.a**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a'), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('x**y.a ()!')), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a', ()))))
		self.assertEqual (ast2nat2ast (p ('x**y.a ()**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a', ()), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('lambda: x')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2nat2ast (p ('lambda x: x**2')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2nat2ast (p ('lambda x, y: x + y')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2nat2ast (p ('lambda x, y, z: x + y + z')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))
		self.assertEqual (ast2nat2ast (p ('1, lambda: x')), (',', (('#', '1'), ('-lamb', ('@', 'x'), ()))))
		self.assertEqual (ast2nat2ast (p ('1, lambda x: x**2')), (',', (('#', '1'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))))
		self.assertEqual (ast2nat2ast (p ('1, lambda x, y: x + y')), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))))
		self.assertEqual (ast2nat2ast (p ('1, lambda x, y, z: x + y + z')), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))))
		self.assertEqual (ast2nat2ast (p ('f = lambda: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ())))
		self.assertEqual (ast2nat2ast (p ('f = lambda x: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x',))))
		self.assertEqual (ast2nat2ast (p ('f = lambda x, y: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y'))))
		self.assertEqual (ast2nat2ast (p ('f = lambda x, y, z: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y', 'z'))))
		self.assertEqual (ast2nat2ast (p ('\\left(\\left(\\right) \\mapsto x \\right)')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2nat2ast (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2nat2ast (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2nat2ast (p ('\\lambda: x')), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (ast2nat2ast (p ('\\lambda x: x')), ('-slice', ('*', (('@', 'lambda'), ('@', 'x')), {1}), ('@', 'x'), None))
		self.assertEqual (ast2nat2ast (p ('\\lambda x, y: x')), (',', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('-slice', ('@', 'y'), ('@', 'x'), None))))
		self.assertEqual (ast2nat2ast (p ('{lambda}: x')), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (ast2nat2ast (p ('{lambda} x: x')), ('-slice', ('*', (('@', 'lambda'), ('@', 'x')), {1}), ('@', 'x'), None))
		self.assertEqual (ast2nat2ast (p ('{lambda} x, y: x')), (',', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('-slice', ('@', 'y'), ('@', 'x'), None))))
		self.assertEqual (ast2nat2ast (p ('$')), ('-sym', ''))
		self.assertEqual (ast2nat2ast (p ('$s')), ('-sym', 's'))
		self.assertEqual (ast2nat2ast (p ('$ (real = True)')), ('-sym', '', (('real', ('@', 'True')),)))
		self.assertEqual (ast2nat2ast (p ('$s (real = True)')), ('-sym', 's', (('real', ('@', 'True')),)))

		self.assertEqual (ast2nat2ast (p ('eye (2).is_diagonal ()')), ('.', ('-func', 'eye', (('#', '2'),)), 'is_diagonal', ()))
		self.assertEqual (ast2nat2ast (p ('a [2]')), ('-idx', ('@', 'a'), (('#', '2'),)))
		self.assertEqual (ast2nat2ast (p ('a [2,3]')), ('-idx', ('@', 'a'), (('#', '2'), ('#', '3'))))
		self.assertEqual (ast2nat2ast (p ('a * [2]')), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (ast2nat2ast (p ('a * {-1}[x]')), ('*', (('@', 'a'), ('-idx', ('(', ('#', '-1')), (('@', 'x'),))), {1}))
		self.assertEqual (ast2nat2ast (p ('a * [x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (ast2nat2ast (p ('N (1/2)')), ('-func', 'N', (('/', ('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ("S ('1/2')")), ('-func', 'S', (('"', '1/2'),)))
		self.assertEqual (ast2nat2ast (p ("N (S ('1/2'))")), ('-func', 'N', (('-func', 'S', (('"', '1/2'),)),)))
		self.assertEqual (ast2nat2ast (p ('S.Half')), ('.', ('@', 'S'), 'Half'))
		self.assertEqual (ast2nat2ast (p ('N S.Half')), ('-func', 'N', (('.', ('@', 'S'), 'Half'),)))
		self.assertEqual (ast2nat2ast (p ('o [i].t')), ('.', ('-idx', ('@', 'o'), (('@', 'i'),)), 't'))
		self.assertEqual (ast2nat2ast (p ('o [i]**2')), ('^', ('-idx', ('@', 'o'), (('@', 'i'),)), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('o [i]!')), ('!', ('-idx', ('@', 'o'), (('@', 'i'),))))
		self.assertEqual (ast2nat2ast (p ("'Hello' [::-1]")), ('-idx', ('"', 'Hello'), (('-slice', False, False, ('#', '-1')),)))
		self.assertEqual (ast2nat2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]')), ('-idx', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), (('-slice', False, False, None), ('#', '1'))))
		self.assertEqual (ast2nat2ast (p ('\\binom96')), ('-func', 'binomial', (('#', '9'), ('#', '6'))))
		self.assertEqual (ast2nat2ast (p ('binomial (x, y)')), ('-func', 'binomial', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('y - 1*x')), ('+', (('@', 'y'), ('-', ('*', (('#', '1'), ('@', 'x')))))))
		self.assertEqual (ast2nat2ast (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'))), ('#', '1'))), ('@', 'x'), ('=', ('@', 'domain'), ('"', 'ZZ')))))
		self.assertEqual (ast2nat2ast (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'), ('@', 'y'))))), ('@', 'x'), ('@', 'y'), ('=', ('@', 'domain'), ('"', 'CC')))))
		self.assertEqual (ast2nat2ast (p ('oct(10)')), ('-func', 'oct', (('#', '10'),)))
		self.assertEqual (ast2nat2ast (p ('(1,) + (2,)')), ('+', (('(', (',', (('#', '1'),))), ('(', (',', (('#', '2'),))))))
		self.assertEqual (ast2nat2ast (p ('[1] + [2]')), ('+', (('[', (('#', '1'),)), ('[', (('#', '2'),)))))
		self.assertEqual (ast2nat2ast (p ("'a' + 'b'")), ('+', (('"', 'a'), ('"', 'b'))))
		self.assertEqual (ast2nat2ast (p ('(1,) * 2')), ('*', (('(', (',', (('#', '1'),))), ('#', '2')), {1}))
		self.assertEqual (ast2nat2ast (p ('[1] * 2')), ('*', (('[', (('#', '1'),)), ('#', '2')), {1}))
		self.assertEqual (ast2nat2ast (p ("'a' * 2")), ('*', (('"', 'a'), ('#', '2')), {1}))
		self.assertEqual (ast2nat2ast (p ('Lambda (x, x**2)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2nat2ast (p ('beta (2, 3)')), ('-func', 'beta', (('#', '2'), ('#', '3'))))
		self.assertEqual (ast2nat2ast (p ('{x d} y')), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (ast2nat2ast (p ('ln((a)**b)')), ('-log', ('^', ('(', ('@', 'a')), ('@', 'b'))))
		self.assertEqual (ast2nat2ast (p ('a * \\int dx + {\\int dx dx}')), ('+', (('*', (('@', 'a'), ('-intg', None, ('@', 'dx')))), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx')), {1}))))
		self.assertEqual (ast2nat2ast (p ('1 if {a = x if z} else 0 if y')), ('-piece', ((('#', '1'), ('=', ('@', 'a'), ('-piece', ((('@', 'x'), ('@', 'z')),)))), (('#', '0'), ('@', 'y')))))
		self.assertEqual (ast2nat2ast (p ('a, lambda: b = 1')), (',', (('@', 'a'), ('-lamb', ('=', ('@', 'b'), ('#', '1')), ()))))
		self.assertEqual (ast2nat2ast (p ('a * [2]')), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (ast2nat2ast (p ('sqrt(1, 2)')), ('-sqrt', (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (ast2nat2ast (p ('x*[][y]')), ('*', (('@', 'x'), ('-idx', ('[', ()), (('@', 'y'),))), {1}))
		self.assertEqual (ast2nat2ast (p ('lambda: x:')), ('-lamb', ('(', ('-slice', ('@', 'x'), False, None)), ()))
		self.assertEqual (ast2nat2ast (p ('a*[x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (ast2nat2ast (p ('a*()**2')), ('*', (('@', 'a'), ('^', ('(', (',', ())), ('#', '2'))), {1}))
		self.assertEqual (ast2nat2ast (p ('a*().t')), ('*', (('@', 'a'), ('.', ('(', (',', ())), 't')), {1}))
		self.assertEqual (ast2nat2ast (p ('a*()[2]')), ('*', (('@', 'a'), ('-idx', ('(', (',', ())), (('#', '2'),))), {1}))
		self.assertEqual (ast2nat2ast (p ('o.f*(a)')), ('*', (('.', ('@', 'o'), 'f'), ('(', ('@', 'a'))), {1}))
		self.assertEqual (ast2nat2ast (p ('o.f*{1+2}')), ('*', (('.', ('@', 'o'), 'f'), ('+', (('#', '1'), ('#', '2'))))))
		self.assertEqual (ast2nat2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (ast2nat2ast (p ('y**z [w]')), ('^', ('@', 'y'), ('-idx', ('@', 'z'), (('@', 'w'),))))
		self.assertEqual (ast2nat2ast (p ('{y**z} [w]')), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))
		self.assertEqual (ast2nat2ast (p ('x {y**z} [w]')), ('*', (('@', 'x'), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))))
		self.assertEqual (ast2nat2ast (p ('{x y**z} [w]')), ('-idx', ('(', ('*', (('@', 'x'), ('^', ('@', 'y'), ('@', 'z'))))), (('@', 'w'),)))
		self.assertEqual (ast2nat2ast (p ('Min (x, y, z)')), ('-func', 'Min', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2nat2ast (p ('Max (x, y, z)')), ('-func', 'Max', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2nat2ast (p ('\\Re (z)')), ('-func', 're', (('@', 'z'),)))
		self.assertEqual (ast2nat2ast (p ('\\Im (z)')), ('-func', 'im', (('@', 'z'),)))
		self.assertEqual (ast2nat2ast (p ('re (z)')), ('-func', 're', (('@', 'z'),)))
		self.assertEqual (ast2nat2ast (p ('im (z)')), ('-func', 'im', (('@', 'z'),)))
		self.assertEqual (ast2nat2ast (p ('{}')), ('-dict', ()))
		self.assertEqual (ast2nat2ast (p ('{1: 2}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('{1: 2,}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('{1: 2, 3: 4}')), ('-dict', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2nat2ast (p ('set ()')), ('-func', 'set', ()))
		self.assertEqual (ast2nat2ast (p ('\\{}')), ('-set', ()))
		self.assertEqual (ast2nat2ast (p ('\\{1}')), ('-set', (('#', '1'),)))
		self.assertEqual (ast2nat2ast (p ('\\{1,2}')), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('{1,2}')), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('1 in {1,2,3}')), ('<>', ('#', '1'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2nat2ast (p ('1 \\in {1,2,3}')), ('<>', ('#', '1'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2nat2ast (p ('4 in {1,2,3}')), ('<>', ('#', '4'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2nat2ast (p ('4 \\in {1,2,3}')), ('<>', ('#', '4'), (('in', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2nat2ast (p ('4 not in {1,2,3}')), ('<>', ('#', '4'), (('notin', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2nat2ast (p ('4 \\notin {1,2,3}')), ('<>', ('#', '4'), (('notin', ('-set', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2nat2ast (p ('{1,2} - {2,3}')), ('+', (('-set', (('#', '1'), ('#', '2'))), ('-', ('-set', (('#', '2'), ('#', '3')))))))
		self.assertEqual (ast2nat2ast (p ('{1,2} || {2,3}')), ('||', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2nat2ast (p ('{1,2} ^^ {2,3}')), ('^^', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2nat2ast (p ('{1,2} && {2,3}')), ('&&', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2nat2ast (p ('{1,2} || {2,3} || {3,4}')), ('||', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2nat2ast (p ('{1,2} ^^ {2,3} ^^ {3,4}')), ('^^', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2nat2ast (p ('{1,2} && {2,3} && {3,4}')), ('&&', (('-set', (('#', '1'), ('#', '2'))), ('-set', (('#', '2'), ('#', '3'))), ('-set', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2nat2ast (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}')), ('||', (('-set', (('#', '1'), ('#', '2'))), ('^^', (('-set', (('#', '2'), ('#', '3'))), ('&&', (('-set', (('#', '3'), ('#', '4'))), ('-set', (('#', '4'), ('#', '5'))))))))))
		self.assertEqual (ast2nat2ast (p ('solve (x**2 = 4)')), ('-func', 'solve', (('=', ('^', ('@', 'x'), ('#', '2')), ('#', '4')),)))
		self.assertEqual (ast2nat2ast (p ('Subs (x y, x, 2)')), ('-subs', ('*', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('Subs (x y, (x, y), (2, 3))')), ('-subs', ('*', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))))
		self.assertEqual (ast2nat2ast (p ('(x y).subs (x, 2)')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y')))), ((('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('(x y).subs (x, 2).subs (y, 3)')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y')))), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))))
		self.assertEqual (ast2nat2ast (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y'), ('@', 'z'), ('@', 'w')))), ((('@', 'z'), ('#', '4')), (('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')), (('@', 'w'), ('#', '5')))))
		self.assertEqual (ast2nat2ast (p ('x or y')), ('-or', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x or y or z')), ('-or', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2nat2ast (p ('x and y')), ('-and', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('x and y and z')), ('-and', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2nat2ast (p ('x and y or z')), ('-or', (('-and', (('@', 'x'), ('@', 'y'))), ('@', 'z'))))
		self.assertEqual (ast2nat2ast (p ('x and {y or z}')), ('-and', (('@', 'x'), ('(', ('-or', (('@', 'y'), ('@', 'z')))))))
		self.assertEqual (ast2nat2ast (p ('not x or y')), ('-or', (('-not', ('@', 'x')), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('not {x or y}')), ('-not', ('(', ('-or', (('@', 'x'), ('@', 'y'))))))
		self.assertEqual (ast2nat2ast (p ('not x and y')), ('-and', (('-not', ('@', 'x')), ('@', 'y'))))
		self.assertEqual (ast2nat2ast (p ('not {x and y}')), ('-not', ('(', ('-and', (('@', 'x'), ('@', 'y'))))))
		self.assertEqual (ast2nat2ast (p ('x or not y')), ('-or', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (ast2nat2ast (p ('x and not y')), ('-and', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (ast2nat2ast (p ('not x')), ('-not', ('@', 'x')))
		self.assertEqual (ast2nat2ast (p ('not not x')), ('-not', ('-not', ('@', 'x'))))
		self.assertEqual (ast2nat2ast (p ('not not not x')), ('-not', ('-not', ('-not', ('@', 'x')))))
		self.assertEqual (ast2nat2ast (p ('0 or []')), ('-or', (('#', '0'), ('[', ()))))
		self.assertEqual (ast2nat2ast (p ('0 or [1]')), ('-or', (('#', '0'), ('[', (('#', '1'),)))))
		self.assertEqual (ast2nat2ast (p ('1 and []')), ('-and', (('#', '1'), ('[', ()))))
		self.assertEqual (ast2nat2ast (p ('1 and [1]')), ('-and', (('#', '1'), ('[', (('#', '1'),)))))
		self.assertEqual (ast2nat2ast (p ('not []')), ('-not', ('[', ())))
		self.assertEqual (ast2nat2ast (p ('not [1]')), ('-not', ('[', (('#', '1'),))))
		self.assertEqual (ast2nat2ast (p ('not None')), ('-not', ('@', 'None')))
		self.assertEqual (ast2nat2ast (p ('True + True')), ('+', (('@', 'True'), ('@', 'True'))))
		self.assertEqual (ast2nat2ast (p ('False - True')), ('+', (('@', 'False'), ('-', ('@', 'True')))))
		self.assertEqual (ast2nat2ast (p ('True * True')), ('*', (('@', 'True'), ('@', 'True'))))
		self.assertEqual (ast2nat2ast (p ('(2 > 1) x')), ('*', (('(', ('<>', ('#', '2'), (('>', ('#', '1')),))), ('@', 'x'))))
		self.assertEqual (ast2nat2ast (p ('(2 > 1) + (1 < 2)')), ('+', (('(', ('<>', ('#', '2'), (('>', ('#', '1')),))), ('(', ('<>', ('#', '1'), (('<', ('#', '2')),))))))
		self.assertEqual (ast2nat2ast (p ('\\[{[a, b]},]')), ('-mat', ((('[', (('@', 'a'), ('@', 'b'))),),)))
		self.assertEqual (ast2nat2ast (p ('{{a:b:c}:d}')), ('-dict', ((('(', ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c'))), ('@', 'd')),)))
		self.assertEqual (ast2nat2ast (p ('{a:{b:c:d}}')), ('-dict', ((('@', 'a'), ('(', ('-slice', ('@', 'b'), ('@', 'c'), ('@', 'd')))),)))
		self.assertEqual (ast2nat2ast (p ('{a:b:c} = {a:b:c}')), ('=', ('(', ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c'))), ('(', ('-slice', ('@', 'a'), ('@', 'b'), ('@', 'c')))))
		self.assertEqual (ast2nat2ast (p ('\\[1:2:3]')), ('-mat', ((('-slice', ('#', '1'), ('#', '2'), ('#', '3')),),)))
		self.assertEqual (ast2nat2ast (p ('-{not x}')), ('-', ('(', ('-not', ('@', 'x')))))
		self.assertEqual (ast2nat2ast (p ('x < y in [y] in [[y]] != 2 > 1')), ('<>', ('@', 'x'), (('<', ('@', 'y')), ('in', ('[', (('@', 'y'),))), ('in', ('[', (('[', (('@', 'y'),)),))), ('!=', ('#', '2')), ('>', ('#', '1')))))
		self.assertEqual (ast2nat2ast (p ('x < y < z < w')), ('<>', ('@', 'x'), (('<', ('@', 'y')), ('<', ('@', 'z')), ('<', ('@', 'w')))))
		self.assertEqual (ast2nat2ast (p ('\\[]')), ('-mat', ()))
		self.assertEqual (ast2nat2ast (p ('\\[[]]')), ('-mat', ()))
		self.assertEqual (ast2nat2ast (p ('\\[[], []]')), ('-mat', ()))
		self.assertEqual (ast2nat2ast (p ('\\{a:b}')), ('-set', (('(', ('-slice', ('@', 'a'), ('@', 'b'), None)),)))
		self.assertEqual (ast2nat2ast (p ('{-x} y / z')), ('/', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'z')))
		self.assertEqual (ast2nat2ast (p ('d / dz {-1} a')), ('-diff', ('(', ('*', (('#', '-1'), ('@', 'a')))), 'd', (('z', 1),)))
		self.assertEqual (ast2nat2ast (p ('1 / {-2} x')), ('/', ('#', '1'), ('*', (('#', '-2'), ('@', 'x')))))
		self.assertEqual (ast2nat2ast (p ('\\sum_{x=0}^b {-x} y')), ('-sum', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'x'), ('#', '0'), ('@', 'b')))
		self.assertEqual (ast2nat2ast (p ('\\lim_{x\\to0} {-x} y')), ('-lim', ('*', (('-', ('@', 'x')), ('@', 'y'))), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2nat2ast (p ('\\int a / -1 dx')), ('-intg', ('/', ('@', 'a'), ('#', '-1')), ('@', 'dx')))
		self.assertEqual (ast2nat2ast (p ('\\[[[x]]]')), ('-mat', ((('[', (('@', 'x'),)),),)))
		self.assertEqual (ast2nat2ast (p ('\\[[[1, 2]], [[3]]]')), ('-mat', ((('[', (('#', '1'), ('#', '2'))),), (('[', (('#', '3'),)),))))
		self.assertEqual (ast2nat2ast (p ('{1/x}.limit (x, 0, "-")')), ('.', ('(', ('/', ('#', '1'), ('@', 'x'))), 'limit', (('@', 'x'), ('#', '0'), ('"', '-'))))
		self.assertEqual (ast2nat2ast (p ('{x^2y**2z}.diff (x, 2, y, z)')), ('.', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')))), 'diff', (('@', 'x'), ('#', '2'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2nat2ast (p ('{x y}.integrate ((x, 0, 1))')), ('.', ('(', ('*', (('@', 'x'), ('@', 'y')))), 'integrate', (('(', (',', (('@', 'x'), ('#', '0'), ('#', '1')))),)))
		self.assertEqual (ast2nat2ast (p ('\\sqrt (a:b)')), ('-sqrt', ('-slice', ('@', 'a'), ('@', 'b'), None)))
		self.assertEqual (ast2nat2ast (p ('\\sqrt[3] (a:b)')), ('-sqrt', ('-slice', ('@', 'a'), ('@', 'b'), None), ('#', '3')))
		self.assertEqual (ast2nat2ast (p ('? ()')), ('-ufunc', '?', ()))
		self.assertEqual (ast2nat2ast (p ('? (x)')), ('-ufunc', '?', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('? (x) (2)')), ('*', (('-ufunc', '?', (('@', 'x'),)), ('(', ('#', '2'))), {1}))
		self.assertEqual (ast2nat2ast (p ('? (2)')), ('-ufunc', '?', (('#', '2'),)))
		self.assertEqual (ast2nat2ast (p ('?f (x, y, real = True)')), ('-ufunc', 'f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2nat2ast (p ('?\\alpha(x)')), ('-ufunc', 'alpha', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('?beta(y)')), ('-ufunc', '?beta', (('@', 'y'),)))
		self.assertEqual (ast2nat2ast (p ("Function ('f', real = True) (x, y)")), ('-ufunc', 'f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2nat2ast (p ("x'")), ('-diffp', ('@', 'x'), 1))
		self.assertEqual (ast2nat2ast (p ("x''")), ('-diffp', ('@', 'x'), 2))
		self.assertEqual (ast2nat2ast (p ("{x + y}'")), ('-diffp', ('(', ('+', (('@', 'x'), ('@', 'y')))), 1))
		self.assertEqual (ast2nat2ast (p ("a [b]'")), ('-diffp', ('-idx', ('@', 'a'), (('@', 'b'),)), 1))
		self.assertEqual (ast2nat2ast (p ("a.b ()'")), ('-diffp', ('.', ('@', 'a'), 'b', ()), 1))
		self.assertEqual (ast2nat2ast (p ("{x/y}'")), ('-diffp', ('(', ('/', ('@', 'x'), ('@', 'y'))), 1))
		self.assertEqual (ast2nat2ast (p ("1'['ac']")), ('-idx', ('-diffp', ('#', '1'), 1), (('"', 'ac'),)))
		self.assertEqual (ast2nat2ast (p ("|x|'")), ('-diffp', ('|', ('@', 'x')), 1))
		self.assertEqual (ast2nat2ast (p ("| 'str'|'")), ('-diffp', ('|', ('"', 'str')), 1))
		self.assertEqual (ast2nat2ast (p ("{x**y}'")), ('-diffp', ('(', ('^', ('@', 'x'), ('@', 'y'))), 1))
		self.assertEqual (ast2nat2ast (p ("{{-1}'}")), ('-diffp', ('(', ('#', '-1')), 1))
		self.assertEqual (ast2nat2ast (p ("{a [b]}''")), ('-diffp', ('-idx', ('@', 'a'), (('@', 'b'),)), 2))
		self.assertEqual (ast2nat2ast (p ("1.'''")), ('-diffp', ('#', '1.'), 3))
		self.assertEqual (ast2nat2ast (p ('x [1]')), ('-idx', ('@', 'x'), (('#', '1'),)))
		self.assertEqual (ast2nat2ast (p ('1 [x]')), ('-idx', ('#', '1'), (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('[1, 2] [x]')), ('-idx', ('[', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('{1, 2} [x]')), ('-idx', ('-set', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('{x: 2} [x]')), ('-idx', ('-dict', ((('@', 'x'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('{y: 2} [x]')), ('-idx', ('-dict', ((('@', 'y'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ("'}'")), ('"', '}'))
		self.assertEqual (ast2nat2ast (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}')), ('*', (('@', 'q'), ('@', 'w'), ('@', 'e'), ('@', 'r'), ('@', 't'), ('@', 'y'), ('@', 'u'), ('@', 'i'), ('@', 'o'), ('@', 'p'), ('@', 'a'), ('@', 's'), ('@', 'd'), ('@', 'f'))))
		self.assertEqual (ast2nat2ast (p ('x, y = 1, 2')), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (ast2nat2ast (p ('x, 2 = 1, 2')), (',', (('@', 'x'), ('=', ('#', '2'), ('#', '1')), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('(x, y) = 1, 2')), (',', (('=', ('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1')), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('1; x, y = 1, 2')), (';', (('#', '1'), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))))
		self.assertEqual (ast2nat2ast (p ('1; x, 2 = 1, 2')), (';', (('#', '1'), (',', (('@', 'x'), ('=', ('#', '2'), ('#', '1')), ('#', '2'))))))
		self.assertEqual (ast2nat2ast (p ('1; (x, y) = 1, 2')), (';', (('#', '1'), (',', (('=', ('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1')), ('#', '2'))))))
		self.assertEqual (ast2nat2ast (p ('f()()')), ('*', (('-ufunc', 'f', ()), ('(', (',', ()))), {1}))
		self.assertEqual (ast2nat2ast (p ('f()*()')), ('*', (('-ufunc', 'f', ()), ('(', (',', ()))), {1}))
		self.assertEqual (ast2nat2ast (p ('f*()*()')), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1, 2}))
		self.assertEqual (ast2nat2ast (p ('f*()()')), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1}))

		self.assertEqual (ast2nat2ast (p ('dy / dx')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2nat2ast (p ('dy / dx z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z')), {1}))
		self.assertEqual (ast2nat2ast (p ('d**2 y / dx**2')), ('-diff', ('@', 'y'), 'd', (('x', 2),)))
		self.assertEqual (ast2nat2ast (p ('d**2 y / dx**2 z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 2),)), ('@', 'z')), {1}))
		self.assertEqual (ast2nat2ast (p ('d**2 y / dx dy')), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2nat2ast (p ('d**2 y / dx dy z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))), ('@', 'z')), {1}))
		self.assertEqual (ast2nat2ast (p ('\\frac{dy}{dx}')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2nat2ast (p ('\\frac{dy}{dx} z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z')), {1}))
		self.assertEqual (ast2nat2ast (p ('\\frac{d**2}{dx**2}')), ('/', ('(', ('^', ('@', 'd'), ('#', '2'))), ('^', ('@', 'dx'), ('#', '2'))))
		self.assertEqual (ast2nat2ast (p ('\\frac{d**2}{dx**2} z')), ('-diff', ('@', 'z'), 'd', (('x', 2),)))
		self.assertEqual (ast2nat2ast (p ('\\frac{d**2}{dx dy}')), ('/', ('(', ('^', ('@', 'd'), ('#', '2'))), ('*', (('@', 'dx'), ('@', 'dy')))))
		self.assertEqual (ast2nat2ast (p ('\\frac{d**2}{dx dy} z')), ('-diff', ('@', 'z'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2nat2ast (p ('\\frac{d**2 y}{dx dy}')), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2nat2ast (p ('\\frac{d**2 y}{dx dy} z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))), ('@', 'z')), {1}))
		self.assertEqual (ast2nat2ast (p ('\\int dy / dx')), ('-intg', ('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', '')))
		self.assertEqual (ast2nat2ast (p ('\\int d/dx x**2 dx')), ('-intg', ('-diff', ('(', ('^', ('@', 'x'), ('#', '2'))), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (ast2nat2ast (p ('\\int d/dx y(x) dx')), ('-intg', ('-diff', ('(', ('-ufunc', 'y', (('@', 'x'),))), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (ast2nat2ast (p ('\\int dx dx dx')), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx'), ('@', 'dx')), {1}))
		self.assertEqual (ast2nat2ast (p ('\\int dx * dx dx')), ('*', (('-intg', None, ('@', 'dx')), ('@', 'dx'), ('@', 'dx')), {1}))
		self.assertEqual (ast2nat2ast (p ('dlambda / dx : x')), ('-slice', ('-diff', ('@', 'lambda'), 'd', (('x', 1),)), ('@', 'x'), None))
		self.assertEqual (ast2nat2ast (p ('d**2 lambda / dx**2 : x')), ('-slice', ('-diff', ('@', 'lambda'), 'd', (('x', 2),)), ('@', 'x'), None))
		self.assertEqual (ast2nat2ast (p ('ln1.or')), ('.', ('@', 'ln1'), 'or'))
		self.assertRaises (AttributeError, ast2nat2ast, p ('ln1. or'))
		self.assertRaises (AttributeError, ast2nat2ast, p ('ln1 . or'))
		self.assertEqual (ast2nat2ast (p ('a.b * c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd'))))
		self.assertEqual (ast2nat2ast (p ('a.b c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd'))))
		self.assertEqual (ast2nat2ast (p ('lambda x, y, z: ln lambda x:')), (',', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('@', 'y'), ('-slice', ('@', 'z'), ('*', (('-log', ('@', 'lambda')), ('@', 'x'))), False))))
		self.assertEqual (ast2nat2ast (p ('lambda x, y, z: ln lambda x: 1')), ('-lamb', ('-log', ('-lamb', ('#', '1'), ('x',))), ('x', 'y', 'z')))

		self.assertEqual (ast2nat2ast (p ('f (x) (0)')), ('*', (('-ufunc', 'f', (('@', 'x'),)), ('(', ('#', '0'))), {1}))
		self.assertEqual (ast2nat2ast (p ('f (x, y) (0, 0)')), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'))), ('(', (',', (('#', '0'), ('#', '0'))))), {1}))
		self.assertEqual (ast2nat2ast (p ('f (x, y, z) (0, 0, 0)')), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('(', (',', (('#', '0'), ('#', '0'), ('#', '0'))))), {1}))
		self.assertEqual (ast2nat2ast (p ("f (x)' (0)")), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2nat2ast (p ('\\. x+y |_{x = 1}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (ast2nat2ast (p ('\\. x+y |_{x = 1, y = 2}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2nat2ast (p ('\\. x+y |_{x, y = 1, 2}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2nat2ast (p ('\\. x+y |_{\\substack{x = 1}}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (ast2nat2ast (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2nat2ast (p ('\\. f(x) |_{f(x) = y}')), ('-subs', ('-ufunc', 'f', (('@', 'x'),)), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')),)))
		self.assertEqual (ast2nat2ast (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}')), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2nat2ast (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}')), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2nat2ast (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}')), ('-subs', ('*', (('-ufunc', 'f', (('@', 'x'),)), ('-ufunc', 'f', (('@', 'y'),)))), ((('-ufunc', 'f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', 'f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2nat2ast (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}')), ('-subs', ('(', ('+', (('(', (',', (('#', '1'), ('#', '2')))), ('(', (',', (('#', '1'), ('#', '2'))))))), ((('(', (',', (('#', '1'), ('#', '2'), ('#', '1'), ('#', '2')))), ('(', (',', (('#', '3'), ('#', '4'))))),)))

		self.assertEqual (ast2nat2ast (p ("f (x)' (0)")), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2nat2ast (p ('d / dx (f (x)) (0)')), ('-subs', ('-diff', ('-ufunc', 'f', (('@', 'x'),)), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2nat2ast (p ('d / dx (u (x, y)) (x, y)')), ('-diff', ('(', ('-ufunc', 'u', (('@', 'x'), ('@', 'y')))), 'd', (('x', 1),)))
		self.assertEqual (ast2nat2ast (p ('d / dx (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2nat2ast (p ('d / dx (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2nat2ast (p ('d**2 / dx dy (u (x, y)) (x, y)')), ('-diff', ('(', ('-ufunc', 'u', (('@', 'x'), ('@', 'y')))), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2nat2ast (p ('d**2 / dx dy (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2nat2ast (p ('d**2 / dx dy (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2nat2ast (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})")), ('-func', 'dsolve', (('+', (('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 2), ('*', (('#', '11'), ('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 1))), ('*', (('#', '24'), ('-ufunc', 'y', (('@', 'x'),)))))), ('=', ('@', 'ics'), ('-dict', ((('-ufunc', 'y', (('#', '0'),)), ('#', '0')), (('-subs', ('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)), ('#', '-7'))))))))
		self.assertEqual (ast2nat2ast (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}")), ('-subs', ('[', (('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ('-diffp', ('-ufunc', 'g', (('@', 'y'),)), 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (ast2nat2ast (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')), ('-subs', ('[', (('-diff', ('(', ('-ufunc', 'f', (('@', 'x'), ('@', 'y')))), 'd', (('x', 1),)), ('-diff', ('(', ('-ufunc', 'g', (('@', 'y'), ('@', 'x')))), 'd', (('x', 1),)))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (ast2nat2ast (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')), ('-subs', ('-diff', ('(', ('-ufunc', 'f', (('@', 'x'), ('@', 'z')))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')), (('@', 'z'), ('#', '3')))))
		self.assertEqual (ast2nat2ast (p ('?() = 2')), ('=', ('-ufunc', '?', ()), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('?f() = 2')), ('=', ('-ufunc', '?f', ()), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('d / dx (a) b')), ('*', (('-diff', ('(', ('@', 'a')), 'd', (('x', 1),)), ('@', 'b')), {1}))
		self.assertEqual (ast2nat2ast (p ('\\frac{d}{dx} (a) b')), ('*', (('-diff', ('(', ('@', 'a')), 'd', (('x', 1),)), ('@', 'b')), {1}))
		self.assertEqual (ast2nat2ast (p ('sin (())')), ('-func', 'sin', (('(', (',', ())),)))
		self.assertEqual (ast2nat2ast (p ('sin (((a))')), ('-func', 'sin', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (ast2nat2ast (p ('a.b (())')), ('.', ('@', 'a'), 'b', (('(', (',', ())),)))
		self.assertEqual (ast2nat2ast (p ('a.b (((a))')), ('.', ('@', 'a'), 'b', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (ast2nat2ast (p ('@x')), ('-func', '@', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('@(x + y)')), ('-func', '@', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2nat2ast (p ('@(x + y)')), ('-func', '@', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2nat2ast (p ('%x')), ('-func', '%', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('%(x + y)')), ('-func', '%', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2nat2ast (p ('%%x')), ('-func', '%', (('-func', '%', (('@', 'x'),)),)))
		self.assertEqual (ast2nat2ast (p ('%%(x + y)')), ('-func', '%', (('-func', '%', (('+', (('@', 'x'), ('@', 'y'))),)),)))
		self.assertEqual (ast2nat2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]')), ('-idx', ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))), (('-slice', False, False, None), ('-slice', ('#', '1'), False, None))))

		self.assertEqual (ast2nat2ast (p ('N - N N 2')), ('+', (('@', 'N'), ('-', ('-func', 'N', (('-func', 'N', (('#', '2'),)),))))))
		self.assertEqual (ast2nat2ast (p ('N N N 2')), ('-func', 'N', (('-func', 'N', (('-func', 'N', (('#', '2'),)),)),)))
		self.assertEqual (ast2nat2ast (p ('sin sin sin 2')), ('-func', 'sin', (('-func', 'sin', (('-func', 'sin', (('#', '2'),)),)),)))
		self.assertEqual (ast2nat2ast (p ('-N sin -N 2')), ('-', ('-func', 'N', (('-func', 'sin', (('-', ('-func', 'N', (('#', '2'),))),)),))))
		self.assertEqual (ast2nat2ast (p ('sin -N sin 2')), ('-func', 'sin', (('-', ('-func', 'N', (('-func', 'sin', (('#', '2'),)),))),)))
		self.assertEqual (ast2nat2ast (p ('N N sin -a [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2nat2ast (p ('N N sin -a.b [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2nat2ast (p ('N N sin -a.b () [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2nat2ast (p ('N N sin -a.b () [2] [3]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),)), (('#', '3'),))),)),)),)))
		self.assertEqual (ast2nat2ast (p ('sin -N () [2] [3].c [4].d () [5]')), ('-func', 'sin', (('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))),)))
		self.assertEqual (ast2nat2ast (p ('sqrt -N () [2] [3].c [4].d () [5]')), ('-sqrt', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (ast2nat2ast (p ('sqrt[3] -N () [2] [3].c [4].d () [5]')), ('-sqrt', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))), ('#', '3')))
		self.assertEqual (ast2nat2ast (p ('log -N () [2] [3].c [4].d () [5]')), ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (ast2nat2ast (p ('\\log_2 -N () [2] [3].c [4].d () [5]')), ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))), ('#', '2')))
		self.assertEqual (ast2nat2ast (p ('N sin**2 ln**2 N x')), ('-func', 'N', (('^', ('-func', 'sin', (('^', ('(', ('-log', ('-func', 'N', (('@', 'x'),)))), ('#', '2')),)), ('#', '2')),)))
		self.assertEqual (ast2nat2ast (p ('sin ln N x')), ('-func', 'sin', (('-log', ('-func', 'N', (('@', 'x'),))),)))
		self.assertEqual (ast2nat2ast (p ('sin(a)**[a][b].c')), ('^', ('-func', 'sin', (('@', 'a'),)), ('.', ('-idx', ('[', (('@', 'a'),)), (('@', 'b'),)), 'c')))
		self.assertEqual (ast2nat2ast (p ('N sin N sin x')), ('-func', 'N', (('-func', 'sin', (('-func', 'N', (('-func', 'sin', (('@', 'x'),)),)),)),)))
		self.assertEqual (ast2nat2ast (p ('cos**-1 0 \\log_2 8')), ('*', (('-func', 'acos', (('#', '0'),)), ('-log', ('#', '8'), ('#', '2')))))
		self.assertEqual (ast2nat2ast (p ('N sin sqrt[3] \\log_2 8')), ('-func', 'N', (('-func', 'sin', (('-sqrt', ('-log', ('#', '8'), ('#', '2')), ('#', '3')),)),)))
		self.assertEqual (ast2nat2ast (p ('sin(x)**-a[b][c].d')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2nat2ast (p ('sin sin x [2].w')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),)))
		self.assertEqual (ast2nat2ast (p ('sin -sin x [2].w')), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (ast2nat2ast (p ('sin sin (x) [2].w')), ('-func', 'sin', (('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w'),)))
		self.assertEqual (ast2nat2ast (p ('sin -sin (x) [2].w')), ('-func', 'sin', (('-', ('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w')),)))
		self.assertEqual (ast2nat2ast (p ('sin sin x [2].w ()')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w', ()),)),)))
		self.assertEqual (ast2nat2ast (p ('ln ln x [2].w')), ('-log', ('-log', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'))))
		self.assertEqual (ast2nat2ast (p ('N N sin -a [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2nat2ast (p ('sin sin -x [2].w')), ('-func', 'sin', (('-func', 'sin', (('-', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w')),)),)))
		self.assertEqual (ast2nat2ast (p ('sin -sin x [2].w')), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (ast2nat2ast (p ('sin(a)**b[2]')), ('^', ('-func', 'sin', (('@', 'a'),)), ('-idx', ('@', 'b'), (('#', '2'),))))
		self.assertEqual (ast2nat2ast (p ('sin**-a[b][c].d x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2nat2ast (p ('sin**-a[b][c].d (x)')), ('^', ('@', 'sin'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2nat2ast (p ('sin**-a[b][c].d {(x)}')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2nat2ast (p ('sin**-a[b][c] (x)')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (ast2nat2ast (p ('\\int**-a[b][c] x')), ('-intg', ('@', 'x'), ('@', ''), ('#', '0'), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (ast2nat2ast (p ('\\int**-a[b][c].d (x)')), ('-intg', None, ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2nat2ast (p ('\\int**-a[b][c].d {(x)}')), ('-intg', ('(', ('@', 'x')), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2nat2ast (p ('\\int**-a[b][c].d (x) y')), ('-intg', ('@', 'y'), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2nat2ast (p ('\\int**-a[b][c].d {(x)} y')), ('-intg', ('*', (('(', ('@', 'x')), ('@', 'y'))), ('@', ''), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2nat2ast (p ('\\int**a.b[2] x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))))

		self.assertEqual (ast2nat2ast (p ('d/dx (real = True)')), ('-diff', ('(', ('=', ('@', 'real'), ('@', 'True'))), 'd', (('x', 1),)))
		self.assertEqual (ast2nat2ast (p ('f {\\left(x\\right)}')), ('-ufunc', 'f', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('a.b {(x)}')), ('*', (('.', ('@', 'a'), 'b'), ('(', ('@', 'x'), True))))
		self.assertEqual (ast2nat2ast (p ('a.b {\\left(x\\right)}')), ('.', ('@', 'a'), 'b', (('@', 'x'),)))
		self.assertEqual (ast2nat2ast (p ('\\log_{|x|} y')), ('-log', ('@', 'y'), ('|', ('@', 'x'))))
		self.assertEqual (ast2nat2ast (p ('|\\int a + b dx|')), ('|', ('-intg', ('+', (('@', 'a'), ('@', 'b'))), ('@', 'dx'))))
		self.assertEqual (ast2nat2ast (p ('\\int deg N dx')), ('-intg', ('-func', 'deg', (('@', 'N'),)), ('@', 'dx')))
		self.assertEqual (ast2nat2ast (p ('a \\int x dx / c')), ('/', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')))), ('@', 'c')))
		self.assertEqual (ast2nat2ast (p ('\\int x dx b / c')), ('/', ('*', (('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b')), {1}), ('@', 'c')))
		self.assertEqual (ast2nat2ast (p ('a \\int x dx b / c')), ('/', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b')), {2}), ('@', 'c')))
		self.assertEqual (ast2nat2ast (p ('a {\\lim_{x\\to0} \\int x dx} / b')), ('/', ('*', (('@', 'a'), ('-lim', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0')))), ('@', 'b')))
		self.assertEqual (ast2nat2ast (p ('a {\\sum_{x=0}^1 \\int x dx} / b')), ('/', ('*', (('@', 'a'), ('-sum', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0'), ('#', '1')))), ('@', 'b')))
		self.assertEqual (ast2nat2ast (p ('a / \\int x dx * c')), ('*', (('/', ('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx'))), ('@', 'c')), {1}))
		self.assertEqual (ast2nat2ast (p ('a / b \\int x dx * c')), ('*', (('/', ('@', 'a'), ('*', (('@', 'b'), ('-intg', ('@', 'x'), ('@', 'dx'))))), ('@', 'c')), {1}))

		self.assertEqual (ast2nat2ast (p ('cos')), ('@', 'cos'))
		self.assertEqual (ast2nat2ast (p ('f = cos')), ('=', ('@', 'f'), ('@', 'cos')))
		self.assertEqual (ast2nat2ast (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)')), ('.', ('-mat', ((('#', '0'), ('@', 'pi')), (('-', ('@', 'pi')), ('#', '0')))), 'applyfunc', (('@', 'cos'),)))
		self.assertEqual (ast2nat2ast (p ('$sin (real = True)')), ('-sym', 'sin', (('real', ('@', 'True')),)))
		self.assertEqual (ast2nat2ast (p ('sin = $(real = True)')), ('=', ('@', 'sin'), ('-sym', '', (('real', ('@', 'True')),))))

	def test_ast2py2ast (self):
		self.assertEqual (ast2py2ast (p ('1')), ('#', '1'))
		self.assertEqual (ast2py2ast (p ('1.')), ('#', '1.'))
		self.assertEqual (ast2py2ast (p ('.1')), ('#', '0.1'))
		self.assertEqual (ast2py2ast (p ('1e20')), ('#', '1e+20'))
		self.assertEqual (ast2py2ast (p ('1E-20')), ('#', '1e-20'))
		self.assertEqual (ast2py2ast (p ('1.e+20')), ('#', '1.e+20'))
		self.assertEqual (ast2py2ast (p ('.1e-20')), ('#', '0.1e-20'))
		self.assertEqual (ast2py2ast (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')), ('-func', 'sin', (('#', '-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901'),)))
		self.assertEqual (ast2py2ast (p ('x')), ('@', 'x'))
		self.assertEqual (ast2py2ast (p ('xy')), ('@', 'xy'))
		self.assertEqual (ast2py2ast (p ('dx')), ('@', 'dx'))
		self.assertEqual (ast2py2ast (p ('partialx')), ('@', 'partialx'))
		self.assertEqual (ast2py2ast (p ('\\partial x')), ('@', 'partialx'))
		self.assertEqual (ast2py2ast (p ('x d  y')), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y')), {1, 2}))
		self.assertEqual (ast2py2ast (p ('x partial y')), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y')), {1, 2}))
		self.assertEqual (ast2py2ast (p ('x \\partial  y')), ('*', (('@', 'x'), ('@', 'partial'), ('@', 'y')), {1, 2}))
		self.assertEqual (ast2py2ast (p ('x dx dy y')), ('*', (('@', 'x'), ('@', 'dx'), ('@', 'dy'), ('@', 'y')), {1, 2, 3}))
		self.assertEqual (ast2py2ast (p ('x partialx partialy y')), ('*', (('@', 'x'), ('@', 'partialx'), ('@', 'partialy'), ('@', 'y')), {1, 2, 3}))
		self.assertEqual (ast2py2ast (p ('-1')), ('#', '-1'))
		self.assertEqual (ast2py2ast (p ('-x')), ('-', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('{x}')), ('@', 'x'))
		self.assertEqual (ast2py2ast (p ('()')), ('(', (',', ())))
		self.assertEqual (ast2py2ast (p ('(x)')), ('(', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('(x,)')), ('(', (',', (('@', 'x'),))))
		self.assertEqual (ast2py2ast (p ('(x,y)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2py2ast (p ('(x,y,)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2py2ast (p ('[]')), ('[', ()))
		self.assertEqual (ast2py2ast (p ('[x]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('[x,]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('[x,y]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('[x,y,]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('"x\\x20\\n"')), ('"', 'x \n'))
		self.assertEqual (ast2py2ast (p ("'x\\x20\\n'")), ('"', 'x \n'))
		self.assertEqual (ast2py2ast (p ('|x|')), ('-func', 'abs', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('x!')), ('-func', 'factorial', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('x+y')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('x-y')), ('+', (('@', 'x'), ('-', ('@', 'y')))))
		self.assertEqual (ast2py2ast (p ('x*y')), ('*', (('@', 'x'), ('@', 'y')), {1}))
		self.assertEqual (ast2py2ast (p ('x y')), ('*', (('@', 'x'), ('@', 'y')), {1}))
		self.assertEqual (ast2py2ast (p ('x(y)')), ('-ufunc', '?x', (('@', 'y'),)))
		self.assertEqual (ast2py2ast (p ('x*(y)')), ('*', (('@', 'x'), ('(', ('@', 'y'))), {1}))
		self.assertEqual (ast2py2ast (p ('x/y')), ('/', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2py2ast (p ('x^y')), ('^', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2py2ast (p ('log x')), ('-log', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('log {x}')), ('-log', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('log (x)')), ('-log', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('\\log_2 x')), ('/', ('-log', ('@', 'x')), ('-log', ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('\\log_2 {x}')), ('/', ('-log', ('@', 'x')), ('-log', ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('\\log_2 (x)')), ('/', ('-log', ('@', 'x')), ('-log', ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('sqrt x')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('sqrt {x}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('sqrt (x)')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('sqrt {(x)}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('sqrt[3] x')), ('^', ('@', 'x'), ('(', ('/', ('#', '1'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('sqrt[3] {x}')), ('^', ('@', 'x'), ('(', ('/', ('#', '1'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('sqrt[3] {(x)}')), ('^', ('@', 'x'), ('(', ('/', ('#', '1'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('sqrt[3] (x)')), ('^', ('@', 'x'), ('(', ('/', ('#', '1'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('sin x')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('sin^2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('sin (x)')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('sin (x)^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('sin {x}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('sin {(x)}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('{sin x}^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('sin**2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('sin**-1 x')), ('-func', 'asin', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('sin(x)**-1')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '-1')))
		self.assertEqual (ast2py2ast (p ('acos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('\\arccos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('sin(x**2)')), ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ('sin(x**2)**2')), ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('(sin(x**2)**2)')), ('(', ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('ln(x**2)')), ('-log', ('^', ('@', 'x'), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('ln(x**2)**2')), ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('(ln(x**2)**2)')), ('(', ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('gamma(x**2)')), ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ('gamma(x**2)**2')), ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('(gamma(x**2)**2)')), ('(', ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('{gamma}[2]')), ('-idx', ('(', ('@', 'gamma')), (('#', '2'),)))
		self.assertEqual (ast2py2ast (p ('{Gamma}[2]')), ('-idx', ('(', ('@', 'Gamma')), (('#', '2'),)))
		self.assertEqual (ast2py2ast (p ('f{(x)}')), ('*', (('@', 'f'), ('(', ('@', 'x'))), {1}))
		self.assertEqual (ast2py2ast (p ("f{(x)}'(0)")), ('*', (('@', 'f'), ('-func', 'diff', (('(', ('@', 'x')),)), ('(', ('#', '0'))), {1, 2}))
		self.assertEqual (ast2py2ast (p ("f{(x)}'{(0)}")), ('*', (('@', 'f'), ('-func', 'diff', (('(', ('@', 'x')),)), ('(', ('#', '0'))), {1, 2}))
		self.assertEqual (ast2py2ast (p ('\\operatorname{x_{1}}{\\left(x \\right)}')), ('-ufunc', '?x1', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('\\lim_{x\\to0} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2py2ast (p ('\\lim_{x\\to0^+} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2py2ast (p ('\\lim_{x\\to0**-} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2py2ast (p ('Limit (1/x, x, 0)')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2py2ast (p ('Limit (1/x, x, 0, "-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2py2ast (p ('Limit (1/x, x, 0, dir="+-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2py2ast (p ('limit (1/x, x, 0)')), ('-func', 'limit', (('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'))))
		self.assertEqual (ast2py2ast (p ('limit (1/x, x, 0, "-")')), ('-func', 'limit', (('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), ('"', '-'))))
		self.assertEqual (ast2py2ast (p ('limit (1/x, x, 0, dir="+-")')), ('-func', 'limit', (('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), ('=', ('@', 'dir'), ('"', '+-')))))
		self.assertEqual (ast2py2ast (p ('\\sum_{n=0}^\\infty x^n/n!')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('-func', 'factorial', (('@', 'n'),))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2py2ast (p ('Sum (x^n/n!, (n, 0, oo))')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('-func', 'factorial', (('@', 'n'),))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2py2ast (p ('summation (x^n/n!, (n, 0, oo))')), ('-func', 'summation', (('/', ('^', ('@', 'x'), ('@', 'n')), ('-func', 'factorial', (('@', 'n'),))), ('(', (',', (('@', 'n'), ('#', '0'), ('@', 'oo')))))))
		self.assertEqual (ast2py2ast (p ('d/dx x**2y**2z')), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')), {1, 2}), 'd', (('x', 1),)))
		self.assertEqual (ast2py2ast (p ('d^2/dx^2 x^2y**2z')), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')), {1, 2}), 'd', (('x', 2),)))
		self.assertEqual (ast2py2ast (p ('d^3/dx^2dy x^2y**2z')), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')), {1, 2}), 'd', (('x', 2), ('y', 1))))
		self.assertEqual (ast2py2ast (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z')), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')), {1, 2}), 'd', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2py2ast (p ('d**1.5 / dx dy x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '1.5')), ('(', ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))), {1, 2, 3}))))
		self.assertEqual (ast2py2ast (p ('d**-2 / dx dy x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '-2')), ('(', ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))), {1, 2, 3}))))
		self.assertEqual (ast2py2ast (p ('d**2 / dx**1.5 x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '2')), ('(', ('*', (('^', ('@', 'dx'), ('#', '1.5')), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))), {1, 2}))))
		self.assertEqual (ast2py2ast (p ('Derivative (x^2y**2z, x, 2, y, z)')), ('-diff', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')), {1, 2}), 'd', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2py2ast (p ('diff (x^2y**2z, x, 2, y, z)')), ('-func', 'diff', (('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')), {1, 2}), ('@', 'x'), ('#', '2'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2py2ast (p ('\\int dx')), ('-intg', ('#', '1'), ('@', 'dx')))
		self.assertEqual (ast2py2ast (p ('\\int x dx')), ('-intg', ('@', 'x'), ('@', 'dx')))
		self.assertEqual (ast2py2ast (p ('\\int_0^1 x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2py2ast (p ('\\int_0^1 \\int y dy dx')), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2py2ast (p ('Integral (\\int y dy, (x, 0, 1))')), ('-intg', ('-intg', ('@', 'y'), ('@', 'dy')), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2py2ast (p ('integrate (\\int y dy, (x, 0, 1))')), ('-func', 'integrate', (('-intg', ('@', 'y'), ('@', 'dy')), ('(', (',', (('@', 'x'), ('#', '0'), ('#', '1')))))))

		self.assertEqual (ast2py2ast (p ('\\[1,]')), ('-func', 'Matrix', (('[', (('#', '1'),)),)))
		self.assertEqual (ast2py2ast (p ('\\[1,2]')), ('-func', 'Matrix', (('[', (('#', '1'), ('#', '2'))),)))
		self.assertEqual (ast2py2ast (p ('\\[1,2,]')), ('-func', 'Matrix', (('[', (('#', '1'), ('#', '2'))),)))
		self.assertEqual (ast2py2ast (p ('\\[[1,],]')), ('-func', 'Matrix', (('[', (('#', '1'),)),)))
		self.assertEqual (ast2py2ast (p ('\\[[1,],[2,]]')), ('-func', 'Matrix', (('[', (('#', '1'), ('#', '2'))),)))
		self.assertEqual (ast2py2ast (p ('\\[[1,],[2,],]')), ('-func', 'Matrix', (('[', (('#', '1'), ('#', '2'))),)))
		self.assertEqual (ast2py2ast (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]')), ('-func', 'Matrix', (('[', (('#', '1'),)),)))
		self.assertEqual (ast2py2ast (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}')), ('-func', 'Matrix', (('[', (('#', '1'),)),)))
		self.assertEqual (ast2py2ast (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}')), ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'))),)),)))
		self.assertEqual (ast2py2ast (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}')), ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'))), ('[', (('#', '3'), ('#', '4'))))),)))
		self.assertEqual (ast2py2ast (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}')), ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'))), ('[', (('#', '3'), ('#', '4'))))),)))
		self.assertEqual (ast2py2ast (p ('\\[1,2]!')), ('-func', 'factorial', (('-func', 'Matrix', (('[', (('#', '1'), ('#', '2'))),)),)))
		self.assertEqual (ast2py2ast (p ('\\[[0,1],[1,0]]**x')), ('^', ('-func', 'Matrix', (('[', (('[', (('#', '0'), ('#', '1'))), ('[', (('#', '1'), ('#', '0'))))),)), ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('\\[[1,2],[3,4]]!')), ('-func', 'factorial', (('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'))), ('[', (('#', '3'), ('#', '4'))))),)),)))
		self.assertEqual (ast2py2ast (p ('\\[[1,2,3],[4,5,6]].T')), ('.', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), 'T'))
		self.assertEqual (ast2py2ast (p ('\\[[1,2,3],[4,5,6]].T.T')), ('.', ('.', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), 'T'), 'T'))
		self.assertEqual (ast2py2ast (p ('\\[[1,2,3],[4,5,6]].T.T.T')), ('.', ('.', ('.', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), 'T'), 'T'), 'T'))
		self.assertEqual (ast2py2ast (p ('\\[[1,2,3],[4,5,6]].transpose ()')), ('.', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), 'transpose', ()))
		self.assertEqual (ast2py2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()')), ('.', ('.', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2py2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()')), ('.', ('.', ('.', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), 'transpose', ()), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2py2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()')), ('.', ('.', ('.', ('.', ('.', ('.', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), 'transpose', ()), 'transpose', ()), 'T'), 'T'), 'transpose', ()), 'transpose', ()))
		self.assertEqual (ast2py2ast (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]')), ('*', (('-func', 'Matrix', (('[', (('[', (('@', 'A'), ('@', 'B'))), ('[', (('@', 'C'), ('@', 'D'))))),)), ('-func', 'Matrix', (('[', (('@', 'x'), ('@', 'y'))),))), {1}))
		self.assertEqual (ast2py2ast (p ('\\[[1, 2], [3')), ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'))), ('[', (('#', '3'),)))),)))
		self.assertEqual (ast2py2ast (p ('\\[[1, 2], [3]]')), ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'))), ('[', (('#', '3'),)))),)))
		self.assertEqual (ast2py2ast (p ('\\[[1], [2, 3]]')), ('-func', 'Matrix', (('[', (('[', (('#', '1'),)), ('[', (('#', '2'), ('#', '3'))))),)))

		self.assertEqual (ast2py2ast (p ('-1**x')), ('-', ('^', ('#', '1'), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('{-1}**x')), ('^', ('(', ('#', '-1')), ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('-{-1}**x')), ('-', ('^', ('(', ('#', '-1')), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('(-1)**x')), ('^', ('(', ('#', '-1')), ('@', 'x')))
		self.assertEqual (ast2py2ast (p ('-(-1)**x')), ('-', ('^', ('(', ('#', '-1')), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (ast2py2ast (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')), (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega'))))
		self.assertEqual (ast2py2ast (p ('1 if x < y')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))),)))
		self.assertEqual (ast2py2ast (p ('1 if x < y else 3')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))), ('(', (',', (('#', '3'), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('1 if x < y else 3 if x < z')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))), ('(', (',', (('#', '3'), ('-func', 'Lt', (('@', 'x'), ('@', 'z')))))))))
		self.assertEqual (ast2py2ast (p ('1 if x < y else 3 if x < z else 5')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))), ('(', (',', (('#', '3'), ('-func', 'Lt', (('@', 'x'), ('@', 'z')))))), ('(', (',', (('#', '5'), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))), ('(', (',', (('#', '3'), ('-func', 'Lt', (('@', 'x'), ('@', 'z')))))), ('(', (',', (('#', '5'), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))), ('(', (',', (('#', '3'), ('-func', 'Lt', (('@', 'x'), ('@', 'z')))))), ('(', (',', (('#', '5'), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))), ('(', (',', (('#', '3'), ('-func', 'Lt', (('@', 'x'), ('@', 'z')))))), ('(', (',', (('#', '5'), ('-func', 'Lt', (('@', 'x'), ('@', 'w')))))))))
		self.assertEqual (ast2py2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('@', 'y')))))), ('(', (',', (('#', '3'), ('-func', 'Lt', (('@', 'x'), ('@', 'z')))))), ('(', (',', (('#', '5'), ('-func', 'Lt', (('@', 'x'), ('@', 'w')))))))))
		self.assertEqual (ast2py2ast (p ('x**y.a')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a')))
		self.assertEqual (ast2py2ast (p ('x**y.a ()')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a', ())))
		self.assertEqual (ast2py2ast (p ('x**y.a.b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b')))
		self.assertEqual (ast2py2ast (p ('x**y.a.b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b', ())))
		self.assertEqual (ast2py2ast (p ('x**y.a ().b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b')))
		self.assertEqual (ast2py2ast (p ('x**y.a ().b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b', ())))
		self.assertEqual (ast2py2ast (p ('{1 if x < 0 else 3} if x < 1 else 5')), ('-func', 'Piecewise', (('(', (',', (('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('#', '0')))))), ('(', (',', (('#', '3'), ('@', 'True')))))), ('-func', 'Lt', (('@', 'x'), ('#', '1')))))), ('(', (',', (('#', '5'), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('1 if {True if x < 0 else False} else 5')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Piecewise', (('(', (',', (('@', 'True'), ('-func', 'Lt', (('@', 'x'), ('#', '0')))))), ('(', (',', (('@', 'False'), ('@', 'True'))))))))), ('(', (',', (('#', '5'), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Piecewise', (('(', (',', (('@', 'True'), ('-func', 'Lt', (('@', 'x'), ('#', '0')))))), ('(', (',', (('@', 'False'), ('@', 'True'))))))))), ('(', (',', (('-func', 'Piecewise', (('(', (',', (('#', '7'), ('-func', 'Lt', (('@', 'x'), ('#', '1')))))), ('(', (',', (('#', '5'), ('@', 'True')))))), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')), ('-func', 'Piecewise', (('(', (',', (('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Lt', (('@', 'x'), ('#', '0')))))), ('(', (',', (('#', '9'), ('@', 'True')))))), ('-func', 'Piecewise', (('(', (',', (('@', 'True'), ('-func', 'Lt', (('@', 'x'), ('#', '1')))))), ('(', (',', (('@', 'False'), ('@', 'True'))))))))), ('(', (',', (('-func', 'Piecewise', (('(', (',', (('#', '7'), ('-func', 'Lt', (('@', 'x'), ('#', '2')))))), ('(', (',', (('#', '5'), ('@', 'True')))))), ('@', 'True')))))))
		self.assertEqual (ast2py2ast (p ('x.y!')), ('-func', 'factorial', (('.', ('@', 'x'), 'y'),)))
		self.assertEqual (ast2py2ast (p ('x.y**2')), ('^', ('.', ('@', 'x'), 'y'), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('x.y ()!')), ('-func', 'factorial', (('.', ('@', 'x'), 'y', ()),)))
		self.assertEqual (ast2py2ast (p ('x.y ()**2')), ('^', ('.', ('@', 'x'), 'y', ()), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('x**y.a!')), ('^', ('@', 'x'), ('-func', 'factorial', (('.', ('@', 'y'), 'a'),))))
		self.assertEqual (ast2py2ast (p ('x**y.a**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a'), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('x**y.a ()!')), ('^', ('@', 'x'), ('-func', 'factorial', (('.', ('@', 'y'), 'a', ()),))))
		self.assertEqual (ast2py2ast (p ('x**y.a ()**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a', ()), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('lambda: x')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2py2ast (p ('lambda x: x**2')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2py2ast (p ('lambda x, y: x + y')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2py2ast (p ('lambda x, y, z: x + y + z')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))
		self.assertEqual (ast2py2ast (p ('1, lambda: x')), (',', (('#', '1'), ('-lamb', ('@', 'x'), ()))))
		self.assertEqual (ast2py2ast (p ('1, lambda x: x**2')), (',', (('#', '1'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))))
		self.assertEqual (ast2py2ast (p ('1, lambda x, y: x + y')), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))))
		self.assertEqual (ast2py2ast (p ('1, lambda x, y, z: x + y + z')), (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))))
		self.assertEqual (ast2py2ast (p ('f = lambda: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ())))
		self.assertEqual (ast2py2ast (p ('f = lambda x: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x',))))
		self.assertEqual (ast2py2ast (p ('f = lambda x, y: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y'))))
		self.assertEqual (ast2py2ast (p ('f = lambda x, y, z: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y', 'z'))))
		self.assertEqual (ast2py2ast (p ('\\left(\\left(\\right) \\mapsto x \\right)')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2py2ast (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2py2ast (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2py2ast (p ('\\lambda: x')), ('-func', 'slice', (('@', 'lambda'), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('\\lambda x: x')), ('-func', 'slice', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('\\lambda x, y: x')), (',', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('-func', 'slice', (('@', 'y'), ('@', 'x'))))))
		self.assertEqual (ast2py2ast (p ('{lambda}: x')), ('-func', 'slice', (('@', 'lambda'), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('{lambda} x: x')), ('-func', 'slice', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('{lambda} x, y: x')), (',', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('-func', 'slice', (('@', 'y'), ('@', 'x'))))))
		self.assertEqual (ast2py2ast (p ('$')), ('-sym', ''))
		self.assertEqual (ast2py2ast (p ('$s')), ('-sym', 's'))
		self.assertEqual (ast2py2ast (p ('$ (real = True)')), ('-sym', '', (('real', ('@', 'True')),)))
		self.assertEqual (ast2py2ast (p ('$s (real = True)')), ('-sym', 's', (('real', ('@', 'True')),)))

		self.assertEqual (ast2py2ast (p ('eye (2).is_diagonal ()')), ('.', ('-func', 'eye', (('#', '2'),)), 'is_diagonal', ()))
		self.assertEqual (ast2py2ast (p ('a [2]')), ('-idx', ('@', 'a'), (('#', '2'),)))
		self.assertEqual (ast2py2ast (p ('a [2,3]')), ('-idx', ('@', 'a'), (('#', '2'), ('#', '3'))))
		self.assertEqual (ast2py2ast (p ('a * [2]')), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (ast2py2ast (p ('a * {-1}[x]')), ('*', (('@', 'a'), ('-idx', ('(', ('#', '-1')), (('@', 'x'),))), {1}))
		self.assertEqual (ast2py2ast (p ('a * [x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (ast2py2ast (p ('N (1/2)')), ('-func', 'N', (('/', ('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ("S ('1/2')")), ('-func', 'S', (('"', '1/2'),)))
		self.assertEqual (ast2py2ast (p ("N (S ('1/2'))")), ('-func', 'N', (('-func', 'S', (('"', '1/2'),)),)))
		self.assertEqual (ast2py2ast (p ('S.Half')), ('.', ('@', 'S'), 'Half'))
		self.assertEqual (ast2py2ast (p ('N S.Half')), ('-func', 'N', (('.', ('@', 'S'), 'Half'),)))
		self.assertEqual (ast2py2ast (p ('o [i].t')), ('.', ('-idx', ('@', 'o'), (('@', 'i'),)), 't'))
		self.assertEqual (ast2py2ast (p ('o [i]**2')), ('^', ('-idx', ('@', 'o'), (('@', 'i'),)), ('#', '2')))
		self.assertEqual (ast2py2ast (p ('o [i]!')), ('-func', 'factorial', (('-idx', ('@', 'o'), (('@', 'i'),)),)))
		self.assertEqual (ast2py2ast (p ("'Hello' [::-1]")), ('-idx', ('"', 'Hello'), (('-slice', False, False, ('#', '-1')),)))
		self.assertEqual (ast2py2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]')), ('-idx', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), (('-slice', False, False, None), ('#', '1'))))
		self.assertEqual (ast2py2ast (p ('\\binom96')), ('-func', 'binomial', (('#', '9'), ('#', '6'))))
		self.assertEqual (ast2py2ast (p ('binomial (x, y)')), ('-func', 'binomial', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('y - 1*x')), ('+', (('@', 'y'), ('-', ('*', (('#', '1'), ('@', 'x')), {1})))))
		self.assertEqual (ast2py2ast (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('*', (('#', '2'), ('@', 'x')), {1}), ('#', '1'))), ('@', 'x'), ('=', ('@', 'domain'), ('"', 'ZZ')))))
		self.assertEqual (ast2py2ast (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'), ('@', 'y')), {1, 2}))), ('@', 'x'), ('@', 'y'), ('=', ('@', 'domain'), ('"', 'CC')))))
		self.assertEqual (ast2py2ast (p ('oct(10)')), ('-func', 'oct', (('#', '10'),)))
		self.assertEqual (ast2py2ast (p ('(1,) + (2,)')), ('+', (('(', (',', (('#', '1'),))), ('(', (',', (('#', '2'),))))))
		self.assertEqual (ast2py2ast (p ('[1] + [2]')), ('+', (('[', (('#', '1'),)), ('[', (('#', '2'),)))))
		self.assertEqual (ast2py2ast (p ("'a' + 'b'")), ('+', (('"', 'a'), ('"', 'b'))))
		self.assertEqual (ast2py2ast (p ('(1,) * 2')), ('*', (('(', (',', (('#', '1'),))), ('#', '2')), {1}))
		self.assertEqual (ast2py2ast (p ('[1] * 2')), ('*', (('[', (('#', '1'),)), ('#', '2')), {1}))
		self.assertEqual (ast2py2ast (p ("'a' * 2")), ('*', (('"', 'a'), ('#', '2')), {1}))
		self.assertEqual (ast2py2ast (p ('Lambda (x, x**2)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2py2ast (p ('beta (2, 3)')), ('-func', 'beta', (('#', '2'), ('#', '3'))))
		self.assertEqual (ast2py2ast (p ('{x d} y')), ('*', (('@', 'x'), ('@', 'd'), ('@', 'y')), {1, 2}))
		self.assertEqual (ast2py2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('(', ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))), {1}))))
		self.assertEqual (ast2py2ast (p ('ln((a)**b)')), ('-log', ('^', ('(', ('@', 'a')), ('@', 'b'))))
		self.assertEqual (ast2py2ast (p ('a * \\int dx + {\\int dx dx}')), ('+', (('*', (('@', 'a'), ('-intg', ('#', '1'), ('@', 'dx'))), {1}), ('*', (('-intg', ('#', '1'), ('@', 'dx')), ('@', 'dx')), {1}))))
		self.assertEqual (ast2py2ast (p ('1 if {a = x if z} else 0 if y')), ('-func', 'Piecewise', (('(', (',', (('#', '1'), ('-func', 'Eq', (('@', 'a'), ('-func', 'Piecewise', (('(', (',', (('@', 'x'), ('@', 'z')))),))))))), ('(', (',', (('#', '0'), ('@', 'y')))))))
		self.assertEqual (ast2py2ast (p ('a, lambda: b = 1')), (',', (('@', 'a'), ('-lamb', ('-func', 'Eq', (('@', 'b'), ('#', '1'))), ()))))
		self.assertEqual (ast2py2ast (p ('a * [2]')), ('*', (('@', 'a'), ('[', (('#', '2'),))), {1}))
		self.assertEqual (ast2py2ast (p ('sqrt(1, 2)')), ('-sqrt', (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (ast2py2ast (p ('x*[][y]')), ('*', (('@', 'x'), ('-idx', ('[', ()), (('@', 'y'),))), {1}))
		self.assertEqual (ast2py2ast (p ('lambda: x:')), ('-lamb', ('-func', 'slice', (('@', 'x'), ('@', 'None'))), ()))
		self.assertEqual (ast2py2ast (p ('a*[x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),))), {1}))
		self.assertEqual (ast2py2ast (p ('a*()**2')), ('*', (('@', 'a'), ('^', ('(', (',', ())), ('#', '2'))), {1}))
		self.assertEqual (ast2py2ast (p ('a*().t')), ('*', (('@', 'a'), ('.', ('(', (',', ())), 't')), {1}))
		self.assertEqual (ast2py2ast (p ('a*()[2]')), ('*', (('@', 'a'), ('-idx', ('(', (',', ())), (('#', '2'),))), {1}))
		self.assertEqual (ast2py2ast (p ('o.f*(a)')), ('*', (('.', ('@', 'o'), 'f'), ('(', ('@', 'a'))), {1}))
		self.assertEqual (ast2py2ast (p ('o.f*{1+2}')), ('*', (('.', ('@', 'o'), 'f'), ('(', ('+', (('#', '1'), ('#', '2'))))), {1}))
		self.assertEqual (ast2py2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2e+0')), ('(', ('*', (('^', ('@', 'dx'), ('#', '2e+0')), ('^', ('@', 'x'), ('#', '3'))), {1}))))
		self.assertEqual (ast2py2ast (p ('y**z [w]')), ('^', ('@', 'y'), ('-idx', ('@', 'z'), (('@', 'w'),))))
		self.assertEqual (ast2py2ast (p ('{y**z} [w]')), ('-idx', ('(', ('^', ('@', 'y'), ('@', 'z'))), (('@', 'w'),)))
		self.assertEqual (ast2py2ast (p ('x {y**z} [w]')), ('*', (('@', 'x'), ('-idx', ('(', ('^', ('@', 'y'), ('@', 'z'))), (('@', 'w'),))), {1}))
		self.assertEqual (ast2py2ast (p ('{x y**z} [w]')), ('-idx', ('(', ('*', (('@', 'x'), ('^', ('@', 'y'), ('@', 'z'))), {1})), (('@', 'w'),)))
		self.assertEqual (ast2py2ast (p ('Min (x, y, z)')), ('-func', 'Min', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2py2ast (p ('Max (x, y, z)')), ('-func', 'Max', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2py2ast (p ('\\Re (z)')), ('-func', 're', (('@', 'z'),)))
		self.assertEqual (ast2py2ast (p ('\\Im (z)')), ('-func', 'im', (('@', 'z'),)))
		self.assertEqual (ast2py2ast (p ('re (z)')), ('-func', 're', (('@', 'z'),)))
		self.assertEqual (ast2py2ast (p ('im (z)')), ('-func', 'im', (('@', 'z'),)))
		self.assertEqual (ast2py2ast (p ('{}')), ('-dict', ()))
		self.assertEqual (ast2py2ast (p ('{1: 2}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ('{1: 2,}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ('{1: 2, 3: 4}')), ('-dict', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2py2ast (p ('set ()')), ('-func', 'set', ()))
		self.assertEqual (ast2py2ast (p ('\\{}')), ('-func', 'FiniteSet', ()))
		self.assertEqual (ast2py2ast (p ('\\{1}')), ('-func', 'FiniteSet', (('#', '1'),)))
		self.assertEqual (ast2py2ast (p ('\\{1,2}')), ('-func', 'FiniteSet', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('{1,2}')), ('-func', 'FiniteSet', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('1 in {1,2,3}')), ('<>', ('#', '1'), (('in', ('-func', 'FiniteSet', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2py2ast (p ('1 \\in {1,2,3}')), ('<>', ('#', '1'), (('in', ('-func', 'FiniteSet', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2py2ast (p ('4 in {1,2,3}')), ('<>', ('#', '4'), (('in', ('-func', 'FiniteSet', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2py2ast (p ('4 \\in {1,2,3}')), ('<>', ('#', '4'), (('in', ('-func', 'FiniteSet', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2py2ast (p ('4 not in {1,2,3}')), ('<>', ('#', '4'), (('notin', ('-func', 'FiniteSet', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2py2ast (p ('4 \\notin {1,2,3}')), ('<>', ('#', '4'), (('notin', ('-func', 'FiniteSet', (('#', '1'), ('#', '2'), ('#', '3')))),)))
		self.assertEqual (ast2py2ast (p ('{1,2} - {2,3}')), ('+', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-', ('-func', 'FiniteSet', (('#', '2'), ('#', '3')))))))
		self.assertEqual (ast2py2ast (p ('{1,2} || {2,3}')), ('-func', 'Union', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-func', 'FiniteSet', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2py2ast (p ('{1,2} ^^ {2,3}')), ('-func', 'SymmetricDifference', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-func', 'FiniteSet', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2py2ast (p ('{1,2} && {2,3}')), ('-func', 'Intersection', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-func', 'FiniteSet', (('#', '2'), ('#', '3'))))))
		self.assertEqual (ast2py2ast (p ('{1,2} || {2,3} || {3,4}')), ('-func', 'Union', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-func', 'FiniteSet', (('#', '2'), ('#', '3'))), ('-func', 'FiniteSet', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2py2ast (p ('{1,2} ^^ {2,3} ^^ {3,4}')), ('-func', 'SymmetricDifference', (('-func', 'SymmetricDifference', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-func', 'FiniteSet', (('#', '2'), ('#', '3'))))), ('-func', 'FiniteSet', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2py2ast (p ('{1,2} && {2,3} && {3,4}')), ('-func', 'Intersection', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-func', 'FiniteSet', (('#', '2'), ('#', '3'))), ('-func', 'FiniteSet', (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2py2ast (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}')), ('-func', 'Union', (('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), ('-func', 'SymmetricDifference', (('-func', 'FiniteSet', (('#', '2'), ('#', '3'))), ('-func', 'Intersection', (('-func', 'FiniteSet', (('#', '3'), ('#', '4'))), ('-func', 'FiniteSet', (('#', '4'), ('#', '5'))))))))))
		self.assertEqual (ast2py2ast (p ('solve (x**2 = 4)')), ('-func', 'solve', (('-func', 'Eq', (('^', ('@', 'x'), ('#', '2')), ('#', '4'))),)))
		self.assertEqual (ast2py2ast (p ('Subs (x y, x, 2)')), ('-subs', ('*', (('@', 'x'), ('@', 'y')), {1}), ((('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ('Subs (x y, (x, y), (2, 3))')), ('-subs', ('*', (('@', 'x'), ('@', 'y')), {1}), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('(x y).subs (x, 2)')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y')), {1})), ((('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ('(x y).subs (x, 2).subs (y, 3)')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y')), {1})), ((('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])')), ('-subs', ('(', ('*', (('@', 'x'), ('@', 'y'), ('@', 'z'), ('@', 'w')), {1, 2, 3})), ((('@', 'z'), ('#', '4')), (('@', 'x'), ('#', '2')), (('@', 'y'), ('#', '3')), (('@', 'w'), ('#', '5')))))
		self.assertEqual (ast2py2ast (p ('x or y')), ('-func', 'Or', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('x or y or z')), ('-func', 'Or', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2py2ast (p ('x and y')), ('-func', 'And', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('x and y and z')), ('-func', 'And', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2py2ast (p ('x and y or z')), ('-func', 'Or', (('-func', 'And', (('@', 'x'), ('@', 'y'))), ('@', 'z'))))
		self.assertEqual (ast2py2ast (p ('x and {y or z}')), ('-func', 'And', (('@', 'x'), ('-func', 'Or', (('@', 'y'), ('@', 'z'))))))
		self.assertEqual (ast2py2ast (p ('not x or y')), ('-func', 'Or', (('-func', 'Not', (('@', 'x'),)), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('not {x or y}')), ('-func', 'Not', (('-func', 'Or', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2py2ast (p ('not x and y')), ('-func', 'And', (('-func', 'Not', (('@', 'x'),)), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('not {x and y}')), ('-func', 'Not', (('-func', 'And', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2py2ast (p ('x or not y')), ('-func', 'Or', (('@', 'x'), ('-func', 'Not', (('@', 'y'),)))))
		self.assertEqual (ast2py2ast (p ('x and not y')), ('-func', 'And', (('@', 'x'), ('-func', 'Not', (('@', 'y'),)))))
		self.assertEqual (ast2py2ast (p ('not x')), ('-func', 'Not', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('not not x')), ('-func', 'Not', (('-func', 'Not', (('@', 'x'),)),)))
		self.assertEqual (ast2py2ast (p ('not not not x')), ('-func', 'Not', (('-func', 'Not', (('-func', 'Not', (('@', 'x'),)),)),)))
		self.assertEqual (ast2py2ast (p ('0 or []')), ('-func', 'Or', (('#', '0'), ('[', ()))))
		self.assertEqual (ast2py2ast (p ('0 or [1]')), ('-func', 'Or', (('#', '0'), ('[', (('#', '1'),)))))
		self.assertEqual (ast2py2ast (p ('1 and []')), ('-func', 'And', (('#', '1'), ('[', ()))))
		self.assertEqual (ast2py2ast (p ('1 and [1]')), ('-func', 'And', (('#', '1'), ('[', (('#', '1'),)))))
		self.assertEqual (ast2py2ast (p ('not []')), ('-func', 'Not', (('[', ()),)))
		self.assertEqual (ast2py2ast (p ('not [1]')), ('-func', 'Not', (('[', (('#', '1'),)),)))
		self.assertEqual (ast2py2ast (p ('not None')), ('-func', 'Not', (('@', 'None'),)))
		self.assertEqual (ast2py2ast (p ('True + True')), ('+', (('@', 'True'), ('@', 'True'))))
		self.assertEqual (ast2py2ast (p ('False - True')), ('+', (('@', 'False'), ('-', ('@', 'True')))))
		self.assertEqual (ast2py2ast (p ('True * True')), ('*', (('@', 'True'), ('@', 'True')), {1}))
		self.assertEqual (ast2py2ast (p ('(2 > 1) x')), ('*', (('(', ('-func', 'Gt', (('#', '2'), ('#', '1')))), ('@', 'x')), {1}))
		self.assertEqual (ast2py2ast (p ('(2 > 1) + (1 < 2)')), ('+', (('(', ('-func', 'Gt', (('#', '2'), ('#', '1')))), ('(', ('-func', 'Lt', (('#', '1'), ('#', '2')))))))
		self.assertEqual (ast2py2ast (p ('\\[{[a, b]},]')), ('-func', 'Matrix', (('[', (('[', (('[', (('@', 'a'), ('@', 'b'))),)),)),)))
		self.assertEqual (ast2py2ast (p ('{{a:b:c}:d}')), ('-dict', ((('-func', 'slice', (('@', 'a'), ('@', 'b'), ('@', 'c'))), ('@', 'd')),)))
		self.assertEqual (ast2py2ast (p ('{a:{b:c:d}}')), ('-dict', ((('@', 'a'), ('-func', 'slice', (('@', 'b'), ('@', 'c'), ('@', 'd')))),)))
		self.assertEqual (ast2py2ast (p ('{a:b:c} = {a:b:c}')), ('-func', 'Eq', (('-func', 'slice', (('@', 'a'), ('@', 'b'), ('@', 'c'))), ('-func', 'slice', (('@', 'a'), ('@', 'b'), ('@', 'c'))))))
		self.assertEqual (ast2py2ast (p ('\\[1:2:3]')), ('-func', 'Matrix', (('[', (('-func', 'slice', (('#', '1'), ('#', '2'), ('#', '3'))),)),)))
		self.assertEqual (ast2py2ast (p ('-{not x}')), ('-', ('-func', 'Not', (('@', 'x'),))))
		self.assertEqual (ast2py2ast (p ('x < y in [y] in [[y]] != 2 > 1')), ('-func', 'And', (('-func', 'Lt', (('@', 'x'), ('@', 'y'))), ('<>', ('@', 'y'), (('in', ('[', (('@', 'y'),))),)), ('<>', ('[', (('@', 'y'),)), (('in', ('[', (('[', (('@', 'y'),)),))),)), ('-func', 'Ne', (('[', (('[', (('@', 'y'),)),)), ('#', '2'))), ('-func', 'Gt', (('#', '2'), ('#', '1'))))))
		self.assertEqual (ast2py2ast (p ('x < y < z < w')), ('-func', 'And', (('-func', 'Lt', (('@', 'x'), ('@', 'y'))), ('-func', 'Lt', (('@', 'y'), ('@', 'z'))), ('-func', 'Lt', (('@', 'z'), ('@', 'w'))))))
		self.assertEqual (ast2py2ast (p ('\\[]')), ('-func', 'Matrix', ()))
		self.assertEqual (ast2py2ast (p ('\\[[]]')), ('-func', 'Matrix', ()))
		self.assertEqual (ast2py2ast (p ('\\[[], []]')), ('-func', 'Matrix', ()))
		self.assertEqual (ast2py2ast (p ('\\{a:b}')), ('-func', 'FiniteSet', (('-func', 'slice', (('@', 'a'), ('@', 'b'))),)))
		self.assertEqual (ast2py2ast (p ('{-x} y / z')), ('/', ('(', ('*', (('-', ('@', 'x')), ('@', 'y')), {1})), ('@', 'z')))
		self.assertEqual (ast2py2ast (p ('d / dz {-1} a')), ('-diff', ('*', (('#', '-1'), ('@', 'a')), {1}), 'd', (('z', 1),)))
		self.assertEqual (ast2py2ast (p ('1 / {-2} x')), ('/', ('#', '1'), ('(', ('*', (('#', '-2'), ('@', 'x')), {1}))))
		self.assertEqual (ast2py2ast (p ('\\sum_{x=0}^b {-x} y')), ('-sum', ('*', (('-', ('@', 'x')), ('@', 'y')), {1}), ('@', 'x'), ('#', '0'), ('@', 'b')))
		self.assertEqual (ast2py2ast (p ('\\lim_{x\\to0} {-x} y')), ('-lim', ('*', (('-', ('@', 'x')), ('@', 'y')), {1}), ('@', 'x'), ('#', '0')))
		self.assertEqual (ast2py2ast (p ('\\int a / -1 dx')), ('-intg', ('/', ('@', 'a'), ('#', '-1')), ('@', 'dx')))
		self.assertEqual (ast2py2ast (p ('\\[[[x]]]')), ('-func', 'Matrix', (('[', (('[', (('[', (('@', 'x'),)),)),)),)))
		self.assertEqual (ast2py2ast (p ('\\[[[1, 2]], [[3]]]')), ('-func', 'Matrix', (('[', (('[', (('[', (('#', '1'), ('#', '2'))),)), ('[', (('[', (('#', '3'),)),)))),)))
		self.assertEqual (ast2py2ast (p ('{1/x}.limit (x, 0, "-")')), ('.', ('(', ('/', ('#', '1'), ('@', 'x'))), 'limit', (('@', 'x'), ('#', '0'), ('"', '-'))))
		self.assertEqual (ast2py2ast (p ('{x^2y**2z}.diff (x, 2, y, z)')), ('.', ('(', ('*', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('@', 'z')), {1, 2})), 'diff', (('@', 'x'), ('#', '2'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2py2ast (p ('{x y}.integrate ((x, 0, 1))')), ('.', ('(', ('*', (('@', 'x'), ('@', 'y')), {1})), 'integrate', (('(', (',', (('@', 'x'), ('#', '0'), ('#', '1')))),)))
		self.assertEqual (ast2py2ast (p ('\\sqrt (a:b)')), ('-sqrt', ('-func', 'slice', (('@', 'a'), ('@', 'b')))))
		self.assertEqual (ast2py2ast (p ('\\sqrt[3] (a:b)')), ('^', ('-func', 'slice', (('@', 'a'), ('@', 'b'))), ('(', ('/', ('#', '1'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('? ()')), ('-ufunc', '?', ()))
		self.assertEqual (ast2py2ast (p ('? (x)')), ('-ufunc', '?', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('? (x) (2)')), ('*', (('-ufunc', '?', (('@', 'x'),)), ('(', ('#', '2'))), {1}))
		self.assertEqual (ast2py2ast (p ('? (2)')), ('-ufunc', '?', (('#', '2'),)))
		self.assertEqual (ast2py2ast (p ('?f (x, y, real = True)')), ('-ufunc', '?f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2py2ast (p ('?\\alpha(x)')), ('-ufunc', '?alpha', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('?beta(y)')), ('-ufunc', '?beta', (('@', 'y'),)))
		self.assertEqual (ast2py2ast (p ("Function ('f', real = True) (x, y)")), ('-ufunc', '?f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2py2ast (p ("x'")), ('-func', 'diff', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ("x''")), ('-func', 'diff', (('-func', 'diff', (('@', 'x'),)),)))
		self.assertEqual (ast2py2ast (p ("{x + y}'")), ('-func', 'diff', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2py2ast (p ("a [b]'")), ('-func', 'diff', (('-idx', ('@', 'a'), (('@', 'b'),)),)))
		self.assertEqual (ast2py2ast (p ("a.b ()'")), ('-func', 'diff', (('.', ('@', 'a'), 'b', ()),)))
		self.assertEqual (ast2py2ast (p ("{x/y}'")), ('-func', 'diff', (('/', ('@', 'x'), ('@', 'y')),)))
		self.assertEqual (ast2py2ast (p ("1'['ac']")), ('-idx', ('-func', 'diff', (('#', '1'),)), (('"', 'ac'),)))
		self.assertEqual (ast2py2ast (p ("|x|'")), ('-func', 'diff', (('-func', 'abs', (('@', 'x'),)),)))
		self.assertEqual (ast2py2ast (p ("| 'str'|'")), ('-func', 'diff', (('-func', 'abs', (('"', 'str'),)),)))
		self.assertEqual (ast2py2ast (p ("{x**y}'")), ('-func', 'diff', (('^', ('@', 'x'), ('@', 'y')),)))
		self.assertEqual (ast2py2ast (p ("{{-1}'}")), ('-func', 'diff', (('#', '-1'),)))
		self.assertEqual (ast2py2ast (p ("{a [b]}''")), ('-func', 'diff', (('-func', 'diff', (('-idx', ('@', 'a'), (('@', 'b'),)),)),)))
		self.assertEqual (ast2py2ast (p ("1.'''")), ('-func', 'diff', (('-func', 'diff', (('-func', 'diff', (('#', '1.'),)),)),)))
		self.assertEqual (ast2py2ast (p ('x [1]')), ('-idx', ('@', 'x'), (('#', '1'),)))
		self.assertEqual (ast2py2ast (p ('1 [x]')), ('-idx', ('#', '1'), (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('[1, 2] [x]')), ('-idx', ('[', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('{1, 2} [x]')), ('-idx', ('-func', 'FiniteSet', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('{x: 2} [x]')), ('-idx', ('-dict', ((('@', 'x'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('{y: 2} [x]')), ('-idx', ('-dict', ((('@', 'y'), ('#', '2')),)), (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ("'}'")), ('"', '}'))
		self.assertEqual (ast2py2ast (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}')), ('*', (('@', 'q'), ('@', 'w'), ('@', 'e'), ('@', 'r'), ('@', 't'), ('@', 'y'), ('@', 'u'), ('@', 'i'), ('@', 'o'), ('@', 'p'), ('@', 'a'), ('@', 's'), ('@', 'd'), ('@', 'f')), {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}))
		self.assertEqual (ast2py2ast (p ('x, y = 1, 2')), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (ast2py2ast (p ('x, 2 = 1, 2')), (',', (('@', 'x'), ('-func', 'Eq', (('#', '2'), ('#', '1'))), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('(x, y) = 1, 2')), (',', (('-func', 'Eq', (('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1'))), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('1; x, y = 1, 2')), (';', (('#', '1'), ('=', (',', (('@', 'x'), ('@', 'y'))), (',', (('#', '1'), ('#', '2')))))))
		self.assertEqual (ast2py2ast (p ('1; x, 2 = 1, 2')), (';', (('#', '1'), (',', (('@', 'x'), ('-func', 'Eq', (('#', '2'), ('#', '1'))), ('#', '2'))))))
		self.assertEqual (ast2py2ast (p ('1; (x, y) = 1, 2')), (';', (('#', '1'), (',', (('-func', 'Eq', (('(', (',', (('@', 'x'), ('@', 'y')))), ('#', '1'))), ('#', '2'))))))
		self.assertEqual (ast2py2ast (p ('f()()')), ('*', (('-ufunc', '?f', ()), ('(', (',', ()))), {1}))
		self.assertEqual (ast2py2ast (p ('f()*()')), ('*', (('-ufunc', '?f', ()), ('(', (',', ()))), {1}))
		self.assertEqual (ast2py2ast (p ('f*()*()')), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1, 2}))
		self.assertEqual (ast2py2ast (p ('f*()()')), ('*', (('@', 'f'), ('(', (',', ())), ('(', (',', ()))), {1, 2}))

		self.assertEqual (ast2py2ast (p ('dy / dx')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2py2ast (p ('dy / dx z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z')), {1}))
		self.assertEqual (ast2py2ast (p ('d**2 y / dx**2')), ('-diff', ('@', 'y'), 'd', (('x', 2),)))
		self.assertEqual (ast2py2ast (p ('d**2 y / dx**2 z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 2),)), ('@', 'z')), {1}))
		self.assertEqual (ast2py2ast (p ('d**2 y / dx dy')), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2py2ast (p ('d**2 y / dx dy z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))), ('@', 'z')), {1}))
		self.assertEqual (ast2py2ast (p ('\\frac{dy}{dx}')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2py2ast (p ('\\frac{dy}{dx} z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'z')), {1}))
		self.assertEqual (ast2py2ast (p ('\\frac{d**2}{dx**2}')), ('/', ('^', ('@', 'd'), ('#', '2')), ('^', ('@', 'dx'), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('\\frac{d**2}{dx**2} z')), ('-diff', ('@', 'z'), 'd', (('x', 2),)))
		self.assertEqual (ast2py2ast (p ('\\frac{d**2}{dx dy}')), ('/', ('^', ('@', 'd'), ('#', '2')), ('(', ('*', (('@', 'dx'), ('@', 'dy')), {1}))))
		self.assertEqual (ast2py2ast (p ('\\frac{d**2}{dx dy} z')), ('-diff', ('@', 'z'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2py2ast (p ('\\frac{d**2 y}{dx dy}')), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2py2ast (p ('\\frac{d**2 y}{dx dy} z')), ('*', (('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))), ('@', 'z')), {1}))
		self.assertEqual (ast2py2ast (p ('\\int dy / dx')), ('-intg', ('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'dy')))
		self.assertEqual (ast2py2ast (p ('\\int d/dx x**2 dx')), ('-intg', ('-diff', ('^', ('@', 'x'), ('#', '2')), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (ast2py2ast (p ('\\int d/dx y(x) dx')), ('-intg', ('-diff', ('-ufunc', '?y', (('@', 'x'),)), 'd', (('x', 1),)), ('@', 'dx')))
		self.assertEqual (ast2py2ast (p ('\\int dx dx dx')), ('*', (('-intg', ('#', '1'), ('@', 'dx')), ('@', 'dx'), ('@', 'dx')), {1, 2}))
		self.assertEqual (ast2py2ast (p ('\\int dx * dx dx')), ('*', (('-intg', ('#', '1'), ('@', 'dx')), ('@', 'dx'), ('@', 'dx')), {1, 2}))
		self.assertEqual (ast2py2ast (p ('dlambda / dx : x')), ('-func', 'slice', (('-diff', ('@', 'lambda'), 'd', (('x', 1),)), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('d**2 lambda / dx**2 : x')), ('-func', 'slice', (('-diff', ('@', 'lambda'), 'd', (('x', 2),)), ('@', 'x'))))
		self.assertEqual (ast2py2ast (p ('ln1.or')), ('.', ('@', 'ln1'), 'or'))
		self.assertRaises (AttributeError, ast2py2ast, p ('ln1. or'))
		self.assertRaises (AttributeError, ast2py2ast, p ('ln1 . or'))
		self.assertEqual (ast2py2ast (p ('a.b * c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd')), {1}))
		self.assertEqual (ast2py2ast (p ('a.b c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd')), {1}))
		self.assertEqual (ast2py2ast (p ('lambda x, y, z: ln lambda x:')), (',', (('*', (('@', 'lambda'), ('@', 'x')), {1}), ('@', 'y'), ('-func', 'slice', (('@', 'z'), ('*', (('-log', ('@', 'lambda')), ('@', 'x')), {1}))))))
		self.assertEqual (ast2py2ast (p ('lambda x, y, z: ln lambda x: 1')), ('-lamb', ('-log', ('-lamb', ('#', '1'), ('x',))), ('x', 'y', 'z')))

		self.assertEqual (ast2py2ast (p ('f (x) (0)')), ('*', (('-ufunc', '?f', (('@', 'x'),)), ('(', ('#', '0'))), {1}))
		self.assertEqual (ast2py2ast (p ('f (x, y) (0, 0)')), ('*', (('-ufunc', '?f', (('@', 'x'), ('@', 'y'))), ('(', (',', (('#', '0'), ('#', '0'))))), {1}))
		self.assertEqual (ast2py2ast (p ('f (x, y, z) (0, 0, 0)')), ('*', (('-ufunc', '?f', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('(', (',', (('#', '0'), ('#', '0'), ('#', '0'))))), {1}))
		self.assertEqual (ast2py2ast (p ("f (x)' (0)")), ('-subs', ('-func', 'diff', (('-ufunc', '?f', (('@', 'x'),)),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2py2ast (p ('\\. x+y |_{x = 1}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (ast2py2ast (p ('\\. x+y |_{x = 1, y = 2}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2py2ast (p ('\\. x+y |_{x, y = 1, 2}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2py2ast (p ('\\. x+y |_{\\substack{x = 1}}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')),)))
		self.assertEqual (ast2py2ast (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}')), ('-subs', ('+', (('@', 'x'), ('@', 'y'))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')))))
		self.assertEqual (ast2py2ast (p ('\\. f(x) |_{f(x) = y}')), ('-subs', ('-ufunc', '?f', (('@', 'x'),)), ((('-ufunc', '?f', (('@', 'x'),)), ('@', 'y')),)))
		self.assertEqual (ast2py2ast (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}')), ('-subs', ('*', (('-ufunc', '?f', (('@', 'x'),)), ('-ufunc', '?f', (('@', 'y'),))), {1}), ((('-ufunc', '?f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', '?f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2py2ast (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}')), ('-subs', ('*', (('-ufunc', '?f', (('@', 'x'),)), ('-ufunc', '?f', (('@', 'y'),))), {1}), ((('-ufunc', '?f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', '?f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2py2ast (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}')), ('-subs', ('*', (('-ufunc', '?f', (('@', 'x'),)), ('-ufunc', '?f', (('@', 'y'),))), {1}), ((('-ufunc', '?f', (('@', 'x'),)), ('@', 'y')), (('-ufunc', '?f', (('@', 'y'),)), ('@', 'z')))))
		self.assertEqual (ast2py2ast (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}')), ('-subs', ('(', ('+', (('(', (',', (('#', '1'), ('#', '2')))), ('(', (',', (('#', '1'), ('#', '2'))))))), ((('(', (',', (('#', '1'), ('#', '2'), ('#', '1'), ('#', '2')))), ('(', (',', (('#', '3'), ('#', '4'))))),)))

		self.assertEqual (ast2py2ast (p ("f (x)' (0)")), ('-subs', ('-func', 'diff', (('-ufunc', '?f', (('@', 'x'),)),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2py2ast (p ('d / dx (f (x)) (0)')), ('-subs', ('-diff', ('-ufunc', '?f', (('@', 'x'),)), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2py2ast (p ('d / dx (u (x, y)) (x, y)')), ('-diff', ('-ufunc', '?u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)))
		self.assertEqual (ast2py2ast (p ('d / dx (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', '?u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2py2ast (p ('d / dx (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', '?u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2py2ast (p ('d**2 / dx dy (u (x, y)) (x, y)')), ('-diff', ('-ufunc', '?u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2py2ast (p ('d**2 / dx dy (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', '?u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2py2ast (p ('d**2 / dx dy (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', '?u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2py2ast (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})")), ('-func', 'dsolve', (('+', (('-func', 'diff', (('-func', 'diff', (('-ufunc', '?y', (('@', 'x'),)),)),)), ('*', (('#', '11'), ('-func', 'diff', (('-ufunc', '?y', (('@', 'x'),)),))), {1}), ('*', (('#', '24'), ('-ufunc', '?y', (('@', 'x'),))), {1}))), ('=', ('@', 'ics'), ('-dict', ((('-ufunc', '?y', (('#', '0'),)), ('#', '0')), (('-subs', ('-func', 'diff', (('-ufunc', '?y', (('@', 'x'),)),)), ((('@', 'x'), ('#', '0')),)), ('#', '-7'))))))))
		self.assertEqual (ast2py2ast (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}")), ('-subs', ('[', (('-func', 'diff', (('-ufunc', '?f', (('@', 'x'),)),)), ('-func', 'diff', (('-ufunc', '?g', (('@', 'y'),)),)))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (ast2py2ast (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')), ('-subs', ('[', (('-diff', ('-ufunc', '?f', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ('-diff', ('-ufunc', '?g', (('@', 'y'), ('@', 'x'))), 'd', (('x', 1),)))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))
		self.assertEqual (ast2py2ast (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')), ('-subs', ('-diff', ('-ufunc', '?f', (('@', 'x'), ('@', 'z'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '1')), (('@', 'y'), ('#', '2')), (('@', 'z'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('?() = 2')), ('-func', 'Eq', (('-ufunc', '?', ()), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('?f() = 2')), ('-func', 'Eq', (('-ufunc', '?f', ()), ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('d / dx (a) b')), ('*', (('-diff', ('@', 'a'), 'd', (('x', 1),)), ('@', 'b')), {1}))
		self.assertEqual (ast2py2ast (p ('\\frac{d}{dx} (a) b')), ('*', (('-diff', ('@', 'a'), 'd', (('x', 1),)), ('@', 'b')), {1}))
		self.assertEqual (ast2py2ast (p ('sin (())')), ('-func', 'sin', (('(', (',', ())),)))
		self.assertEqual (ast2py2ast (p ('sin (((a))')), ('-func', 'sin', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (ast2py2ast (p ('a.b (())')), ('.', ('@', 'a'), 'b', (('(', (',', ())),)))
		self.assertEqual (ast2py2ast (p ('a.b (((a))')), ('.', ('@', 'a'), 'b', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (ast2py2ast (p ('@x')), ('@', 'x'))
		self.assertEqual (ast2py2ast (p ('@(x + y)')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('@(x + y)')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('%x')), ('@', 'x'))
		self.assertEqual (ast2py2ast (p ('%(x + y)')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('%%x')), ('@', 'x'))
		self.assertEqual (ast2py2ast (p ('%%(x + y)')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2py2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]')), ('-idx', ('-func', 'Matrix', (('[', (('[', (('#', '1'), ('#', '2'), ('#', '3'))), ('[', (('#', '4'), ('#', '5'), ('#', '6'))))),)), (('-slice', False, False, None), ('-slice', ('#', '1'), False, None))))

		self.assertEqual (ast2py2ast (p ('N - N N 2')), ('+', (('@', 'N'), ('-', ('-func', 'N', (('-func', 'N', (('#', '2'),)),))))))
		self.assertEqual (ast2py2ast (p ('N N N 2')), ('-func', 'N', (('-func', 'N', (('-func', 'N', (('#', '2'),)),)),)))
		self.assertEqual (ast2py2ast (p ('sin sin sin 2')), ('-func', 'sin', (('-func', 'sin', (('-func', 'sin', (('#', '2'),)),)),)))
		self.assertEqual (ast2py2ast (p ('-N sin -N 2')), ('-', ('-func', 'N', (('-func', 'sin', (('-', ('-func', 'N', (('#', '2'),))),)),))))
		self.assertEqual (ast2py2ast (p ('sin -N sin 2')), ('-func', 'sin', (('-', ('-func', 'N', (('-func', 'sin', (('#', '2'),)),))),)))
		self.assertEqual (ast2py2ast (p ('N N sin -a [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2py2ast (p ('N N sin -a.b [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2py2ast (p ('N N sin -a.b () [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2py2ast (p ('N N sin -a.b () [2] [3]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),)), (('#', '3'),))),)),)),)))
		self.assertEqual (ast2py2ast (p ('sin -N () [2] [3].c [4].d () [5]')), ('-func', 'sin', (('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),))),)))
		self.assertEqual (ast2py2ast (p ('sqrt -N () [2] [3].c [4].d () [5]')), ('-sqrt', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (ast2py2ast (p ('sqrt[3] -N () [2] [3].c [4].d () [5]')), ('^', ('(', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))), ('(', ('/', ('#', '1'), ('#', '3')))))
		self.assertEqual (ast2py2ast (p ('log -N () [2] [3].c [4].d () [5]')), ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))))
		self.assertEqual (ast2py2ast (p ('\\log_2 -N () [2] [3].c [4].d () [5]')), ('/', ('-log', ('-', ('-idx', ('.', ('-idx', ('.', ('-idx', ('-idx', ('-func', 'N', ()), (('#', '2'),)), (('#', '3'),)), 'c'), (('#', '4'),)), 'd', ()), (('#', '5'),)))), ('-log', ('#', '2'))))
		self.assertEqual (ast2py2ast (p ('N sin**2 ln**2 N x')), ('-func', 'N', (('^', ('-func', 'sin', (('^', ('-log', ('-func', 'N', (('@', 'x'),))), ('#', '2')),)), ('#', '2')),)))
		self.assertEqual (ast2py2ast (p ('sin ln N x')), ('-func', 'sin', (('-log', ('-func', 'N', (('@', 'x'),))),)))
		self.assertEqual (ast2py2ast (p ('sin(a)**[a][b].c')), ('^', ('-func', 'sin', (('@', 'a'),)), ('.', ('-idx', ('[', (('@', 'a'),)), (('@', 'b'),)), 'c')))
		self.assertEqual (ast2py2ast (p ('N sin N sin x')), ('-func', 'N', (('-func', 'sin', (('-func', 'N', (('-func', 'sin', (('@', 'x'),)),)),)),)))
		self.assertEqual (ast2py2ast (p ('cos**-1 0 \\log_2 8')), ('*', (('-func', 'acos', (('#', '0'),)), ('(', ('/', ('-log', ('#', '8')), ('-log', ('#', '2'))))), {1}))
		self.assertEqual (ast2py2ast (p ('N sin sqrt[3] \\log_2 8')), ('-func', 'N', (('-func', 'sin', (('^', ('(', ('/', ('-log', ('#', '8')), ('-log', ('#', '2')))), ('(', ('/', ('#', '1'), ('#', '3')))),)),)))
		self.assertEqual (ast2py2ast (p ('sin(x)**-a[b][c].d')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2py2ast (p ('sin sin x [2].w')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),)))
		self.assertEqual (ast2py2ast (p ('sin -sin x [2].w')), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (ast2py2ast (p ('sin sin (x) [2].w')), ('-func', 'sin', (('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w'),)))
		self.assertEqual (ast2py2ast (p ('sin -sin (x) [2].w')), ('-func', 'sin', (('-', ('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w')),)))
		self.assertEqual (ast2py2ast (p ('sin sin x [2].w ()')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w', ()),)),)))
		self.assertEqual (ast2py2ast (p ('ln ln x [2].w')), ('-log', ('-log', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'))))
		self.assertEqual (ast2py2ast (p ('N N sin -a [2]')), ('-func', 'N', (('-func', 'N', (('-func', 'sin', (('-', ('-idx', ('@', 'a'), (('#', '2'),))),)),)),)))
		self.assertEqual (ast2py2ast (p ('sin sin -x [2].w')), ('-func', 'sin', (('-func', 'sin', (('-', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w')),)),)))
		self.assertEqual (ast2py2ast (p ('sin -sin x [2].w')), ('-func', 'sin', (('-', ('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),))),)))
		self.assertEqual (ast2py2ast (p ('sin(a)**b[2]')), ('^', ('-func', 'sin', (('@', 'a'),)), ('-idx', ('@', 'b'), (('#', '2'),))))
		self.assertEqual (ast2py2ast (p ('sin**-a[b][c].d x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2py2ast (p ('sin**-a[b][c].d (x)')), ('^', ('@', 'sin'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2py2ast (p ('sin**-a[b][c].d {(x)}')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2py2ast (p ('sin**-a[b][c] (x)')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (ast2py2ast (p ('\\int**-a[b][c] x')), None)
		self.assertEqual (ast2py2ast (p ('\\int**-a[b][c].d (x)')), None)
		self.assertEqual (ast2py2ast (p ('\\int**-a[b][c].d {(x)}')), None)
		self.assertEqual (ast2py2ast (p ('\\int**-a[b][c].d (x) y')), None)
		self.assertEqual (ast2py2ast (p ('\\int**-a[b][c].d {(x)} y')), None)
		self.assertEqual (ast2py2ast (p ('\\int**a.b[2] x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))))

		self.assertEqual (ast2py2ast (p ('d/dx (real = True)')), ('-diff', ('-func', 'Eq', (('@', 'real'), ('@', 'True'))), 'd', (('x', 1),)))
		self.assertEqual (ast2py2ast (p ('f {\\left(x\\right)}')), ('-ufunc', '?f', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('a.b {(x)}')), ('*', (('.', ('@', 'a'), 'b'), ('(', ('@', 'x'))), {1}))
		self.assertEqual (ast2py2ast (p ('a.b {\\left(x\\right)}')), ('.', ('@', 'a'), 'b', (('@', 'x'),)))
		self.assertEqual (ast2py2ast (p ('\\log_{|x|} y')), ('/', ('-log', ('@', 'y')), ('-log', ('-func', 'abs', (('@', 'x'),)))))
		self.assertEqual (ast2py2ast (p ('|\\int a + b dx|')), ('-func', 'abs', (('-intg', ('+', (('@', 'a'), ('@', 'b'))), ('@', 'dx')),)))
		self.assertEqual (ast2py2ast (p ('\\int deg N dx')), ('-intg', ('-func', 'deg', (('@', 'N'),)), ('@', 'dx')))
		self.assertEqual (ast2py2ast (p ('a \\int x dx / c')), ('/', ('(', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx'))), {1})), ('@', 'c')))
		self.assertEqual (ast2py2ast (p ('\\int x dx b / c')), ('/', ('(', ('*', (('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b')), {1})), ('@', 'c')))
		self.assertEqual (ast2py2ast (p ('a \\int x dx b / c')), ('/', ('(', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'b')), {1, 2})), ('@', 'c')))
		self.assertEqual (ast2py2ast (p ('a {\\lim_{x\\to0} \\int x dx} / b')), ('/', ('(', ('*', (('@', 'a'), ('-lim', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0'))), {1})), ('@', 'b')))
		self.assertEqual (ast2py2ast (p ('a {\\sum_{x=0}^1 \\int x dx} / b')), ('/', ('(', ('*', (('@', 'a'), ('-sum', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0'), ('#', '1'))), {1})), ('@', 'b')))
		self.assertEqual (ast2py2ast (p ('a / \\int x dx * c')), ('*', (('/', ('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx'))), ('@', 'c')), {1}))
		self.assertEqual (ast2py2ast (p ('a / b \\int x dx * c')), ('*', (('/', ('@', 'a'), ('(', ('*', (('@', 'b'), ('-intg', ('@', 'x'), ('@', 'dx'))), {1}))), ('@', 'c')), {1}))

		self.assertEqual (ast2py2ast (p ('cos')), ('@', 'cos'))
		self.assertEqual (ast2py2ast (p ('f = cos')), ('=', ('@', 'f'), ('@', 'cos')))
		self.assertEqual (ast2py2ast (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)')), ('.', ('-func', 'Matrix', (('[', (('[', (('#', '0'), ('@', 'pi'))), ('[', (('-', ('@', 'pi')), ('#', '0'))))),)), 'applyfunc', (('@', 'cos'),)))
		self.assertEqual (ast2py2ast (p ('$sin (real = True)')), ('-sym', 'sin', (('real', ('@', 'True')),)))
		self.assertEqual (ast2py2ast (p ('sin = $(real = True)')), ('=', ('@', 'sin'), ('-sym', '', (('real', ('@', 'True')),))))

	def test_ast2spt2ast (self):
		self.assertEqual (ast2spt2ast (p ('1')), ('#', '1'))
		self.assertEqual (ast2spt2ast (p ('1.')), ('#', '1'))
		self.assertEqual (ast2spt2ast (p ('.1')), ('#', '0.1'))
		self.assertEqual (ast2spt2ast (p ('1e20')), ('#', '1e+20'))
		self.assertEqual (ast2spt2ast (p ('1E-20')), ('#', '1e-20'))
		self.assertEqual (ast2spt2ast (p ('1.e+20')), ('#', '1e+20'))
		self.assertEqual (ast2spt2ast (p ('.1e-20')), ('#', '1e-21'))
		self.assertEqual (ast2spt2ast (p ('sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)')), ('#', '-0.944005725045266578111580178964150229172986049810954315912648896418833061306836817'))
		self.assertEqual (ast2spt2ast (p ('x')), ('@', 'x'))
		self.assertEqual (ast2spt2ast (p ('xy')), ('@', 'xy'))
		self.assertEqual (ast2spt2ast (p ('dx')), ('@', 'dx'))
		self.assertEqual (ast2spt2ast (p ('partialx')), ('@', 'partialx'))
		self.assertEqual (ast2spt2ast (p ('\\partial x')), ('@', 'partialx'))
		self.assertEqual (ast2spt2ast (p ('x d  y')), ('*', (('@', 'd'), ('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x partial y')), ('*', (('@', 'partial'), ('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x \\partial  y')), ('*', (('@', 'partial'), ('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x dx dy y')), ('*', (('@', 'dx'), ('@', 'dy'), ('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x partialx partialy y')), ('*', (('@', 'partialx'), ('@', 'partialy'), ('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('-1')), ('#', '-1'))
		self.assertEqual (ast2spt2ast (p ('-x')), ('-', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('{x}')), ('@', 'x'))
		self.assertEqual (ast2spt2ast (p ('()')), ('(', (',', ())))
		self.assertEqual (ast2spt2ast (p ('(x)')), ('@', 'x'))
		self.assertEqual (ast2spt2ast (p ('(x,)')), ('(', (',', (('@', 'x'),))))
		self.assertEqual (ast2spt2ast (p ('(x,y)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2spt2ast (p ('(x,y,)')), ('(', (',', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2spt2ast (p ('[]')), ('[', ()))
		self.assertEqual (ast2spt2ast (p ('[x]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('[x,]')), ('[', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('[x,y]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('[x,y,]')), ('[', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('"x\\x20\\n"')), ('"', 'x \n'))
		self.assertEqual (ast2spt2ast (p ("'x\\x20\\n'")), ('"', 'x \n'))
		self.assertEqual (ast2spt2ast (p ('|x|')), ('|', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('x!')), ('!', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('x+y')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x-y')), ('+', (('@', 'x'), ('-', ('@', 'y')))))
		self.assertEqual (ast2spt2ast (p ('x*y')), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x y')), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x(y)')), ('-ufunc', 'x', (('@', 'y'),)))
		self.assertEqual (ast2spt2ast (p ('x*(y)')), ('*', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x/y')), ('/', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2spt2ast (p ('x^y')), ('^', ('@', 'x'), ('@', 'y')))
		self.assertEqual (ast2spt2ast (p ('log x')), ('-log', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('log {x}')), ('-log', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('log (x)')), ('-log', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('\\log_2 x')), ('/', ('-log', ('@', 'x')), ('-log', ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('\\log_2 {x}')), ('/', ('-log', ('@', 'x')), ('-log', ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('\\log_2 (x)')), ('/', ('-log', ('@', 'x')), ('-log', ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('sqrt x')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('sqrt {x}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('sqrt (x)')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('sqrt {(x)}')), ('-sqrt', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('sqrt[3] x')), ('^', ('@', 'x'), ('/', ('#', '1'), ('#', '3'))))
		self.assertEqual (ast2spt2ast (p ('sqrt[3] {x}')), ('^', ('@', 'x'), ('/', ('#', '1'), ('#', '3'))))
		self.assertEqual (ast2spt2ast (p ('sqrt[3] {(x)}')), ('^', ('@', 'x'), ('/', ('#', '1'), ('#', '3'))))
		self.assertEqual (ast2spt2ast (p ('sqrt[3] (x)')), ('^', ('@', 'x'), ('/', ('#', '1'), ('#', '3'))))
		self.assertEqual (ast2spt2ast (p ('sin x')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('sin^2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('sin (x)')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('sin (x)^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('sin {x}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('sin {(x)}')), ('-func', 'sin', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('{sin x}^2')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('sin**2 x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('sin**-1 x')), ('-func', 'asin', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('sin(x)**-1')), ('/', ('#', '1'), ('-func', 'sin', (('@', 'x'),))))
		self.assertEqual (ast2spt2ast (p ('acos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('\\arccos (x)')), ('-func', 'acos', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('sin(x**2)')), ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2spt2ast (p ('sin(x**2)**2')), ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('(sin(x**2)**2)')), ('^', ('-func', 'sin', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('ln(x**2)')), ('-log', ('^', ('@', 'x'), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('ln(x**2)**2')), ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('(ln(x**2)**2)')), ('^', ('-log', ('^', ('@', 'x'), ('#', '2'))), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('gamma(x**2)')), ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)))
		self.assertEqual (ast2spt2ast (p ('gamma(x**2)**2')), ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('(gamma(x**2)**2)')), ('^', ('-func', 'gamma', (('^', ('@', 'x'), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('{gamma}[2]')), ('-idx', ('@', 'gamma'), (('#', '2'),)))
		self.assertEqual (ast2spt2ast (p ('{Gamma}[2]')), ('-idx', ('@', 'Gamma'), (('#', '2'),)))
		self.assertEqual (ast2spt2ast (p ('f{(x)}')), ('*', (('@', 'f'), ('@', 'x'))))
		self.assertEqual (ast2spt2ast (p ("f{(x)}'(0)")), ('#', '0'))
		self.assertEqual (ast2spt2ast (p ("f{(x)}'{(0)}")), ('#', '0'))
		self.assertEqual (ast2spt2ast (p ('\\operatorname{x_{1}}{\\left(x \\right)}')), ('-ufunc', 'x1', (('@', 'x'),)))
		self.assertRaises (ValueError, ast2spt2ast, p ('\\lim_{x\\to0} 1/x'))
		self.assertEqual (ast2spt2ast (p ('\\lim_{x\\to0^+} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2spt2ast (p ('\\lim_{x\\to0**-} 1/x')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertEqual (ast2spt2ast (p ('Limit (1/x, x, 0)')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '+'))
		self.assertEqual (ast2spt2ast (p ('Limit (1/x, x, 0, "-")')), ('-lim', ('/', ('#', '1'), ('@', 'x')), ('@', 'x'), ('#', '0'), '-'))
		self.assertRaises (ValueError, ast2spt2ast, p ('Limit (1/x, x, 0, dir="+-")'))
		self.assertEqual (ast2spt2ast (p ('limit (1/x, x, 0)')), ('@', 'oo'))
		self.assertEqual (ast2spt2ast (p ('limit (1/x, x, 0, "-")')), ('-', ('@', 'oo')))
		self.assertRaises (ValueError, ast2spt2ast, p ('limit (1/x, x, 0, dir="+-")'))
		self.assertEqual (ast2spt2ast (p ('\\sum_{n=0}^\\infty x^n/n!')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2spt2ast (p ('Sum (x^n/n!, (n, 0, oo))')), ('-sum', ('/', ('^', ('@', 'x'), ('@', 'n')), ('!', ('@', 'n'))), ('@', 'n'), ('#', '0'), ('@', 'oo')))
		self.assertEqual (ast2spt2ast (p ('summation (x^n/n!, (n, 0, oo))')), ('^', ('@', 'e'), ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('d/dx x**2y**2z')), ('-diff', ('*', (('@', 'z'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')))), 'd', (('x', 1),)))
		self.assertEqual (ast2spt2ast (p ('d^2/dx^2 x^2y**2z')), ('-diff', ('*', (('@', 'z'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')))), 'd', (('x', 2),)))
		self.assertEqual (ast2spt2ast (p ('d^3/dx^2dy x^2y**2z')), ('-diff', ('*', (('@', 'z'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')))), 'd', (('x', 2), ('y', 1))))
		self.assertEqual (ast2spt2ast (p ('\\partial^4 / \\partial x^2\\partial y\\partial z x^2 y**2 z')), ('-diff', ('*', (('@', 'z'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')))), 'd', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2spt2ast (p ('d**1.5 / dx dy x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '1.5')), ('*', (('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2spt2ast (p ('d**-2 / dx dy x**2y**2')), ('/', ('#', '1'), ('*', (('^', ('@', 'd'), ('#', '2')), ('@', 'dx'), ('@', 'dy'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2spt2ast (p ('d**2 / dx**1.5 x**2y**2')), ('/', ('^', ('@', 'd'), ('#', '2')), ('*', (('^', ('@', 'dx'), ('#', '1.5')), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2'))))))
		self.assertEqual (ast2spt2ast (p ('Derivative (x^2y**2z, x, 2, y, z)')), ('-diff', ('*', (('@', 'z'), ('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')))), 'd', (('x', 2), ('y', 1), ('z', 1))))
		self.assertEqual (ast2spt2ast (p ('diff (x^2y**2z, x, 2, y, z)')), ('*', (('#', '4'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('\\int dx')), ('-intg', ('#', '1'), ('@', 'dx')))
		self.assertEqual (ast2spt2ast (p ('\\int x dx')), ('-intg', ('@', 'x'), ('@', 'dx')))
		self.assertEqual (ast2spt2ast (p ('\\int_0^1 x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('#', '1')))
		self.assertEqual (ast2spt2ast (p ('\\int_0^1 \\int y dy dx')), ('-intg', ('@', 'y'), ('@', 'dy')))
		self.assertEqual (ast2spt2ast (p ('Integral (\\int y dy, (x, 0, 1))')), ('-intg', ('@', 'y'), ('@', 'dy')))
		self.assertEqual (ast2spt2ast (p ('integrate (\\int y dy, (x, 0, 1))')), ('/', ('^', ('@', 'y'), ('#', '2')), ('#', '2')))

		self.assertEqual (ast2spt2ast (p ('\\[1,]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2spt2ast (p ('\\[1,2]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2spt2ast (p ('\\[1,2,]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,],]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2spt2ast (p ('\\[[1,],[2,]]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,],[2,],]')), ('-mat', ((('#', '1'),), (('#', '2'),))))
		self.assertEqual (ast2spt2ast (p ('\\left[\\begin{matrix} 1 \\end{matrix}\\right]')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2spt2ast (p ('\\begin{bmatrix} 1 \\\\ \\end{bmatrix}')), ('-mat', ((('#', '1'),),)))
		self.assertEqual (ast2spt2ast (p ('\\begin{vmatrix} 1 & 2 \\\\ \\end{vmatrix}')), ('-mat', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2spt2ast (p ('\\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2spt2ast (p ('\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\\\ \\end{matrix}')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2spt2ast (p ('\\[1,2]!')), ('!', ('-mat', ((('#', '1'),), (('#', '2'),)))))
		self.assertEqual (ast2spt2ast (p ('\\[[0,1],[1,0]]**x')), ('-mat', ((('+', (('/', ('^', ('#', '-1'), ('@', 'x')), ('#', '2')), ('/', ('#', '1'), ('#', '2')))), ('+', (('/', ('#', '1'), ('#', '2')), ('-', ('/', ('^', ('#', '-1'), ('@', 'x')), ('#', '2')))))), (('+', (('/', ('#', '1'), ('#', '2')), ('-', ('/', ('^', ('#', '-1'), ('@', 'x')), ('#', '2'))))), ('+', (('/', ('^', ('#', '-1'), ('@', 'x')), ('#', '2')), ('/', ('#', '1'), ('#', '2'))))))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2],[3,4]]!')), ('!', ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4'))))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2,3],[4,5,6]].T')), ('-mat', ((('#', '1'), ('#', '4')), (('#', '2'), ('#', '5')), (('#', '3'), ('#', '6')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2,3],[4,5,6]].T.T')), ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2,3],[4,5,6]].T.T.T')), ('-mat', ((('#', '1'), ('#', '4')), (('#', '2'), ('#', '5')), (('#', '3'), ('#', '6')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2,3],[4,5,6]].transpose ()')), ('-mat', ((('#', '1'), ('#', '4')), (('#', '2'), ('#', '5')), (('#', '3'), ('#', '6')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ()')), ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()')), ('-mat', ((('#', '1'), ('#', '4')), (('#', '2'), ('#', '5')), (('#', '3'), ('#', '6')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()')), ('-mat', ((('#', '1'), ('#', '2'), ('#', '3')), (('#', '4'), ('#', '5'), ('#', '6')))))
		self.assertEqual (ast2spt2ast (p ('\\begin{matrix} A & B \\\\ C & D \\end{matrix} * \\[x, y]')), ('-mat', ((('+', (('*', (('@', 'A'), ('@', 'x'))), ('*', (('@', 'B'), ('@', 'y'))))),), (('+', (('*', (('@', 'C'), ('@', 'x'))), ('*', (('@', 'D'), ('@', 'y'))))),))))
		self.assertEqual (ast2spt2ast (p ('\\[[1, 2], [3')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('-sym', '')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1, 2], [3]]')), ('-mat', ((('#', '1'), ('#', '2')), (('#', '3'), ('-sym', '')))))
		self.assertEqual (ast2spt2ast (p ('\\[[1], [2, 3]]')), ('-mat', ((('#', '1'), ('-sym', '')), (('#', '2'), ('#', '3')))))

		self.assertEqual (ast2spt2ast (p ('-1**x')), ('#', '-1'))
		self.assertEqual (ast2spt2ast (p ('{-1}**x')), ('^', ('#', '-1'), ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('-{-1}**x')), ('-', ('^', ('#', '-1'), ('@', 'x'))))
		self.assertEqual (ast2spt2ast (p ('(-1)**x')), ('^', ('#', '-1'), ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('-(-1)**x')), ('-', ('^', ('#', '-1'), ('@', 'x'))))
		self.assertEqual (ast2spt2ast (p ('alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega')), ('(', (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega')))))
		self.assertEqual (ast2spt2ast (p ('\\alpha, \\beta, \\gamma, \\delta, \\epsilon, \\zeta, \\eta, \\theta, \\iota, \\kappa, \\lambda, \\mu, \\nu, \\xi, \\pi, \\rho, \\sigma, \\tau, \\upsilon, \\phi, \\chi, \\psi, \\omega, \\Gamma, \\Delta, \\Theta, \\Lambda, \\Xi, \\Pi, \\Sigma, \\Upsilon, \\Phi, \\Psi, \\Omega')), ('(', (',', (('@', 'alpha'), ('@', 'beta'), ('@', 'gamma'), ('@', 'delta'), ('@', 'epsilon'), ('@', 'zeta'), ('@', 'eta'), ('@', 'theta'), ('@', 'iota'), ('@', 'kappa'), ('@', 'lambda'), ('@', 'mu'), ('@', 'nu'), ('@', 'xi'), ('@', 'pi'), ('@', 'rho'), ('@', 'sigma'), ('@', 'tau'), ('@', 'upsilon'), ('@', 'phi'), ('@', 'chi'), ('@', 'psi'), ('@', 'omega'), ('@', 'Gamma'), ('@', 'Delta'), ('@', 'Theta'), ('@', 'Lambda'), ('@', 'Xi'), ('@', 'Pi'), ('@', 'Sigma'), ('@', 'Upsilon'), ('@', 'Phi'), ('@', 'Psi'), ('@', 'Omega')))))
		self.assertEqual (ast2spt2ast (p ('1 if x < y')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))),)))
		self.assertEqual (ast2spt2ast (p ('1 if x < y else 3')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), True))))
		self.assertEqual (ast2spt2ast (p ('1 if x < y else 3 if x < z')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))))))
		self.assertEqual (ast2spt2ast (p ('1 if x < y else 3 if x < z else 5')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2spt2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2spt2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & \\\\ \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), True))))
		self.assertEqual (ast2spt2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'w'), (('>', ('@', 'x')),))))))
		self.assertEqual (ast2spt2ast (p ('\\begin{cases} 1 & x < y \\\\ 3 & x < z \\\\ 5 & x < w \\\\ \\end{cases}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('@', 'y')),))), (('#', '3'), ('<>', ('@', 'x'), (('<', ('@', 'z')),))), (('#', '5'), ('<>', ('@', 'w'), (('>', ('@', 'x')),))))))
		self.assertEqual (ast2spt2ast (p ('x**y.a')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a')))
		self.assertEqual (ast2spt2ast (p ('x**y.a ()')), ('^', ('@', 'x'), ('.', ('@', 'y'), 'a', ())))
		self.assertEqual (ast2spt2ast (p ('x**y.a.b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b')))
		self.assertEqual (ast2spt2ast (p ('x**y.a.b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a'), 'b', ())))
		self.assertEqual (ast2spt2ast (p ('x**y.a ().b')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b')))
		self.assertEqual (ast2spt2ast (p ('x**y.a ().b ()')), ('^', ('@', 'x'), ('.', ('.', ('@', 'y'), 'a', ()), 'b', ())))
		self.assertEqual (ast2spt2ast (p ('{1 if x < 0 else 3} if x < 1 else 5')), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '3'), True))), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))))
		self.assertEqual (ast2spt2ast (p ('1 if {True if x < 0 else False} else 5')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '5'), True))))
		self.assertEqual (ast2spt2ast (p ('1 if {True if x < 0 else False} else {7 if x < 1 else 5}')), ('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('#', '5'), True))), True))))
		self.assertEqual (ast2spt2ast (p ('{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}')), ('-piece', ((('-piece', ((('#', '1'), ('<>', ('@', 'x'), (('<', ('#', '0')),))), (('#', '9'), True))), ('<>', ('@', 'x'), (('<', ('#', '1')),))), (('-piece', ((('#', '7'), ('<>', ('@', 'x'), (('<', ('#', '2')),))), (('#', '5'), True))), True))))
		self.assertEqual (ast2spt2ast (p ('x.y!')), ('!', ('.', ('@', 'x'), 'y')))
		self.assertEqual (ast2spt2ast (p ('x.y**2')), ('^', ('.', ('@', 'x'), 'y'), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('x.y ()!')), ('!', ('.', ('@', 'x'), 'y', ())))
		self.assertEqual (ast2spt2ast (p ('x.y ()**2')), ('^', ('.', ('@', 'x'), 'y', ()), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('x**y.a!')), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a'))))
		self.assertEqual (ast2spt2ast (p ('x**y.a**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a'), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('x**y.a ()!')), ('^', ('@', 'x'), ('!', ('.', ('@', 'y'), 'a', ()))))
		self.assertEqual (ast2spt2ast (p ('x**y.a ()**2')), ('^', ('@', 'x'), ('^', ('.', ('@', 'y'), 'a', ()), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('lambda: x')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2spt2ast (p ('lambda x: x**2')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2spt2ast (p ('lambda x, y: x + y')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2spt2ast (p ('lambda x, y, z: x + y + z')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z')))
		self.assertEqual (ast2spt2ast (p ('1, lambda: x')), ('(', (',', (('#', '1'), ('-lamb', ('@', 'x'), ())))))
		self.assertEqual (ast2spt2ast (p ('1, lambda x: x**2')), ('(', (',', (('#', '1'), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',))))))
		self.assertEqual (ast2spt2ast (p ('1, lambda x, y: x + y')), ('(', (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y'))))))
		self.assertEqual (ast2spt2ast (p ('1, lambda x, y, z: x + y + z')), ('(', (',', (('#', '1'), ('-lamb', ('+', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('x', 'y', 'z'))))))
		self.assertEqual (ast2spt2ast (p ('f = lambda: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ())))
		self.assertEqual (ast2spt2ast (p ('f = lambda x: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x',))))
		self.assertEqual (ast2spt2ast (p ('f = lambda x, y: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y'))))
		self.assertEqual (ast2spt2ast (p ('f = lambda x, y, z: 0')), ('=', ('@', 'f'), ('-lamb', ('#', '0'), ('x', 'y', 'z'))))
		self.assertEqual (ast2spt2ast (p ('\\left(\\left(\\right) \\mapsto x \\right)')), ('-lamb', ('@', 'x'), ()))
		self.assertEqual (ast2spt2ast (p ('\\left(\\left(x \\right) \\mapsto x^2 \\right)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2spt2ast (p ('\\left(\\left(x, y \\right) \\mapsto x + y \\right)')), ('-lamb', ('+', (('@', 'x'), ('@', 'y'))), ('x', 'y')))
		self.assertEqual (ast2spt2ast (p ('\\lambda: x')), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (ast2spt2ast (p ('\\lambda x: x')), ('-slice', ('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'x'), None))
		self.assertEqual (ast2spt2ast (p ('\\lambda x, y: x')), ('(', (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('-slice', ('@', 'y'), ('@', 'x'), None)))))
		self.assertEqual (ast2spt2ast (p ('{lambda}: x')), ('-slice', ('@', 'lambda'), ('@', 'x'), None))
		self.assertEqual (ast2spt2ast (p ('{lambda} x: x')), ('-slice', ('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'x'), None))
		self.assertEqual (ast2spt2ast (p ('{lambda} x, y: x')), ('(', (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('-slice', ('@', 'y'), ('@', 'x'), None)))))
		self.assertEqual (ast2spt2ast (p ('$')), ('-sym', ''))
		self.assertEqual (ast2spt2ast (p ('$s')), ('@', 's'))
		self.assertEqual (ast2spt2ast (p ('$ (real = True)')), ('-sym', '', (('real', ('@', 'True')),)))
		self.assertEqual (ast2spt2ast (p ('$s (real = True)')), ('-sym', 's', (('real', ('@', 'True')),)))

		self.assertEqual (ast2spt2ast (p ('eye (2).is_diagonal ()')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('a [2]')), ('-idx', ('@', 'a'), (('#', '2'),)))
		self.assertEqual (ast2spt2ast (p ('a [2,3]')), ('-idx', ('@', 'a'), (('#', '2'), ('#', '3'))))
		self.assertRaises (TypeError, ast2spt2ast, p ('a * [2]'))
		self.assertRaises (TypeError, ast2spt2ast, p ('a * {-1}[x]'))
		self.assertEqual (ast2spt2ast (p ('a * [x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),)))))
		self.assertEqual (ast2spt2ast (p ('N (1/2)')), ('#', '0.5'))
		self.assertEqual (ast2spt2ast (p ("S ('1/2')")), ('/', ('#', '1'), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ("N (S ('1/2'))")), ('#', '0.5'))
		self.assertEqual (ast2spt2ast (p ('S.Half')), ('/', ('#', '1'), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('N S.Half')), ('#', '0.5'))
		self.assertEqual (ast2spt2ast (p ('o [i].t')), ('.', ('-idx', ('@', 'o'), (('@', 'i'),)), 't'))
		self.assertEqual (ast2spt2ast (p ('o [i]**2')), ('^', ('-idx', ('@', 'o'), (('@', 'i'),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('o [i]!')), ('!', ('-idx', ('@', 'o'), (('@', 'i'),))))
		self.assertEqual (ast2spt2ast (p ("'Hello' [::-1]")), ('"', 'olleH'))
		self.assertEqual (ast2spt2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:,1]')), ('-mat', ((('#', '2'),), (('#', '5'),))))
		self.assertEqual (ast2spt2ast (p ('\\binom96')), ('#', '84'))
		self.assertEqual (ast2spt2ast (p ('binomial (x, y)')), ('-func', 'binomial', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('y - 1*x')), ('+', (('@', 'y'), ('-', ('@', 'x')))))
		self.assertEqual (ast2spt2ast (p ("Poly(x**2 + 2 x + 1, x, domain = 'ZZ')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'))), ('#', '1'))), ('=', ('@', 'domain'), ('"', 'ZZ')))))
		self.assertEqual (ast2spt2ast (p ("Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')")), ('-func', 'Poly', (('+', (('^', ('@', 'x'), ('#', '2')), ('^', ('@', 'y'), ('#', '2')), ('*', (('#', '2'), ('@', 'x'), ('@', 'y'))))), ('=', ('@', 'domain'), ('"', 'CC')))))
		self.assertEqual (ast2spt2ast (p ('oct(10)')), ('"', '0o12'))
		self.assertEqual (ast2spt2ast (p ('(1,) + (2,)')), ('(', (',', (('#', '1'), ('#', '2')))))
		self.assertEqual (ast2spt2ast (p ('[1] + [2]')), ('[', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ("'a' + 'b'")), ('"', 'ab'))
		self.assertEqual (ast2spt2ast (p ('(1,) * 2')), ('(', (',', (('#', '1'), ('#', '1')))))
		self.assertEqual (ast2spt2ast (p ('[1] * 2')), ('[', (('#', '1'), ('#', '1'))))
		self.assertEqual (ast2spt2ast (p ("'a' * 2")), ('"', 'aa'))
		self.assertEqual (ast2spt2ast (p ('Lambda (x, x**2)')), ('-lamb', ('^', ('@', 'x'), ('#', '2')), ('x',)))
		self.assertEqual (ast2spt2ast (p ('beta (2, 3)')), ('-func', 'beta', (('#', '2'), ('#', '3'))))
		self.assertEqual (ast2spt2ast (p ('{x d} y')), ('*', (('@', 'd'), ('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2')), ('*', (('^', ('@', 'dx'), ('#', '2')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (ast2spt2ast (p ('ln((a)**b)')), ('-log', ('^', ('@', 'a'), ('@', 'b'))))
		self.assertEqual (ast2spt2ast (p ('a * \\int dx + {\\int dx dx}')), ('+', (('*', (('@', 'a'), ('-intg', ('#', '1'), ('@', 'dx')))), ('*', (('@', 'dx'), ('-intg', ('#', '1'), ('@', 'dx')))))))
		self.assertRaises (TypeError, ast2spt2ast, p ('1 if {a = x if z} else 0 if y'))
		self.assertEqual (ast2spt2ast (p ('a, lambda: b = 1')), ('(', (',', (('@', 'a'), ('-lamb', ('=', ('@', 'b'), ('#', '1')), ())))))
		self.assertRaises (TypeError, ast2spt2ast, p ('a * [2]'))
		self.assertRaises (AttributeError, ast2spt2ast, p ('sqrt(1, 2)'))
		self.assertEqual (ast2spt2ast (p ('x*[][y]')), ('*', (('@', 'x'), ('-idx', ('[', ()), (('@', 'y'),)))))
		self.assertRaises (AttributeError, ast2spt2ast, p ('lambda: x:'))
		self.assertEqual (ast2spt2ast (p ('a*[x][y][z]')), ('*', (('@', 'a'), ('-idx', ('-idx', ('[', (('@', 'x'),)), (('@', 'y'),)), (('@', 'z'),)))))
		self.assertRaises (AttributeError, ast2spt2ast, p ('a*()**2'))
		self.assertRaises (AttributeError, ast2spt2ast, p ('a*().t'))
		self.assertRaises (IndexError, ast2spt2ast, p ('a*()[2]'))
		self.assertEqual (ast2spt2ast (p ('o.f*(a)')), ('*', (('@', 'a'), ('.', ('@', 'o'), 'f'))))
		self.assertEqual (ast2spt2ast (p ('o.f*{1+2}')), ('*', (('#', '3'), ('.', ('@', 'o'), 'f'))))
		self.assertEqual (ast2spt2ast (p ('d**2e0/dx**2e0 x**3')), ('/', ('^', ('@', 'd'), ('#', '2')), ('*', (('^', ('@', 'dx'), ('#', '2')), ('^', ('@', 'x'), ('#', '3'))))))
		self.assertEqual (ast2spt2ast (p ('y**z [w]')), ('^', ('@', 'y'), ('-idx', ('@', 'z'), (('@', 'w'),))))
		self.assertEqual (ast2spt2ast (p ('{y**z} [w]')), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))
		self.assertEqual (ast2spt2ast (p ('x {y**z} [w]')), ('*', (('@', 'x'), ('-idx', ('^', ('@', 'y'), ('@', 'z')), (('@', 'w'),)))))
		self.assertEqual (ast2spt2ast (p ('{x y**z} [w]')), ('-idx', ('*', (('@', 'x'), ('^', ('@', 'y'), ('@', 'z')))), (('@', 'w'),)))
		self.assertEqual (ast2spt2ast (p ('Min (x, y, z)')), ('-func', 'Min', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('Max (x, y, z)')), ('-func', 'Max', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('\\Re (z)')), ('-func', 're', (('@', 'z'),)))
		self.assertEqual (ast2spt2ast (p ('\\Im (z)')), ('-func', 'im', (('@', 'z'),)))
		self.assertEqual (ast2spt2ast (p ('re (z)')), ('-func', 're', (('@', 'z'),)))
		self.assertEqual (ast2spt2ast (p ('im (z)')), ('-func', 'im', (('@', 'z'),)))
		self.assertEqual (ast2spt2ast (p ('{}')), ('-dict', ()))
		self.assertEqual (ast2spt2ast (p ('{1: 2}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2spt2ast (p ('{1: 2,}')), ('-dict', ((('#', '1'), ('#', '2')),)))
		self.assertEqual (ast2spt2ast (p ('{1: 2, 3: 4}')), ('-dict', ((('#', '1'), ('#', '2')), (('#', '3'), ('#', '4')))))
		self.assertEqual (ast2spt2ast (p ('set ()')), ('-set', ()))
		self.assertEqual (ast2spt2ast (p ('\\{}')), ('-set', ()))
		self.assertEqual (ast2spt2ast (p ('\\{1}')), ('-set', (('#', '1'),)))
		self.assertEqual (ast2spt2ast (p ('\\{1,2}')), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('{1,2}')), ('-set', (('#', '1'), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('1 in {1,2,3}')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('1 \\in {1,2,3}')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('4 in {1,2,3}')), ('@', 'False'))
		self.assertEqual (ast2spt2ast (p ('4 \\in {1,2,3}')), ('@', 'False'))
		self.assertEqual (ast2spt2ast (p ('4 not in {1,2,3}')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('4 \\notin {1,2,3}')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('{1,2} - {2,3}')), ('-set', (('#', '1'),)))
		self.assertEqual (ast2spt2ast (p ('{1,2} || {2,3}')), ('-set', (('#', '1'), ('#', '2'), ('#', '3'))))
		self.assertEqual (ast2spt2ast (p ('{1,2} ^^ {2,3}')), ('-set', (('#', '1'), ('#', '3'))))
		self.assertEqual (ast2spt2ast (p ('{1,2} && {2,3}')), ('-set', (('#', '2'),)))
		self.assertEqual (ast2spt2ast (p ('{1,2} || {2,3} || {3,4}')), ('-set', (('#', '1'), ('#', '2'), ('#', '3'), ('#', '4'))))
		self.assertEqual (ast2spt2ast (p ('{1,2} ^^ {2,3} ^^ {3,4}')), ('-set', (('#', '1'), ('#', '4'))))
		self.assertEqual (ast2spt2ast (p ('{1,2} && {2,3} && {3,4}')), ('-set', ()))
		self.assertEqual (ast2spt2ast (p ('{1,2} || {2,3} ^^ {3,4} && {4,5}')), ('-set', (('#', '1'), ('#', '2'), ('#', '3'), ('#', '4'))))
		self.assertEqual (ast2spt2ast (p ('solve (x**2 = 4)')), ('[', (('#', '-2'), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('Subs (x y, x, 2)')), ('*', (('#', '2'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('Subs (x y, (x, y), (2, 3))')), ('#', '6'))
		self.assertEqual (ast2spt2ast (p ('(x y).subs (x, 2)')), ('*', (('#', '2'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('(x y).subs (x, 2).subs (y, 3)')), ('#', '6'))
		self.assertEqual (ast2spt2ast (p ('Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])')), ('#', '120'))
		self.assertEqual (ast2spt2ast (p ('x or y')), ('-or', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x or y or z')), ('-or', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('x and y')), ('-and', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x and y and z')), ('-and', (('@', 'x'), ('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('x and y or z')), ('-or', (('@', 'z'), ('-and', (('@', 'x'), ('@', 'y'))))))
		self.assertEqual (ast2spt2ast (p ('x and {y or z}')), ('-and', (('@', 'x'), ('-or', (('@', 'y'), ('@', 'z'))))))
		self.assertEqual (ast2spt2ast (p ('not x or y')), ('-or', (('@', 'y'), ('-not', ('@', 'x')))))
		self.assertEqual (ast2spt2ast (p ('not {x or y}')), ('-not', ('-or', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2spt2ast (p ('not x and y')), ('-and', (('@', 'y'), ('-not', ('@', 'x')))))
		self.assertEqual (ast2spt2ast (p ('not {x and y}')), ('-not', ('-and', (('@', 'x'), ('@', 'y')))))
		self.assertEqual (ast2spt2ast (p ('x or not y')), ('-or', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (ast2spt2ast (p ('x and not y')), ('-and', (('@', 'x'), ('-not', ('@', 'y')))))
		self.assertEqual (ast2spt2ast (p ('not x')), ('-not', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('not not x')), ('@', 'x'))
		self.assertEqual (ast2spt2ast (p ('not not not x')), ('-not', ('@', 'x')))
		self.assertEqual (ast2spt2ast (p ('0 or []')), ('@', 'False'))
		self.assertEqual (ast2spt2ast (p ('0 or [1]')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('1 and []')), ('@', 'False'))
		self.assertEqual (ast2spt2ast (p ('1 and [1]')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('not []')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('not [1]')), ('@', 'False'))
		self.assertEqual (ast2spt2ast (p ('not None')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('True + True')), ('#', '2'))
		self.assertEqual (ast2spt2ast (p ('False - True')), ('#', '-1'))
		self.assertEqual (ast2spt2ast (p ('True * True')), ('#', '1'))
		self.assertEqual (ast2spt2ast (p ('(2 > 1) x')), ('@', 'x'))
		self.assertEqual (ast2spt2ast (p ('(2 > 1) + (1 < 2)')), ('#', '2'))
		self.assertEqual (ast2spt2ast (p ('\\[{[a, b]},]')), ('-mat', ((('[', (('@', 'a'), ('@', 'b'))),),)))
		self.assertRaises (TypeError, ast2spt2ast, p ('{{a:b:c}:d}'))
		self.assertEqual (ast2spt2ast (p ('{a:{b:c:d}}')), ('-dict', ((('@', 'a'), ('-slice', ('@', 'b'), ('@', 'c'), ('@', 'd'))),)))
		self.assertEqual (ast2spt2ast (p ('{a:b:c} = {a:b:c}')), ('@', 'True'))
		self.assertEqual (ast2spt2ast (p ('\\[1:2:3]')), ('-mat', ((('-slice', ('#', '1'), ('#', '2'), ('#', '3')),),)))
		self.assertRaises (TypeError, ast2spt2ast, p ('-{not x}'))
		self.assertEqual (ast2spt2ast (p ('x < y in [y] in [[y]] != 2 > 1')), ('<>', ('@', 'x'), (('<', ('@', 'y')),)))
		self.assertEqual (ast2spt2ast (p ('x < y < z < w')), ('<>', ('@', 'x'), (('<', ('@', 'y')), ('<', ('@', 'z')), ('<', ('@', 'w')))))
		self.assertEqual (ast2spt2ast (p ('\\[]')), ('-mat', ()))
		self.assertEqual (ast2spt2ast (p ('\\[[]]')), ('-mat', ()))
		self.assertEqual (ast2spt2ast (p ('\\[[], []]')), ('-mat', ()))
		self.assertRaises (AttributeError, ast2spt2ast, p ('\\{a:b}'))
		self.assertEqual (ast2spt2ast (p ('{-x} y / z')), ('-', ('/', ('*', (('@', 'x'), ('@', 'y'))), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('d / dz {-1} a')), ('-diff', ('-', ('@', 'a')), 'd', (('z', 1),)))
		self.assertEqual (ast2spt2ast (p ('1 / {-2} x')), ('-', ('/', ('#', '1'), ('*', (('#', '2'), ('@', 'x'))))))
		self.assertEqual (ast2spt2ast (p ('\\sum_{x=0}^b {-x} y')), ('-sum', ('-', ('*', (('@', 'x'), ('@', 'y')))), ('@', 'x'), ('#', '0'), ('@', 'b')))
		self.assertEqual (ast2spt2ast (p ('\\lim_{x\\to0} {-x} y')), ('#', '0'))
		self.assertEqual (ast2spt2ast (p ('\\int a / -1 dx')), ('-intg', ('-', ('@', 'a')), ('@', 'dx')))
		self.assertEqual (ast2spt2ast (p ('\\[[[x]]]')), ('-mat', ((('[', (('@', 'x'),)),),)))
		self.assertEqual (ast2spt2ast (p ('\\[[[1, 2]], [[3]]]')), ('-mat', ((('[', (('#', '1'), ('#', '2'))),), (('[', (('#', '3'),)),))))
		self.assertEqual (ast2spt2ast (p ('{1/x}.limit (x, 0, "-")')), ('-', ('@', 'oo')))
		self.assertEqual (ast2spt2ast (p ('{x^2y**2z}.diff (x, 2, y, z)')), ('*', (('#', '4'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('{x y}.integrate ((x, 0, 1))')), ('/', ('@', 'y'), ('#', '2')))
		self.assertRaises (TypeError, ast2spt2ast, p ('\\sqrt (a:b)'))
		self.assertRaises (TypeError, ast2spt2ast, p ('\\sqrt[3] (a:b)'))
		self.assertEqual (ast2spt2ast (p ('? ()')), ('-ufunc', '?', ()))
		self.assertEqual (ast2spt2ast (p ('? (x)')), ('-ufunc', '?', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('? (x) (2)')), ('*', (('#', '2'), ('-ufunc', '?', (('@', 'x'),)))))
		self.assertEqual (ast2spt2ast (p ('? (2)')), ('-ufunc', '?', (('#', '2'),)))
		self.assertEqual (ast2spt2ast (p ('?f (x, y, real = True)')), ('-ufunc', '?f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2spt2ast (p ('?\\alpha(x)')), ('-ufunc', '?alpha', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('?beta(y)')), ('-ufunc', '?beta', (('@', 'y'),)))
		self.assertEqual (ast2spt2ast (p ("Function ('f', real = True) (x, y)")), ('-ufunc', '?f', (('@', 'x'), ('@', 'y')), (('real', ('@', 'True')),)))
		self.assertEqual (ast2spt2ast (p ("x'")), ('-diffp', ('@', 'x'), 1))
		self.assertEqual (ast2spt2ast (p ("x''")), ('-diffp', ('@', 'x'), 2))
		self.assertRaises (ValueError, ast2spt2ast, p ("{x + y}'"))
		self.assertRaises (ValueError, ast2spt2ast, p ("a [b]'"))
		self.assertRaises (ValueError, ast2spt2ast, p ("a.b ()'"))
		self.assertRaises (ValueError, ast2spt2ast, p ("{x/y}'"))
		self.assertRaises (TypeError, ast2spt2ast, p ("1'['ac']"))
		self.assertEqual (ast2spt2ast (p ("|x|'")), ('-diffp', ('|', ('@', 'x')), 1))
		self.assertEqual (ast2spt2ast (p ("| 'str'|'")), ('-diffp', ('|', ('@', 'str')), 1))
		self.assertRaises (ValueError, ast2spt2ast, p ("{x**y}'"))
		self.assertEqual (ast2spt2ast (p ("{{-1}'}")), ('#', '0'))
		self.assertRaises (ValueError, ast2spt2ast, p ("{a [b]}''"))
		self.assertEqual (ast2spt2ast (p ("1.'''")), ('#', '0'))
		self.assertEqual (ast2spt2ast (p ('x [1]')), ('-idx', ('@', 'x'), (('#', '1'),)))
		self.assertRaises (TypeError, ast2spt2ast, p ('1 [x]'))
		self.assertEqual (ast2spt2ast (p ('[1, 2] [x]')), ('-idx', ('[', (('#', '1'), ('#', '2'))), (('@', 'x'),)))
		self.assertRaises (TypeError, ast2spt2ast, p ('{1, 2} [x]'))
		self.assertEqual (ast2spt2ast (p ('{x: 2} [x]')), ('#', '2'))
		self.assertRaises (KeyError, ast2spt2ast, p ('{y: 2} [x]'))
		self.assertEqual (ast2spt2ast (p ("'}'")), ('"', '}'))
		self.assertEqual (ast2spt2ast (p ('q w * e * {r * t} * y u {i * o} p {a {s * d} f}')), ('*', (('@', 'e'), ('@', 'i'), ('@', 'a'), ('@', 'd'), ('@', 'f'), ('@', 'o'), ('@', 'p'), ('@', 'q'), ('@', 'r'), ('@', 's'), ('@', 't'), ('@', 'u'), ('@', 'w'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('x, y = 1, 2')), ('=', ('(', (',', (('@', 'x'), ('@', 'y')))), ('(', (',', (('#', '1'), ('#', '2'))))))
		self.assertEqual (ast2spt2ast (p ('x, 2 = 1, 2')), ('(', (',', (('@', 'x'), ('@', 'False'), ('#', '2')))))
		self.assertEqual (ast2spt2ast (p ('(x, y) = 1, 2')), ('(', (',', (('@', 'False'), ('#', '2')))))
		self.assertRaises (RuntimeError, ast2spt2ast, p ('1; x, y = 1, 2'))
		self.assertRaises (RuntimeError, ast2spt2ast, p ('1; x, 2 = 1, 2'))
		self.assertRaises (RuntimeError, ast2spt2ast, p ('1; (x, y) = 1, 2'))
		self.assertEqual (ast2spt2ast (p ('f()()')), ('*', (('-ufunc', 'f', ()), ('(', (',', ())))))
		self.assertEqual (ast2spt2ast (p ('f()*()')), ('*', (('-ufunc', 'f', ()), ('(', (',', ())))))
		self.assertRaises (AttributeError, ast2spt2ast, p ('f*()*()'))
		self.assertRaises (AttributeError, ast2spt2ast, p ('f*()()'))

		self.assertEqual (ast2spt2ast (p ('dy / dx')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2spt2ast (p ('dy / dx z')), ('*', (('@', 'z'), ('-diff', ('@', 'y'), 'd', (('x', 1),)))))
		self.assertEqual (ast2spt2ast (p ('d**2 y / dx**2')), ('-diff', ('@', 'y'), 'd', (('x', 2),)))
		self.assertEqual (ast2spt2ast (p ('d**2 y / dx**2 z')), ('*', (('@', 'z'), ('-diff', ('@', 'y'), 'd', (('x', 2),)))))
		self.assertEqual (ast2spt2ast (p ('d**2 y / dx dy')), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2spt2ast (p ('d**2 y / dx dy z')), ('*', (('@', 'z'), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))))
		self.assertEqual (ast2spt2ast (p ('\\frac{dy}{dx}')), ('-diff', ('@', 'y'), 'd', (('x', 1),)))
		self.assertEqual (ast2spt2ast (p ('\\frac{dy}{dx} z')), ('*', (('@', 'z'), ('-diff', ('@', 'y'), 'd', (('x', 1),)))))
		self.assertEqual (ast2spt2ast (p ('\\frac{d**2}{dx**2}')), ('/', ('^', ('@', 'd'), ('#', '2')), ('^', ('@', 'dx'), ('#', '2'))))
		self.assertEqual (ast2spt2ast (p ('\\frac{d**2}{dx**2} z')), ('-diff', ('@', 'z'), 'd', (('x', 2),)))
		self.assertEqual (ast2spt2ast (p ('\\frac{d**2}{dx dy}')), ('/', ('^', ('@', 'd'), ('#', '2')), ('*', (('@', 'dx'), ('@', 'dy')))))
		self.assertEqual (ast2spt2ast (p ('\\frac{d**2}{dx dy} z')), ('-diff', ('@', 'z'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2spt2ast (p ('\\frac{d**2 y}{dx dy}')), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2spt2ast (p ('\\frac{d**2 y}{dx dy} z')), ('*', (('@', 'z'), ('-diff', ('@', 'y'), 'd', (('x', 1), ('y', 1))))))
		self.assertEqual (ast2spt2ast (p ('\\int dy / dx')), ('-intg', ('-diff', ('@', 'y'), 'd', (('x', 1),)), ('@', 'd')))
		self.assertEqual (ast2spt2ast (p ('\\int d/dx x**2 dx')), ('-intg', ('-diffp', ('^', ('@', 'x'), ('#', '2')), 1), ('@', 'dx')))
		self.assertEqual (ast2spt2ast (p ('\\int d/dx y(x) dx')), ('-intg', ('-diffp', ('-ufunc', 'y', (('@', 'x'),)), 1), ('@', 'dx')))
		self.assertEqual (ast2spt2ast (p ('\\int dx dx dx')), ('*', (('^', ('@', 'dx'), ('#', '2')), ('-intg', ('#', '1'), ('@', 'dx')))))
		self.assertEqual (ast2spt2ast (p ('\\int dx * dx dx')), ('*', (('^', ('@', 'dx'), ('#', '2')), ('-intg', ('#', '1'), ('@', 'dx')))))
		self.assertEqual (ast2spt2ast (p ('dlambda / dx : x')), ('-slice', ('-diff', ('@', 'lambda'), 'd', (('x', 1),)), ('@', 'x'), None))
		self.assertEqual (ast2spt2ast (p ('d**2 lambda / dx**2 : x')), ('-slice', ('-diff', ('@', 'lambda'), 'd', (('x', 2),)), ('@', 'x'), None))
		self.assertEqual (ast2spt2ast (p ('ln1.or')), ('.', ('@', 'ln1'), 'or'))
		self.assertRaises (AttributeError, ast2spt2ast, p ('ln1. or'))
		self.assertRaises (AttributeError, ast2spt2ast, p ('ln1 . or'))
		self.assertEqual (ast2spt2ast (p ('a.b * c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd'))))
		self.assertEqual (ast2spt2ast (p ('a.b c.d')), ('*', (('.', ('@', 'a'), 'b'), ('.', ('@', 'c'), 'd'))))
		self.assertEqual (ast2spt2ast (p ('lambda x, y, z: ln lambda x:')), ('(', (',', (('*', (('@', 'lambda'), ('@', 'x'))), ('@', 'y'), ('-slice', ('@', 'z'), ('*', (('@', 'x'), ('-log', ('@', 'lambda')))), None)))))
		self.assertEqual (ast2spt2ast (p ('lambda x, y, z: ln lambda x: 1')), ('-lamb', ('-log', ('-lamb', ('#', '1'), ('x',))), ('x', 'y', 'z')))

		self.assertEqual (ast2spt2ast (p ('f (x) (0)')), ('#', '0'))
		self.assertEqual (ast2spt2ast (p ('f (x, y) (0, 0)')), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'))), ('(', (',', (('#', '0'), ('#', '0')))))))
		self.assertEqual (ast2spt2ast (p ('f (x, y, z) (0, 0, 0)')), ('*', (('-ufunc', 'f', (('@', 'x'), ('@', 'y'), ('@', 'z'))), ('(', (',', (('#', '0'), ('#', '0'), ('#', '0')))))))
		self.assertEqual (ast2spt2ast (p ("f (x)' (0)")), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2spt2ast (p ('\\. x+y |_{x = 1}')), ('+', (('@', 'y'), ('#', '1'))))
		self.assertEqual (ast2spt2ast (p ('\\. x+y |_{x = 1, y = 2}')), ('#', '3'))
		self.assertEqual (ast2spt2ast (p ('\\. x+y |_{x, y = 1, 2}')), ('#', '3'))
		self.assertEqual (ast2spt2ast (p ('\\. x+y |_{\\substack{x = 1}}')), ('+', (('@', 'y'), ('#', '1'))))
		self.assertEqual (ast2spt2ast (p ('\\. x+y |_{\\substack{x = 1 \\\\ y = 2}}')), ('#', '3'))
		self.assertEqual (ast2spt2ast (p ('\\. f(x) |_{f(x) = y}')), ('@', 'y'))
		self.assertEqual (ast2spt2ast (p ('\\. f(x) f(y) |_{f(x), f(y) = y, z}')), ('*', (('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('\\. f(x) f(y) |_{f(x) = y, f(y) = z}')), ('*', (('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('\\. f(x) f(y) |_{\\substack{f(x) = y \\\\ f(y) = z}}')), ('*', (('@', 'y'), ('@', 'z'))))
		self.assertEqual (ast2spt2ast (p ('\\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}')), ('(', (',', (('#', '3'), ('#', '4')))))

		self.assertEqual (ast2spt2ast (p ("f (x)' (0)")), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2spt2ast (p ('d / dx (f (x)) (0)')), ('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2spt2ast (p ('d / dx (u (x, y)) (x, y)')), ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)))
		self.assertEqual (ast2spt2ast (p ('d / dx (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2spt2ast (p ('d / dx (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2spt2ast (p ('d**2 / dx dy (u (x, y)) (x, y)')), ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))))
		self.assertEqual (ast2spt2ast (p ('d**2 / dx dy (u (x, y)) (0, y)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')),)))
		self.assertEqual (ast2spt2ast (p ('d**2 / dx dy (u (x, y)) (0, 0)')), ('-subs', ('-diff', ('-ufunc', 'u', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1), ('y', 1))), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '0')))))
		self.assertEqual (ast2spt2ast (p ("dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})")), ('=', ('-ufunc', 'y', (('@', 'x'),)), ('*', (('+', (('/', ('*', (('#', '7'), ('^', ('@', 'e'), ('*', (('#', '-5'), ('@', 'x')))))), ('#', '5')), ('-', ('/', ('#', '7'), ('#', '5'))))), ('^', ('@', 'e'), ('*', (('#', '-3'), ('@', 'x'))))))))
		self.assertEqual (ast2spt2ast (p ("\\. [f(x)', g(y)'] |_{x = 0, y = 1}")), ('[', (('-subs', ('-diffp', ('-ufunc', 'f', (('@', 'x'),)), 1), ((('@', 'x'), ('#', '0')),)), ('-subs', ('-diffp', ('-ufunc', 'g', (('@', 'y'),)), 1), ((('@', 'y'), ('#', '1')),)))))
		self.assertEqual (ast2spt2ast (p ('\\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}')), ('[', (('-subs', ('-diff', ('-ufunc', 'f', (('@', 'x'), ('@', 'y'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))), ('-subs', ('-diff', ('-ufunc', 'g', (('@', 'y'), ('@', 'x'))), 'd', (('x', 1),)), ((('@', 'x'), ('#', '0')), (('@', 'y'), ('#', '1')))))))
		self.assertEqual (ast2spt2ast (p ('\\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}')), ('#', '0'))
		self.assertEqual (ast2spt2ast (p ('?() = 2')), ('=', ('-ufunc', '?', ()), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('?f() = 2')), ('=', ('-ufunc', '?f', ()), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('d / dx (a) b')), ('*', (('@', 'b'), ('-diff', ('@', 'a'), 'd', (('x', 1),)))))
		self.assertEqual (ast2spt2ast (p ('\\frac{d}{dx} (a) b')), ('*', (('@', 'b'), ('-diff', ('@', 'a'), 'd', (('x', 1),)))))
		self.assertRaises (AttributeError, ast2spt2ast, p ('sin (())'))
		self.assertEqual (ast2spt2ast (p ('sin (((a))')), ('-func', 'sin', (('@', 'a'),)))
		self.assertEqual (ast2spt2ast (p ('a.b (())')), ('.', ('@', 'a'), 'b', (('(', (',', ())),)))
		self.assertEqual (ast2spt2ast (p ('a.b (((a))')), ('.', ('@', 'a'), 'b', (('(', ('(', ('@', 'a'))),)))
		self.assertEqual (ast2spt2ast (p ('@x')), ('@', 'x'))
		self.assertEqual (ast2spt2ast (p ('@(x + y)')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('@(x + y)')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('%x')), ('@', 'x'))
		self.assertEqual (ast2spt2ast (p ('%(x + y)')), ('+', (('@', 'x'), ('@', 'y'))))
		self.assertEqual (ast2spt2ast (p ('%%x')), ('-func', '%', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('%%(x + y)')), ('-func', '%', (('+', (('@', 'x'), ('@', 'y'))),)))
		self.assertEqual (ast2spt2ast (p ('\\[[1, 2, 3], [4, 5, 6]] [:, 1:]')), ('-mat', ((('#', '2'), ('#', '3')), (('#', '5'), ('#', '6')))))

		self.assertEqual (ast2spt2ast (p ('N - N N 2')), ('+', (('@', 'N'), ('-', ('#', '2')))))
		self.assertEqual (ast2spt2ast (p ('N N N 2')), ('#', '2'))
		self.assertEqual (ast2spt2ast (p ('sin sin sin 2')), ('-func', 'sin', (('-func', 'sin', (('-func', 'sin', (('#', '2'),)),)),)))
		self.assertEqual (ast2spt2ast (p ('-N sin -N 2')), ('#', '0.909297426825682'))
		self.assertEqual (ast2spt2ast (p ('sin -N sin 2')), ('#', '-0.789072343572888'))
		self.assertEqual (ast2spt2ast (p ('N N sin -a [2]')), ('-', ('-func', 'sin', (('-idx', ('@', 'a'), (('#', '2'),)),))))
		self.assertEqual (ast2spt2ast (p ('N N sin -a.b [2]')), ('-', ('-func', 'sin', (('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),)),))))
		self.assertEqual (ast2spt2ast (p ('N N sin -a.b () [2]')), ('-', ('-func', 'sin', (('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),)),))))
		self.assertEqual (ast2spt2ast (p ('N N sin -a.b () [2] [3]')), ('-', ('-func', 'sin', (('-idx', ('-idx', ('.', ('@', 'a'), 'b', ()), (('#', '2'),)), (('#', '3'),)),))))
		self.assertRaises (TypeError, ast2spt2ast, p ('sin -N () [2] [3].c [4].d () [5]'))
		self.assertRaises (TypeError, ast2spt2ast, p ('sqrt -N () [2] [3].c [4].d () [5]'))
		self.assertRaises (TypeError, ast2spt2ast, p ('sqrt[3] -N () [2] [3].c [4].d () [5]'))
		self.assertRaises (TypeError, ast2spt2ast, p ('log -N () [2] [3].c [4].d () [5]'))
		self.assertRaises (TypeError, ast2spt2ast, p ('\\log_2 -N () [2] [3].c [4].d () [5]'))
		self.assertEqual (ast2spt2ast (p ('N sin**2 ln**2 N x')), ('^', ('-func', 'sin', (('^', ('-log', ('@', 'x')), ('#', '2')),)), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('sin ln N x')), ('-func', 'sin', (('-log', ('@', 'x')),)))
		self.assertEqual (ast2spt2ast (p ('sin(a)**[a][b].c')), ('^', ('-func', 'sin', (('@', 'a'),)), ('.', ('-idx', ('[', (('@', 'a'),)), (('@', 'b'),)), 'c')))
		self.assertEqual (ast2spt2ast (p ('N sin N sin x')), ('-func', 'sin', (('-func', 'sin', (('@', 'x'),)),)))
		self.assertEqual (ast2spt2ast (p ('cos**-1 0 \\log_2 8')), ('/', ('*', (('#', '3'), ('@', 'pi'))), ('#', '2')))
		self.assertEqual (ast2spt2ast (p ('N sin sqrt[3] \\log_2 8')), ('#', '0.991749236577359'))
		self.assertEqual (ast2spt2ast (p ('sin(x)**-a[b][c].d')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2spt2ast (p ('sin sin x [2].w')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),)))
		self.assertEqual (ast2spt2ast (p ('sin -sin x [2].w')), ('-', ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),))))
		self.assertEqual (ast2spt2ast (p ('sin sin (x) [2].w')), ('-func', 'sin', (('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w'),)))
		self.assertEqual (ast2spt2ast (p ('sin -sin (x) [2].w')), ('-', ('-func', 'sin', (('.', ('-idx', ('-func', 'sin', (('@', 'x'),)), (('#', '2'),)), 'w'),))))
		self.assertEqual (ast2spt2ast (p ('sin sin x [2].w ()')), ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w', ()),)),)))
		self.assertEqual (ast2spt2ast (p ('ln ln x [2].w')), ('-log', ('-log', ('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'))))
		self.assertEqual (ast2spt2ast (p ('N N sin -a [2]')), ('-', ('-func', 'sin', (('-idx', ('@', 'a'), (('#', '2'),)),))))
		self.assertEqual (ast2spt2ast (p ('sin sin -x [2].w')), ('-', ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),))))
		self.assertEqual (ast2spt2ast (p ('sin -sin x [2].w')), ('-', ('-func', 'sin', (('-func', 'sin', (('.', ('-idx', ('@', 'x'), (('#', '2'),)), 'w'),)),))))
		self.assertEqual (ast2spt2ast (p ('sin(a)**b[2]')), ('^', ('-func', 'sin', (('@', 'a'),)), ('-idx', ('@', 'b'), (('#', '2'),))))
		self.assertEqual (ast2spt2ast (p ('sin**-a[b][c].d x')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertRaises (TypeError, ast2spt2ast, p ('sin**-a[b][c].d (x)'))
		self.assertEqual (ast2spt2ast (p ('sin**-a[b][c].d {(x)}')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2spt2ast (p ('sin**-a[b][c] (x)')), ('^', ('-func', 'sin', (('@', 'x'),)), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (ast2spt2ast (p ('\\int**-a[b][c] x')), ('-intg', ('@', 'x'), ('@', 'd'), ('#', '0'), ('-', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)))))
		self.assertEqual (ast2spt2ast (p ('\\int**-a[b][c].d (x)')), ('-intg', ('#', '1'), ('@', 'd'), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2spt2ast (p ('\\int**-a[b][c].d {(x)}')), ('-intg', ('@', 'x'), ('@', 'd'), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2spt2ast (p ('\\int**-a[b][c].d (x) y')), ('-intg', ('@', 'y'), ('@', 'd'), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd', (('@', 'x'),)))))
		self.assertEqual (ast2spt2ast (p ('\\int**-a[b][c].d {(x)} y')), ('-intg', ('*', (('@', 'x'), ('@', 'y'))), ('@', 'd'), ('#', '0'), ('-', ('.', ('-idx', ('-idx', ('@', 'a'), (('@', 'b'),)), (('@', 'c'),)), 'd'))))
		self.assertEqual (ast2spt2ast (p ('\\int**a.b[2] x dx')), ('-intg', ('@', 'x'), ('@', 'dx'), ('#', '0'), ('-idx', ('.', ('@', 'a'), 'b'), (('#', '2'),))))

		self.assertEqual (ast2spt2ast (p ('d/dx (real = True)')), ('-diff', ('=', ('@', 'real'), ('@', 'True')), 'd', (('x', 1),)))
		self.assertEqual (ast2spt2ast (p ('f {\\left(x\\right)}')), ('-ufunc', 'f', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('a.b {(x)}')), ('*', (('@', 'x'), ('.', ('@', 'a'), 'b'))))
		self.assertEqual (ast2spt2ast (p ('a.b {\\left(x\\right)}')), ('.', ('@', 'a'), 'b', (('@', 'x'),)))
		self.assertEqual (ast2spt2ast (p ('\\log_{|x|} y')), ('/', ('-log', ('@', 'y')), ('-log', ('|', ('@', 'x')))))
		self.assertEqual (ast2spt2ast (p ('|\\int a + b dx|')), ('|', ('-intg', ('+', (('@', 'a'), ('@', 'b'))), ('@', 'dx'))))
		self.assertEqual (ast2spt2ast (p ('\\int deg N dx')), ('-intg', ('/', ('*', (('#', '180'), ('@', 'N'))), ('@', 'pi')), ('@', 'dx')))
		self.assertEqual (ast2spt2ast (p ('a \\int x dx / c')), ('/', ('*', (('@', 'a'), ('-intg', ('@', 'x'), ('@', 'dx')))), ('@', 'c')))
		self.assertEqual (ast2spt2ast (p ('\\int x dx b / c')), ('/', ('*', (('@', 'b'), ('-intg', ('@', 'x'), ('@', 'dx')))), ('@', 'c')))
		self.assertEqual (ast2spt2ast (p ('a \\int x dx b / c')), ('/', ('*', (('@', 'a'), ('@', 'b'), ('-intg', ('@', 'x'), ('@', 'dx')))), ('@', 'c')))
		self.assertRaises (NotImplementedError, ast2spt2ast, p ('a {\\lim_{x\\to0} \\int x dx} / b'))
		self.assertEqual (ast2spt2ast (p ('a {\\sum_{x=0}^1 \\int x dx} / b')), ('/', ('*', (('@', 'a'), ('-sum', ('-intg', ('@', 'x'), ('@', 'dx')), ('@', 'x'), ('#', '0'), ('#', '1')))), ('@', 'b')))
		self.assertEqual (ast2spt2ast (p ('a / \\int x dx * c')), ('/', ('*', (('@', 'a'), ('@', 'c'))), ('-intg', ('@', 'x'), ('@', 'dx'))))
		self.assertEqual (ast2spt2ast (p ('a / b \\int x dx * c')), ('/', ('*', (('@', 'a'), ('@', 'c'))), ('*', (('@', 'b'), ('-intg', ('@', 'x'), ('@', 'dx'))))))

		self.assertEqual (ast2spt2ast (p ('cos')), ('@', 'cos'))
		self.assertEqual (ast2spt2ast (p ('f = cos')), ('@', 'False'))
		self.assertEqual (ast2spt2ast (p ('\\[[0, pi], [-pi, 0]].applyfunc (cos)')), ('-mat', ((('#', '1'), ('#', '-1')), (('#', '-1'), ('#', '1')))))
		self.assertEqual (ast2spt2ast (p ('$sin (real = True)')), ('-sym', 'sin', (('real', ('@', 'True')),)))
		self.assertEqual (ast2spt2ast (p ('sin = $(real = True)')), ('@', 'False'))
	# END UPDATE BLOCK

_EXPRESSIONS = r"""
1
1.
.1
1e20
1E-20
1.e+20
.1e-20
sin (-1.23456789012345678901234567890123456789012345678901234567890123456789012345678901)
x
xy
dx
partialx
\partial x
x d  y
x partial y
x \partial  y
x dx dy y
x partialx partialy y
-1
-x
{x}
()
(x)
(x,)
(x,y)
(x,y,)
[]
[x]
[x,]
[x,y]
[x,y,]
"x\x20\n"
'x\x20\n'
|x|
x!
x+y
x-y
x*y
x y
x(y)
x*(y)
x/y
x^y
log x
log {x}
log (x)
\log_2 x
\log_2 {x}
\log_2 (x)
sqrt x
sqrt {x}
sqrt (x)
sqrt {(x)}
sqrt[3] x
sqrt[3] {x}
sqrt[3] {(x)}
sqrt[3] (x)
sin x
sin^2 x
sin (x)
sin (x)^2
sin {x}
sin {(x)}
{sin x}^2
sin**2 x
sin**-1 x
sin(x)**-1
acos (x)
\arccos (x)
sin(x**2)
sin(x**2)**2
(sin(x**2)**2)
ln(x**2)
ln(x**2)**2
(ln(x**2)**2)
gamma(x**2)
gamma(x**2)**2
(gamma(x**2)**2)
{gamma}[2]
{Gamma}[2]
f{(x)}
f{(x)}'(0)
f{(x)}'{(0)}
\operatorname{x_{1}}{\left(x \right)}
\lim_{x\to0} 1/x
\lim_{x\to0^+} 1/x
\lim_{x\to0**-} 1/x
Limit (1/x, x, 0)
Limit (1/x, x, 0, "-")
Limit (1/x, x, 0, dir="+-")
limit (1/x, x, 0)
limit (1/x, x, 0, "-")
limit (1/x, x, 0, dir="+-")
\sum_{n=0}^\infty x^n/n!
Sum (x^n/n!, (n, 0, oo))
summation (x^n/n!, (n, 0, oo))
d/dx x**2y**2z
d^2/dx^2 x^2y**2z
d^3/dx^2dy x^2y**2z
\partial^4 / \partial x^2\partial y\partial z x^2 y**2 z
d**1.5 / dx dy x**2y**2
d**-2 / dx dy x**2y**2
d**2 / dx**1.5 x**2y**2
Derivative (x^2y**2z, x, 2, y, z)
diff (x^2y**2z, x, 2, y, z)
\int dx
\int x dx
\int_0^1 x dx
\int_0^1 \int y dy dx
Integral (\int y dy, (x, 0, 1))
integrate (\int y dy, (x, 0, 1))

\[1,]
\[1,2]
\[1,2,]
\[[1,],]
\[[1,],[2,]]
\[[1,],[2,],]
\left[\begin{matrix} 1 \end{matrix}\right]
\begin{bmatrix} 1 \\ \end{bmatrix}
\begin{vmatrix} 1 & 2 \\ \end{vmatrix}
\begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix}
\begin{matrix} 1 & 2 \\ 3 & 4 \\ \end{matrix}
\[1,2]!
\[[0,1],[1,0]]**x
\[[1,2],[3,4]]!
\[[1,2,3],[4,5,6]].T
\[[1,2,3],[4,5,6]].T.T
\[[1,2,3],[4,5,6]].T.T.T
\[[1,2,3],[4,5,6]].transpose ()
\[[1,2,3],[4,5,6]].transpose ().transpose ()
\[[1,2,3],[4,5,6]].transpose ().transpose ().transpose ()
\[[1,2,3],[4,5,6]].transpose ().transpose ().T.T.transpose ().transpose ()
\begin{matrix} A & B \\ C & D \end{matrix} * \[x, y]
\[[1, 2], [3
\[[1, 2], [3]]
\[[1], [2, 3]]

-1**x
{-1}**x
-{-1}**x
(-1)**x
-(-1)**x
alpha, beta, gamma, delta, epsilon, zeta, eta, theta, iota, kappa, lambda, mu, nu, xi, pi, rho, sigma, tau, upsilon, phi, chi, psi, omega, Gamma, Delta, Theta, Lambda, Xi, Pi, Sigma, Upsilon, Phi, Psi, Omega
\alpha, \beta, \gamma, \delta, \epsilon, \zeta, \eta, \theta, \iota, \kappa, \lambda, \mu, \nu, \xi, \pi, \rho, \sigma, \tau, \upsilon, \phi, \chi, \psi, \omega, \Gamma, \Delta, \Theta, \Lambda, \Xi, \Pi, \Sigma, \Upsilon, \Phi, \Psi, \Omega
1 if x < y
1 if x < y else 3
1 if x < y else 3 if x < z
1 if x < y else 3 if x < z else 5
\begin{cases} 1 & x < y \\ 3 & x < z \\ 5 & \end{cases}
\begin{cases} 1 & x < y \\ 3 & x < z \\ 5 & \\ \end{cases}
\begin{cases} 1 & x < y \\ 3 & x < z \\ 5 & x < w \end{cases}
\begin{cases} 1 & x < y \\ 3 & x < z \\ 5 & x < w \\ \end{cases}
x**y.a
x**y.a ()
x**y.a.b
x**y.a.b ()
x**y.a ().b
x**y.a ().b ()
{1 if x < 0 else 3} if x < 1 else 5
1 if {True if x < 0 else False} else 5
1 if {True if x < 0 else False} else {7 if x < 1 else 5}
{1 if x < 0 else 9} if {True if x < 1 else False} else {7 if x < 2 else 5}
x.y!
x.y**2
x.y ()!
x.y ()**2
x**y.a!
x**y.a**2
x**y.a ()!
x**y.a ()**2
lambda: x
lambda x: x**2
lambda x, y: x + y
lambda x, y, z: x + y + z
1, lambda: x
1, lambda x: x**2
1, lambda x, y: x + y
1, lambda x, y, z: x + y + z
f = lambda: 0
f = lambda x: 0
f = lambda x, y: 0
f = lambda x, y, z: 0
\left(\left(\right) \mapsto x \right)
\left(\left(x \right) \mapsto x^2 \right)
\left(\left(x, y \right) \mapsto x + y \right)
\lambda: x
\lambda x: x
\lambda x, y: x
{lambda}: x
{lambda} x: x
{lambda} x, y: x
$
$s
$ (real = True)
$s (real = True)

eye (2).is_diagonal ()
a [2]
a [2,3]
a * [2]
a * {-1}[x]
a * [x][y][z]
N (1/2)
S ('1/2')
N (S ('1/2'))
S.Half
N S.Half
o [i].t
o [i]**2
o [i]!
'Hello' [::-1]
\[[1, 2, 3], [4, 5, 6]] [:,1]
\binom96
binomial (x, y)
y - 1*x
Poly(x**2 + 2 x + 1, x, domain = 'ZZ')
Poly(x**2 + y**2 + 2 x y, x, y, domain = 'CC')
oct(10)
(1,) + (2,)
[1] + [2]
'a' + 'b'
(1,) * 2
[1] * 2
'a' * 2
Lambda (x, x**2)
beta (2, 3)
{x d} y
d**2e0/dx**2e0 x**3
ln((a)**b)
a * \int dx + {\int dx dx}
1 if {a = x if z} else 0 if y
a, lambda: b = 1
a * [2]
sqrt(1, 2)
x*[][y]
lambda: x:
a*[x][y][z]
a*()**2
a*().t
a*()[2]
o.f*(a)
o.f*{1+2}
d**2e0/dx**2e0 x**3
y**z [w]
{y**z} [w]
x {y**z} [w]
{x y**z} [w]
Min (x, y, z)
Max (x, y, z)
\Re (z)
\Im (z)
re (z)
im (z)
{}
{1: 2}
{1: 2,}
{1: 2, 3: 4}
set ()
\{}
\{1}
\{1,2}
{1,2}
1 in {1,2,3}
1 \in {1,2,3}
4 in {1,2,3}
4 \in {1,2,3}
4 not in {1,2,3}
4 \notin {1,2,3}
{1,2} - {2,3}
{1,2} || {2,3}
{1,2} ^^ {2,3}
{1,2} && {2,3}
{1,2} || {2,3} || {3,4}
{1,2} ^^ {2,3} ^^ {3,4}
{1,2} && {2,3} && {3,4}
{1,2} || {2,3} ^^ {3,4} && {4,5}
solve (x**2 = 4)
Subs (x y, x, 2)
Subs (x y, (x, y), (2, 3))
(x y).subs (x, 2)
(x y).subs (x, 2).subs (y, 3)
Subs ((x y z w).subs ({z: 4}), (x, y), (2, 3)).subs ([(w, 5)])
x or y
x or y or z
x and y
x and y and z
x and y or z
x and {y or z}
not x or y
not {x or y}
not x and y
not {x and y}
x or not y
x and not y
not x
not not x
not not not x
0 or []
0 or [1]
1 and []
1 and [1]
not []
not [1]
not None
True + True
False - True
True * True
(2 > 1) x
(2 > 1) + (1 < 2)
\[{[a, b]},]
{{a:b:c}:d}
{a:{b:c:d}}
{a:b:c} = {a:b:c}
\[1:2:3]
-{not x}
x < y in [y] in [[y]] != 2 > 1
x < y < z < w
\[]
\[[]]
\[[], []]
\{a:b}
{-x} y / z
d / dz {-1} a
1 / {-2} x
\sum_{x=0}^b {-x} y
\lim_{x\to0} {-x} y
\int a / -1 dx
\[[[x]]]
\[[[1, 2]], [[3]]]
{1/x}.limit (x, 0, "-")
{x^2y**2z}.diff (x, 2, y, z)
{x y}.integrate ((x, 0, 1))
\sqrt (a:b)
\sqrt[3] (a:b)
? ()
? (x)
? (x) (2)
? (2)
?f (x, y, real = True)
?\alpha(x)
?beta(y)
Function ('f', real = True) (x, y)
x'
x''
{x + y}'
a [b]'
a.b ()'
{x/y}'
1'['ac']
|x|'
| 'str'|'
{x**y}'
{{-1}'}
{a [b]}''
1.'''
x [1]
1 [x]
[1, 2] [x]
{1, 2} [x]
{x: 2} [x]
{y: 2} [x]
'}'
q w * e * {r * t} * y u {i * o} p {a {s * d} f}
x, y = 1, 2
x, 2 = 1, 2
(x, y) = 1, 2
1; x, y = 1, 2
1; x, 2 = 1, 2
1; (x, y) = 1, 2
f()()
f()*()
f*()*()
f*()()

dy / dx
dy / dx z
d**2 y / dx**2
d**2 y / dx**2 z
d**2 y / dx dy
d**2 y / dx dy z
\frac{dy}{dx}
\frac{dy}{dx} z
\frac{d**2}{dx**2}
\frac{d**2}{dx**2} z
\frac{d**2}{dx dy}
\frac{d**2}{dx dy} z
\frac{d**2 y}{dx dy}
\frac{d**2 y}{dx dy} z
\int dy / dx
\int d/dx x**2 dx
\int d/dx y(x) dx
\int dx dx dx
\int dx * dx dx
dlambda / dx : x
d**2 lambda / dx**2 : x
ln1.or
ln1. or
ln1 . or
a.b * c.d
a.b c.d
lambda x, y, z: ln lambda x:
lambda x, y, z: ln lambda x: 1

f (x) (0)
f (x, y) (0, 0)
f (x, y, z) (0, 0, 0)
f (x)' (0)
\. x+y |_{x = 1}
\. x+y |_{x = 1, y = 2}
\. x+y |_{x, y = 1, 2}
\. x+y |_{\substack{x = 1}}
\. x+y |_{\substack{x = 1 \\ y = 2}}
\. f(x) |_{f(x) = y}
\. f(x) f(y) |_{f(x), f(y) = y, z}
\. f(x) f(y) |_{f(x) = y, f(y) = z}
\. f(x) f(y) |_{\substack{f(x) = y \\ f(y) = z}}
\. ((1, 2) + (1, 2)) |_{(1,2,1,2) = (3,4)}

f (x)' (0)
d / dx (f (x)) (0)
d / dx (u (x, y)) (x, y)
d / dx (u (x, y)) (0, y)
d / dx (u (x, y)) (0, 0)
d**2 / dx dy (u (x, y)) (x, y)
d**2 / dx dy (u (x, y)) (0, y)
d**2 / dx dy (u (x, y)) (0, 0)
dsolve (y(x)'' + 11y(x)' + 24y(x), ics = {y(0): 0, y(x)'(0): -7})
\. [f(x)', g(y)'] |_{x = 0, y = 1}
\. [d / dx (f(x, y)), d / dx (g(y, x))] |_{x = 0, y = 1}
\. d**2 / dx dy (f(x, z)) |_{x = 1, y = 2, z = 3}
?() = 2
?f() = 2
d / dx (a) b
\frac{d}{dx} (a) b
sin (())
sin (((a))
a.b (())
a.b (((a))
@x
@(x + y)
@(x + y)
%x
%(x + y)
%%x
%%(x + y)
\[[1, 2, 3], [4, 5, 6]] [:, 1:]

N - N N 2
N N N 2
sin sin sin 2
-N sin -N 2
sin -N sin 2
N N sin -a [2]
N N sin -a.b [2]
N N sin -a.b () [2]
N N sin -a.b () [2] [3]
sin -N () [2] [3].c [4].d () [5]
sqrt -N () [2] [3].c [4].d () [5]
sqrt[3] -N () [2] [3].c [4].d () [5]
log -N () [2] [3].c [4].d () [5]
\log_2 -N () [2] [3].c [4].d () [5]
N sin**2 ln**2 N x
sin ln N x
sin(a)**[a][b].c
N sin N sin x
cos**-1 0 \log_2 8
N sin sqrt[3] \log_2 8
sin(x)**-a[b][c].d
sin sin x [2].w
sin -sin x [2].w
sin sin (x) [2].w
sin -sin (x) [2].w
sin sin x [2].w ()
ln ln x [2].w
N N sin -a [2]
sin sin -x [2].w
sin -sin x [2].w
sin(a)**b[2]
sin**-a[b][c].d x
sin**-a[b][c].d (x)
sin**-a[b][c].d {(x)}
sin**-a[b][c] (x)
\int**-a[b][c] x
\int**-a[b][c].d (x)
\int**-a[b][c].d {(x)}
\int**-a[b][c].d (x) y
\int**-a[b][c].d {(x)} y
\int**a.b[2] x dx

d/dx (real = True)
f {\left(x\right)}
a.b {(x)}
a.b {\left(x\right)}
\log_{|x|} y
|\int a + b dx|
\int deg N dx
a \int x dx / c
\int x dx b / c
a \int x dx b / c
a {\lim_{x\to0} \int x dx} / b
a {\sum_{x=0}^1 \int x dx} / b
a / \int x dx * c
a / b \int x dx * c

cos
f = cos
\[[0, pi], [-pi, 0]].applyfunc (cos)
$sin (real = True)
sin = $(real = True)

"""
# _EXPRESSIONS = r"""

if __name__ == '__main__':
	import os.path
	import subprocess
	import sys

	if len (sys.argv) == 1:
		subprocess.run ([sys.executable, '-m', 'unittest', '-v', os.path.basename (sys.argv [0])])
		subprocess.run ([sys.executable, '-m', 'unittest', '-v', os.path.abspath ('test_server.py')])
		sys.exit (0)

	exprs = [s.strip () for s in _EXPRESSIONS.strip ().split ('\n')]
	lines = []

	if sys.argv [1] == '--human':
		if len (sys.argv) == 2:
			func = ast2nat
		else:
			func = globals () [sys.argv [2]]

		for expr in exprs:
			if not expr.strip ():
				lines.append ('')

				continue

			lines.extend (['', expr])

			try:
				lines.append (str (func (p (expr))).replace ('\n', ''))
			except Exception as e:
				lines.append (f'{e.__class__.__name__}: {e.args [0]}')

		for line in lines:
			print (str (line))

	elif sys.argv [1] in {'--print', '--update'}:
		for func in (sparser, ast2tex, ast2nat, ast2py, ast2tex2ast, ast2nat2ast, ast2py2ast, ast2spt2ast):
			lines.extend (['', f'\tdef test_{func.__name__} (self):'])

			for expr in exprs:
				if not expr.strip ():
					lines.append ('')

					continue

				try:
					if func == sparser:
						lines.append (f'\t\tself.assertEqual (p ({expr!r}), ' + repr (p (expr)).replace ('\n', '') + ')')
					else:
						lines.append (f'\t\tself.assertEqual ({func.__name__} (p ({expr!r})), ' + repr (func (p (expr))).replace ('\n', '') + ')')

				except Exception as e:
					lines.append (f'\t\tself.assertRaises ({e.__class__.__name__}, {func.__name__}, p ({expr!r}))')

			if sys.argv [1] == '--print':
				for line in lines:
					print (line)

			else: # '--update'
				testpy = open ('test.py').readlines ()

				os.chmod ('test.py', 0o755)

				start  = testpy.index ('\t# BEGIN UPDATE BLOCK\n')
				end    = testpy.index ('\t# END UPDATE BLOCK\n')

				testpy [start + 1 : end] = (f'{line}\n' for line in lines [1:])

				open ('test.py', 'w', newline = '\n').writelines (testpy)