class Node(object):
    pass

class Program(Node):
    def __init__(self, functions, lineno = None):
        self.functions = functions
        self.lineno = lineno

class Function(Node):
    def __init__(self, name, params, statements, lineno = None):
        self.name = name
        self.params = params
        self.statements = statements
        self.lineno = lineno

    def __repr__(self):
        return "<Function: %s at line %d>" % (name, lineno)

class Statement(Node):
    pass

class IfStatement(Statement):
    def __init__(self, expression, true_statements, false_statements, lineno = None):
        self.expression = expression
        self.true_statements = true_statements
        self.false_statements = false_statements
        self.lineno = lineno

    def __repr__(self):
        return "<IfStatement at line %d>" % lineno

class WhileStatement(Statement):
    def __init__(self, expression, statements, lineno = None):
        self.expression = expression
        self.statements = statements
        self.lineno = lineno

    def __repr__(self):
        return "<WhileStatement at line %d>" % lineno

class ReturnStatement(Statement):
    def __init__(self, expression, lineno = None):
        self.expression = expression
        self.lineno = lineno

    def __repr__(self):
        return "<ReturnStatement at line %d>" % lineno

class AssignStatement(Statement):
    def __init__(self, ident, expression, lineno = None):
        self.ident = ident
        self.expression = expression
        self.lineno = lineno

    def __repr__(self):
        return "<AssignStatement for %s at line %d>" % (ident, lineno)

class FunctionCall(Statement):
    def __init__(self, ident, arguments, lineno = None):
        self.ident = ident
        self.arguments = arguments
        self.lineno = lineno

    def __repr__(self):
        return "<FunctionCall for %s at line %d>" % (ident, lineno)

class Expression(Node):
    pass

class UnaryExpression(Expression):
    def __init__(self, op, right, lineno = None):
        self.op = op
        self.right = right
        self.lineno = lineno

    def __repr__(self):
        return "<UnaryExpression: %s(%s) at line %d>" % (op, right, lineno)

class BinaryExpression(Expression):
    def __init__(self, left, op, right, lineno = None):
        self.left = left
        self.op = op
        self.right = right
        self.lineno = lineno

    def __repr__(self):
        return "<BinaryExpression: %s(%s, %s) at line %d>" % (op, left, right, lineno)