/* File generated from manager.idl */

#include <stddef.h>
#include <string.h>
#include <caml/mlvalues.h>
#include <caml/memory.h>
#include <caml/alloc.h>
#include <caml/fail.h>
#include <caml/callback.h>
#ifdef Custom_tag
#include <caml/custom.h>
#include <caml/bigarray.h>
#endif
#include <caml/camlidlruntime.h>


#include "caml/custom.h"
#include "cudd_caml.h"

#define camlidl_ml2c_manager_manager__t(v,c,ctx) manager_ml2c(v,c)

#define camlidl_c2ml_manager_manager__t(c,ctx) manager_c2ml(c)

int camlidl_transl_table_manager_enum_1[22] = {
  CUDD_REORDER_SAME,
  CUDD_REORDER_NONE,
  CUDD_REORDER_RANDOM,
  CUDD_REORDER_RANDOM_PIVOT,
  CUDD_REORDER_SIFT,
  CUDD_REORDER_SIFT_CONVERGE,
  CUDD_REORDER_SYMM_SIFT,
  CUDD_REORDER_SYMM_SIFT_CONV,
  CUDD_REORDER_WINDOW2,
  CUDD_REORDER_WINDOW3,
  CUDD_REORDER_WINDOW4,
  CUDD_REORDER_WINDOW2_CONV,
  CUDD_REORDER_WINDOW3_CONV,
  CUDD_REORDER_WINDOW4_CONV,
  CUDD_REORDER_GROUP_SIFT,
  CUDD_REORDER_GROUP_SIFT_CONV,
  CUDD_REORDER_ANNEALING,
  CUDD_REORDER_GENETIC,
  CUDD_REORDER_LINEAR,
  CUDD_REORDER_LINEAR_CONVERGE,
  CUDD_REORDER_LAZY_SIFT,
  CUDD_REORDER_EXACT,
};

int camlidl_ml2c_manager_enum_reorder(value _v1)
{
  int _c2;
  _c2 = camlidl_transl_table_manager_enum_1[Int_val(_v1)];
  return _c2;
}

value camlidl_c2ml_manager_enum_reorder(int _c1)
{
  value _v2;
  _v2 = camlidl_find_enum(_c1, camlidl_transl_table_manager_enum_1, 22, "enum reorder: bad enum reorder value");
  return _v2;
}

int camlidl_transl_table_manager_enum_2[10] = {
  CUDD_NO_CHECK,
  CUDD_GROUP_CHECK,
  CUDD_GROUP_CHECK2,
  CUDD_GROUP_CHECK3,
  CUDD_GROUP_CHECK4,
  CUDD_GROUP_CHECK5,
  CUDD_GROUP_CHECK6,
  CUDD_GROUP_CHECK7,
  CUDD_GROUP_CHECK8,
  CUDD_GROUP_CHECK9,
};

int camlidl_ml2c_manager_enum_aggregation(value _v1)
{
  int _c2;
  _c2 = camlidl_transl_table_manager_enum_2[Int_val(_v1)];
  return _c2;
}

value camlidl_c2ml_manager_enum_aggregation(int _c1)
{
  value _v2;
  _v2 = camlidl_find_enum(_c1, camlidl_transl_table_manager_enum_2, 10, "enum aggregation: bad enum aggregation value");
  return _v2;
}

int camlidl_transl_table_manager_enum_3[4] = {
  CUDD_LAZY_NONE,
  CUDD_LAZY_SOFT_GROUP,
  CUDD_LAZY_HARD_GROUP,
  CUDD_LAZY_UNGROUP,
};

int camlidl_ml2c_manager_enum_lazygroup(value _v1)
{
  int _c2;
  _c2 = camlidl_transl_table_manager_enum_3[Int_val(_v1)];
  return _c2;
}

value camlidl_c2ml_manager_enum_lazygroup(int _c1)
{
  value _v2;
  switch(_c1) {
  case CUDD_LAZY_NONE: _v2 = Val_int(0); break;
  case CUDD_LAZY_SOFT_GROUP: _v2 = Val_int(1); break;
  case CUDD_LAZY_HARD_GROUP: _v2 = Val_int(2); break;
  case CUDD_LAZY_UNGROUP: _v2 = Val_int(3); break;
  default: invalid_argument("enum lazygroup: bad enum lazygroup value");
  }
  return _v2;
}

int camlidl_transl_table_manager_enum_4[3] = {
  CUDD_VAR_PRIMARY_INPUT,
  CUDD_VAR_PRESENT_STATE,
  CUDD_VAR_NEXT_STATE,
};

int camlidl_ml2c_manager_enum_vartype(value _v1)
{
  int _c2;
  _c2 = camlidl_transl_table_manager_enum_4[Int_val(_v1)];
  return _c2;
}

value camlidl_c2ml_manager_enum_vartype(int _c1)
{
  value _v2;
  switch(_c1) {
  case CUDD_VAR_PRIMARY_INPUT: _v2 = Val_int(0); break;
  case CUDD_VAR_PRESENT_STATE: _v2 = Val_int(1); break;
  case CUDD_VAR_NEXT_STATE: _v2 = Val_int(2); break;
  default: invalid_argument("enum vartype: bad enum vartype value");
  }
  return _v2;
}

int camlidl_transl_table_manager_enum_5[2] = {
  MTR_DEFAULT,
  MTR_FIXED,
};

int camlidl_ml2c_manager_enum_mtr(value _v1)
{
  int _c2;
  _c2 = camlidl_transl_table_manager_enum_5[Int_val(_v1)];
  return _c2;
}

value camlidl_c2ml_manager_enum_mtr(int _c1)
{
  value _v2;
  switch(_c1) {
  case MTR_DEFAULT: _v2 = Val_int(0); break;
  case MTR_FIXED: _v2 = Val_int(1); break;
  default: invalid_argument("enum mtr: bad enum mtr value");
  }
  return _v2;
}

int camlidl_transl_table_manager_enum_6[6] = {
  CUDD_NO_ERROR,
  CUDD_MEMORY_OUT,
  CUDD_TOO_MANY_NODES,
  CUDD_MAX_MEM_EXCEEDED,
  CUDD_INVALID_ARG,
  CUDD_INTERNAL_ERROR,
};

int camlidl_ml2c_manager_enum_error(value _v1)
{
  int _c2;
  _c2 = camlidl_transl_table_manager_enum_6[Int_val(_v1)];
  return _c2;
}

value camlidl_c2ml_manager_enum_error(int _c1)
{
  value _v2;
  _v2 = camlidl_find_enum(_c1, camlidl_transl_table_manager_enum_6, 6, "enum error: bad enum error value");
  return _v2;
}

value camlidl_manager_make(
	value _v_numVars,
	value _v_numVarsZ,
	value _v_numSlots,
	value _v_cacheSize,
	value _v_maxMemory)
{
  unsigned int numVars; /*in*/
  unsigned int numVarsZ; /*in*/
  unsigned int numSlots; /*in*/
  unsigned int cacheSize; /*in*/
  unsigned long maxMemory; /*in*/
  manager__t _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  numVars = Int_val(_v_numVars);
  numVarsZ = Int_val(_v_numVarsZ);
  numSlots = Int_val(_v_numSlots);
  cacheSize = Int_val(_v_cacheSize);
  maxMemory = Long_val(_v_maxMemory);
  /* begin user-supplied calling sequence */
  if (numSlots==0) numSlots = CUDD_UNIQUE_SLOTS;
   if (cacheSize==0) cacheSize = CUDD_CACHE_SLOTS;
   _res = Cudd_Init(numVars, numVarsZ, numSlots, cacheSize, maxMemory);
   {
     int res;
     res = Cudd_AddHook(_res,camlidl_dd_garbage,CUDD_PRE_GC_HOOK);
     if (res!=1)
      failwith("Manager.make: unable to add the garbage collection hook");
     res = Cudd_AddHook(_res,camlidl_dd_reordering,CUDD_PRE_REORDERING_HOOK);
     if (res!=1)
      failwith("Manager.make: unable to add the reordering hook");
}

  /* end user-supplied calling sequence */
  _vres = camlidl_c2ml_manager_manager__t(&_res, _ctx);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_free(
	value _v_man)
{
  manager__t man; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
Cudd_Quit(man);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_debugcheck(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_DebugCheck(man);
 if (_res == CUDD_OUT_OF_MEM)
   failwith("Dd.debugcheck returned CUDD_OUT_OF_MEM");

  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_check_keys(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_CheckKeys(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_level_of_var(
	value _v_man,
	value _v_var)
{
  manager__t man; /*in*/
  int var; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  var = Int_val(_v_var);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadPerm(man,var);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_var_of_level(
	value _v_man,
	value _v_level)
{
  manager__t man; /*in*/
  int level; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  level = Int_val(_v_level);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadInvPerm(man,level);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_reduce_heap(
	value _v_man,
	value _v_heuristic,
	value _v_minsize)
{
  manager__t man; /*in*/
  int heuristic; /*in*/
  int minsize; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  heuristic = camlidl_ml2c_manager_enum_reorder(_v_heuristic);
  minsize = Int_val(_v_minsize);
  /* begin user-supplied calling sequence */
{
  int ok = Cudd_ReduceHeap(man,heuristic,minsize);
  if (ok==0) failwith("Manager.reduce_heap failed");
}
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_shuffle_heap(
	value _v_man,
	value _v_permut)
{
  manager__t man; /*in*/
  int *permut; /*in*/
  mlsize_t _c1;
  mlsize_t _c2;
  value _v3;
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  _c1 = Wosize_val(_v_permut);
  permut = camlidl_malloc(_c1 * sizeof(int ), _ctx);
  for (_c2 = 0; _c2 < _c1; _c2++) {
    _v3 = Field(_v_permut, _c2);
    permut[_c2] = Int_val(_v3);
  }
  /* begin user-supplied calling sequence */
{
  int ok = Cudd_ShuffleHeap(man,permut);
  if (ok==0) failwith("Manager.shuffle_heap failed");
}
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_enable_autodyn(
	value _v_man,
	value _v_heuristic)
{
  manager__t man; /*in*/
  int heuristic; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  heuristic = camlidl_ml2c_manager_enum_reorder(_v_heuristic);
  /* begin user-supplied calling sequence */
Cudd_AutodynEnable(man,heuristic);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_disable_autodyn(
	value _v_man)
{
  manager__t man; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
Cudd_AutodynDisable(man);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_autodyn_status(
	value _v_man)
{
  manager__t man; /*in*/
  int *heuristic; /*out*/
  int _res;
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  int _c1;
  value _vresult;
  value _vres[2] = { 0, 0, };

  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  heuristic = &_c1;
  /* begin user-supplied calling sequence */
_res = Cudd_ReorderingStatus(man,(Cudd_ReorderingType*)heuristic);
  /* end user-supplied calling sequence */
  Begin_roots_block(_vres, 2)
    _vres[0] = Val_int(_res);
    _vres[1] = camlidl_c2ml_manager_enum_reorder(*heuristic);
    _vresult = camlidl_alloc_small(2, 0);
    Field(_vresult, 0) = _vres[0];
    Field(_vresult, 1) = _vres[1];
  End_roots()
  camlidl_free(_ctx);
  return _vresult;
}

value camlidl_manager_group(
	value _v_man,
	value _v_low,
	value _v_size,
	value _v_type)
{
  manager__t man; /*in*/
  int low; /*in*/
  int size; /*in*/
  int type; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  low = Int_val(_v_low);
  size = Int_val(_v_size);
  type = camlidl_ml2c_manager_enum_mtr(_v_type);
  /* begin user-supplied calling sequence */
Cudd_MakeTreeNode(man, low, size, type);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_set_varmap(
	value _v_man,
	value _v_permut)
{
  manager__t man; /*in*/
  int *permut; /*in*/
  int size; /*in*/
  mlsize_t _c1;
  mlsize_t _c2;
  value _v3;
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  _c1 = Wosize_val(_v_permut);
  permut = camlidl_malloc(_c1 * sizeof(int ), _ctx);
  for (_c2 = 0; _c2 < _c1; _c2++) {
    _v3 = Field(_v_permut, _c2);
    permut[_c2] = Int_val(_v3);
  }
  size = _c1;
  /* begin user-supplied calling sequence */
{
  int ok = Cuddaux_SetVarMap(man,permut);
  if (ok==0) failwith("Manager.set_varmap failed");
}
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_background(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
{
  DdNode* add = Cudd_ReadBackground(man);
  _res = cuddV(add);
}
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_background(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  double v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Double_val(_v_v);
  /* begin user-supplied calling sequence */
{
  DdNode* add = Cudd_addConst(man,v);
  cuddRef(add);
  Cudd_SetBackground(man,add);
}
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_epsilon(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadEpsilon(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_epsilon(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  double v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Double_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetEpsilon(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_min_hit(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMinHit(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_min_hit(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetMinHit(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_max_cache_hard(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMaxCacheHard(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_max_cache_hard(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetMaxCacheHard(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_looseupto(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadLooseUpTo(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_looseupto(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetLooseUpTo(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_max_live(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMaxLive(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_max_live(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetMaxLive(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_max_mem(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMaxMemory(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_max_mem(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetMaxMemory(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_sift_max_swap(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadSiftMaxSwap(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_sift_max_swap(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetSiftMaxSwap(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_sift_max_var(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadSiftMaxVar(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_sift_max_var(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetSiftMaxVar(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_groupcheck(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadGroupcheck(man);
  /* end user-supplied calling sequence */
  _vres = camlidl_c2ml_manager_enum_aggregation(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_groupcheck(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = camlidl_ml2c_manager_enum_aggregation(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetGroupcheck(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_arcviolation(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadArcviolation(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_arcviolation(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetArcviolation(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_crossovers(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadNumberXovers(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_crossovers(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetNumberXovers(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_population(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadPopulationSize(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_population(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetPopulationSize(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_recomb(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadRecomb(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_recomb(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetRecomb(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_symmviolation(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadSymmviolation(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_symmviolation(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetSymmviolation(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_max_growth(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMaxGrowth(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_max_growth(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetMaxGrowth(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_max_growth_alt(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMaxGrowthAlternate(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_max_growth_alt(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  double v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Double_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetMaxGrowthAlternate(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_reordering_cycle(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadReorderingCycle(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_reordering_cycle(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetReorderingCycle(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_next_autodyn(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadNextReordering(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_set_next_autodyn(
	value _v_man,
	value _v_v)
{
  manager__t man; /*in*/
  int v; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  v = Int_val(_v_v);
  /* begin user-supplied calling sequence */
Cudd_SetNextReordering(man,v);
  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}

value camlidl_manager_get_cache_hits(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadCacheHits(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_cache_lookups(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadCacheLookUps(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_cache_slots(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadCacheSlots(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_cache_used_slots(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadCacheUsedSlots(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_dead(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadDead(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_error(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadErrorCode(man);
  /* end user-supplied calling sequence */
  _vres = camlidl_c2ml_manager_enum_error(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_gc_time(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadGarbageCollectionTime(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_gc_nb(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadGarbageCollections(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_keys(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadKeys(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_linear(
	value _v_man,
	value _v_x,
	value _v_y)
{
  manager__t man; /*in*/
  int x; /*in*/
  int y; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  x = Int_val(_v_x);
  y = Int_val(_v_y);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadLinear(man,x,y);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_max_cache(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMaxCache(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_min_dead(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadMinDead(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_node_count(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadNodeCount(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_node_count_peak(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadPeakNodeCount(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_reordering_time(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadReorderingTime(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_reordering_nb(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadReorderings(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_bddvar_nb(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadSize(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_zddvar_nb(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadZddSize(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_slots(
	value _v_man)
{
  manager__t man; /*in*/
  int _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadSlots(man);
  /* end user-supplied calling sequence */
  _vres = Val_int(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_used_slots(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadUsedSlots(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_get_swap_nb(
	value _v_man)
{
  manager__t man; /*in*/
  double _res;
  value _vres;

  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
_res = Cudd_ReadSwapSteps(man);
  /* end user-supplied calling sequence */
  _vres = copy_double(_res);
  camlidl_free(_ctx);
  return _vres;
}

value camlidl_manager_print_info(
	value _v_man)
{
  manager__t man; /*in*/
  struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL };
  camlidl_ctx _ctx = &_ctxs;
  camlidl_ml2c_manager_manager__t(_v_man, &man, _ctx);
  /* begin user-supplied calling sequence */
  fflush(stdout);
   Cudd_PrintInfo(man,stdout);
   fflush(stdout);

  /* end user-supplied calling sequence */
  camlidl_free(_ctx);
  return Val_unit;
}