// Syntax.java
// created by dataGen

abstract class Stm {
    public abstract <A> A accept (StmVisitor<A> v);
}

class CompoundStm extends Stm {
    public Stm stm1;
    public Stm stm2;
    public CompoundStm (Stm stm1, Stm stm2) {
        this.stm1 = stm1;
        this.stm2 = stm2;
    }
    public <A> A accept (StmVisitor<A> v) {
        return v.visit (this);
    }
}

class AssignStm extends Stm {
    public String id;
    public Exp exp;
    public AssignStm (String id, Exp exp) {
        this.id = id;
        this.exp = exp;
    }
    public <A> A accept (StmVisitor<A> v) {
        return v.visit (this);
    }
}

class PrintStm extends Stm {
    public ExpList exps;
    public PrintStm (ExpList exps) {
        this.exps = exps;
    }
    public <A> A accept (StmVisitor<A> v) {
        return v.visit (this);
    }
}

interface StmVisitor<A> {
    public A visit (CompoundStm s);
    public A visit (AssignStm s);
    public A visit (PrintStm s);
}

abstract class Exp {
    public abstract <A> A accept (ExpVisitor<A> v);
}

class IdExp extends Exp {
    public String id;
    public IdExp (String id) {
        this.id = id;
    }
    public <A> A accept (ExpVisitor<A> v) {
        return v.visit (this);
    }
}

class NumExp extends Exp {
    public int num;
    public NumExp (int num) {
        this.num = num;
    }
    public <A> A accept (ExpVisitor<A> v) {
        return v.visit (this);
    }
}

class OpExp extends Exp {
    public Exp left;
    public int op;
    public Exp right;
    public OpExp (Exp left, int op, Exp right) {
        this.left = left;
        this.op = op;
        this.right = right;
    }
    public <A> A accept (ExpVisitor<A> v) {
        return v.visit (this);
    }
}

class EseqExp extends Exp {
    public Stm stm;
    public Exp exp;
    public EseqExp (Stm stm, Exp exp) {
        this.stm = stm;
        this.exp = exp;
    }
    public <A> A accept (ExpVisitor<A> v) {
        return v.visit (this);
    }
}

interface ExpVisitor<A> {
    public A visit (IdExp e);
    public A visit (NumExp e);
    public A visit (OpExp e);
    public A visit (EseqExp e);
}

abstract class ExpList {
    public abstract <A> A accept (ExpListVisitor<A> v);
}

class PairExpList extends ExpList {
    public Exp head;
    public ExpList tail;
    public PairExpList (Exp head, ExpList tail) {
        this.head = head;
        this.tail = tail;
    }
    public <A> A accept (ExpListVisitor<A> v) {
        return v.visit (this);
    }
}

class LastExpList extends ExpList {
    public Exp head;
    public LastExpList (Exp head) {
        this.head = head;
    }
    public <A> A accept (ExpListVisitor<A> v) {
        return v.visit (this);
    }
}

interface ExpListVisitor<A> {
    public A visit (PairExpList e);
    public A visit (LastExpList e);
}