`module Addr : sig ... end`
`module Var : sig ... end`
`type cont = Addr.t * Var.t list`
`type prim =`

1. `| Vectlength`
2. `| Array_get`
3. `| Extern of string`
4. `| Not`
5. `| IsInt`
6. `| Eq`
7. `| Neq`
8. `| Lt`
9. `| Le`
10. `| Ult`

`type array_or_not =`

1. `| Array`
2. `| NotArray`
3. `| Unknown`

`module Native_string : sig ... end`
`type constant =`

1. `| String of string`
2. `| NativeString of Native_string.t`
3. `| Float of Stdlib.Int64.t`
4. `| Float32 of Stdlib.Int64.t`
5. `| Float_array of Stdlib.Int64.t array`
6. `| Int of Targetint.t`
7. `| Int32 of Stdlib.Int32.t`
   (*

   Only produced when compiling to WebAssembly.

   *)
8. `| Int64 of Stdlib.Int64.t`
9. `| NativeInt of Stdlib.Int32.t`
   (*

   Only produced when compiling to WebAssembly.

   *)
10. `| Tuple of int * constant array * array_or_not`
11. `| Null_`

`module Constant : sig ... end`
`type loc =`

1. `| No`
2. `| Before of Addr.t`
3. `| After of Addr.t`

`val noloc : loc`
`val location_of_pc : int -> loc`
`type prim_arg =`

1. `| Pv of Var.t`
2. `| Pc of constant`

`type special =`

1. `| Alias_prim of string`

`type mutability =`

1. `| Immutable`
2. `| Maybe_mutable`

`type field_type =`

1. `| Non_float`
2. `| Float`

`type expr =`

1. `| Apply of {`
   1. `f : Var.t;`
   2. `args : Var.t list;`
   3. `exact : bool;`
   `}`
2. `| Block of int * Var.t array * array_or_not * mutability`
3. `| Field of Var.t * int * field_type`
4. `| Closure of Var.t list * cont * Parse_info.t option`
5. `| Constant of constant`
6. `| Prim of prim * prim_arg list`
7. `| Special of special`

`type instr =`

1. `| Let of Var.t * expr`
2. `| Assign of Var.t * Var.t`
3. `| Set_field of Var.t * int * field_type * Var.t`
4. `| Offset_ref of Var.t * int`
5. `| Array_set of Var.t * Var.t * Var.t`
6. `| Event of Parse_info.t`

`type last =`

1. `| Return of Var.t`
2. `| Raise of Var.t * [ `Normal | `Notrace | `Reraise ]`
3. `| Stop`
4. `| Branch of cont`
5. `| Cond of Var.t * cont * cont`
6. `| Switch of Var.t * cont array`
7. `| Pushtrap of cont * Var.t * cont`
8. `| Poptrap of cont`

`type block = {`

1. `params : Var.t list;`
2. `body : instr list;`
3. `branch : last;`

`}`
`type program = {`

1. `start : Addr.t;`
2. `blocks : block Addr.Map.t;`
3. `free_pc : Addr.t;`

`}`
`module Print : sig ... end`
`type 'c fold_blocs = block Addr.Map.t -> Addr.t -> (Addr.t -> 'c -> 'c) -> 'c -> 'c`
`type fold_blocs_poly = {`

1. `fold : 'a. 'a fold_blocs;`

`}`
`val fold_closures : program -> (Var.t option -> Var.t list -> cont -> Parse_info.t option -> 'd -> 'd) -> 'd -> 'd`

`fold_closures p f init` folds `f` over all closures in the program `p`, starting from the initial value `init`. For each closure, `f` is called with the following arguments: the closure name (enclosed in `Stdlib.Some`), its parameter list, the address and parameter instantiation of its first block, the optional closure location and the current accumulator. In addition, `f` is called on the initial block `p.start`, with `None` as the closure name. All closures in all blocks of `p` are included in the fold, not only the ones reachable from `p.start`.

`val fold_closures_innermost_first : program -> (Var.t option -> Var.t list -> cont -> Parse_info.t option -> 'd -> 'd) -> 'd -> 'd`

Similar to `fold_closures`, but applies the fold function to the innermost closures first. Unlike with `fold_closures`, only the closures reachable from `p.start` are considered.

`val fold_closures_outermost_first : program -> (Var.t option -> Var.t list -> cont -> Parse_info.t option -> 'd -> 'd) -> 'd -> 'd`

Similar to `fold_closures`, but applies the fold function to the outermost closures first. Unlike with `fold_closures`, only the closures reachable from `p.start` are considered.

`val fold_children : 'c fold_blocs`
`val fold_children_skip_try_body : 'c fold_blocs`
`val poptraps : block Addr.Map.t -> Addr.t -> Addr.Set.t`
`val return_values : program -> Var.Set.t Var.Map.t`
`val traverse : fold_blocs_poly -> (Addr.t -> 'c -> 'c) -> Addr.t -> block Addr.Map.t -> 'c -> 'c`
`val preorder_traverse : fold_blocs_poly -> (Addr.t -> 'c -> 'c) -> Addr.t -> block Addr.Map.t -> 'c -> 'c`
`val last_instr : instr list -> instr option`

Last instruction of a block body, ignoring events

`val used_blocks : program -> Stdlib.BitSet.t`
`val prepend : program -> instr list -> program`
`val empty : program`
`val compact : program -> program`
`val is_empty : program -> bool`
`val equal : program -> program -> bool`
`val print_diff : program -> program -> unit`
`val check_updates : name:string -> program -> program -> updates:int -> unit`
`val invariant : program -> unit`
`val cont_equal : cont -> cont -> bool`
`val cont_compare : cont -> cont -> int`