BitvectorEncoder

abstract val sourceProgram: Program

final def !=(arg0: Any): Boolean

final def ##(): Int

def <<(that: ProgramEncoder { val sourceProgram: inox.ast.ProgramEncoder.<refinement>.type }): ProgramEncoder { ... /* 2 definitions in type refinement */ }

final def ==(arg0: Any): Boolean

def >>(that: ProgramEncoder { val t: BitvectorEncoder.this.s.type }): ProgramEncoder { ... /* 2 definitions in type refinement */ }

def andThen(that: ProgramTransformer { val sourceProgram: inox.ast.ProgramEncoder.<refinement>.type }): ProgramTransformer { ... /* 2 definitions in type refinement */ }

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose(that: ProgramTransformer { val targetProgram: BitvectorEncoder.this.sourceProgram.type }): ProgramTransformer { ... /* 2 definitions in type refinement */ }

def decode(tpe: ast.Trees.Type): ast.Trees.Type

def decode(e: ast.Trees.Expr): ast.Trees.Expr

def decode(v: ast.Trees.Variable): ast.Trees.Variable

def decode(vd: ast.Trees.ValDef): ast.Trees.ValDef

object decoder extends ast.Trees.SelfTreeTransformer

def encode(tpe: ast.Trees.Type): ast.Trees.Type

def encode(e: ast.Trees.Expr): ast.Trees.Expr

def encode(v: ast.Trees.Variable): ast.Trees.Variable

def encode(vd: ast.Trees.ValDef): ast.Trees.ValDef

def encodedProgram: Program { val trees: BitvectorEncoder.this.t.type }

Override point for more complex program transformations

object encoder extends ast.Trees.SelfTreeTransformer

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val extraADTs: Seq[ast.Trees.ADTConstructor]

val extraFunctions: Seq[ast.Trees.FunDef]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reverse: ProgramTransformer { ... /* 2 definitions in type refinement */ }

final lazy val s: Program.trees.type

final def synchronized[T0](arg0: ⇒ T0): T0

val t: Program.trees.type

final lazy val targetProgram: Program { val trees: BitvectorEncoder.this.t.type }

def toString(): String

lazy val trees: Program.trees.type

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit