# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.10
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_opt')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_opt')
    _opt = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_opt', [dirname(__file__)])
        except ImportError:
            import _opt
            return _opt
        if fp is not None:
            try:
                _mod = imp.load_module('_opt', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _opt = swig_import_helper()
    del swig_import_helper
else:
    import _opt
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

PRIuPTR = _opt.PRIuPTR
PRIdPTR = _opt.PRIdPTR
LLU = _opt.LLU
LLO = _opt.LLO
LLX = _opt.LLX
false = _opt.false
true = _opt.true
OUTCOME_GENERIC_ERROR = _opt.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _opt.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _opt.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _opt.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _opt.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _opt.OUTCOME_SUCCESS
DEFAULT_OUTPUT_ORDER_FILE = _opt.DEFAULT_OUTPUT_ORDER_FILE
DEFAULT_CONJ_PART_THRESHOLD = _opt.DEFAULT_CONJ_PART_THRESHOLD
DEFAULT_IMAGE_CLUSTER_SIZE = _opt.DEFAULT_IMAGE_CLUSTER_SIZE
DEFAULT_SHOWN_STATES = _opt.DEFAULT_SHOWN_STATES
MAX_SHOWN_STATES = _opt.MAX_SHOWN_STATES
OPT_USER_POV_NULL_STRING = _opt.OPT_USER_POV_NULL_STRING
FORWARD = _opt.FORWARD
BACKWARD = _opt.BACKWARD
FORWARD_BACKWARD = _opt.FORWARD_BACKWARD
BDD_BMC = _opt.BDD_BMC
ZIGZAG_HEURISTIC = _opt.ZIGZAG_HEURISTIC
SMALLEST_BDD_HEURISTIC = _opt.SMALLEST_BDD_HEURISTIC
STEPS_HEURISTIC = _opt.STEPS_HEURISTIC
SIZE_HEURISTIC = _opt.SIZE_HEURISTIC
DEFAULT_DAGGIFIER_COUNTER_THS = _opt.DEFAULT_DAGGIFIER_COUNTER_THS
DEFAULT_DAGGIFIER_DEPTH_THS = _opt.DEFAULT_DAGGIFIER_DEPTH_THS
DEFAULT_BDD2BMC_HEURISTIC_THRESHOLD = _opt.DEFAULT_BDD2BMC_HEURISTIC_THRESHOLD

def set_use_reachable_states(arg1: 'OptsHandler_ptr') -> "void":
    """set_use_reachable_states(OptsHandler_ptr arg1)"""
    return _opt.set_use_reachable_states(arg1)

def unset_use_reachable_states(arg1: 'OptsHandler_ptr') -> "void":
    """unset_use_reachable_states(OptsHandler_ptr arg1)"""
    return _opt.unset_use_reachable_states(arg1)

def opt_use_reachable_states(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_use_reachable_states(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_use_reachable_states(arg1)

def set_use_fair_states(arg1: 'OptsHandler_ptr') -> "void":
    """set_use_fair_states(OptsHandler_ptr arg1)"""
    return _opt.set_use_fair_states(arg1)

def unset_use_fair_states(arg1: 'OptsHandler_ptr') -> "void":
    """unset_use_fair_states(OptsHandler_ptr arg1)"""
    return _opt.unset_use_fair_states(arg1)

def opt_use_fair_states(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_use_fair_states(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_use_fair_states(arg1)

def init_options() -> "void":
    """init_options()"""
    return _opt.init_options()

def deinit_options() -> "void":
    """deinit_options()"""
    return _opt.deinit_options()

def init_options_cmd() -> "void":
    """init_options_cmd()"""
    return _opt.init_options_cmd()

def set_pgm_name(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_pgm_name(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_pgm_name(arg1, arg2)

def reset_pgm_name(arg1: 'OptsHandler_ptr') -> "void":
    """reset_pgm_name(OptsHandler_ptr arg1)"""
    return _opt.reset_pgm_name(arg1)

def get_pgm_name(arg1: 'OptsHandler_ptr') -> "char *":
    """get_pgm_name(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_pgm_name(arg1)

def set_script_file(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_script_file(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_script_file(arg1, arg2)

def reset_script_file(arg1: 'OptsHandler_ptr') -> "void":
    """reset_script_file(OptsHandler_ptr arg1)"""
    return _opt.reset_script_file(arg1)

def get_script_file(arg1: 'OptsHandler_ptr') -> "char *":
    """get_script_file(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_script_file(arg1)

def set_pgm_path(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_pgm_path(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_pgm_path(arg1, arg2)

def reset_pgm_path(arg1: 'OptsHandler_ptr') -> "void":
    """reset_pgm_path(OptsHandler_ptr arg1)"""
    return _opt.reset_pgm_path(arg1)

def get_pgm_path(arg1: 'OptsHandler_ptr') -> "char *":
    """get_pgm_path(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_pgm_path(arg1)

def set_input_file(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_input_file(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_input_file(arg1, arg2)

def reset_input_file(arg1: 'OptsHandler_ptr') -> "void":
    """reset_input_file(OptsHandler_ptr arg1)"""
    return _opt.reset_input_file(arg1)

def get_input_file(arg1: 'OptsHandler_ptr') -> "char *":
    """get_input_file(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_input_file(arg1)

def set_input_order_file(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_input_order_file(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_input_order_file(arg1, arg2)

def reset_input_order_file(arg1: 'OptsHandler_ptr') -> "void":
    """reset_input_order_file(OptsHandler_ptr arg1)"""
    return _opt.reset_input_order_file(arg1)

def get_input_order_file(arg1: 'OptsHandler_ptr') -> "char *":
    """get_input_order_file(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_input_order_file(arg1)

def set_output_order_file(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_output_order_file(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_output_order_file(arg1, arg2)

def reset_output_order_file(arg1: 'OptsHandler_ptr') -> "void":
    """reset_output_order_file(OptsHandler_ptr arg1)"""
    return _opt.reset_output_order_file(arg1)

def get_output_order_file(arg1: 'OptsHandler_ptr') -> "char *":
    """get_output_order_file(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_output_order_file(arg1)

def is_default_order_file(opt: 'OptsHandler_ptr') -> "boolean":
    """is_default_order_file(OptsHandler_ptr opt) -> boolean"""
    return _opt.is_default_order_file(opt)

def set_trans_order_file(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_trans_order_file(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_trans_order_file(arg1, arg2)

def reset_trans_order_file(arg1: 'OptsHandler_ptr') -> "void":
    """reset_trans_order_file(OptsHandler_ptr arg1)"""
    return _opt.reset_trans_order_file(arg1)

def get_trans_order_file(arg1: 'OptsHandler_ptr') -> "char *":
    """get_trans_order_file(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_trans_order_file(arg1)

def opt_trans_order_file(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_trans_order_file(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_trans_order_file(arg1)

def set_output_flatten_model_file(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_output_flatten_model_file(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_output_flatten_model_file(arg1, arg2)

def reset_output_flatten_model_file(arg1: 'OptsHandler_ptr') -> "void":
    """reset_output_flatten_model_file(OptsHandler_ptr arg1)"""
    return _opt.reset_output_flatten_model_file(arg1)

def get_output_flatten_model_file(arg1: 'OptsHandler_ptr') -> "char *":
    """get_output_flatten_model_file(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_output_flatten_model_file(arg1)

def set_output_boolean_model_file(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_output_boolean_model_file(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_output_boolean_model_file(arg1, arg2)

def reset_output_boolean_model_file(arg1: 'OptsHandler_ptr') -> "void":
    """reset_output_boolean_model_file(OptsHandler_ptr arg1)"""
    return _opt.reset_output_boolean_model_file(arg1)

def get_output_boolean_model_file(arg1: 'OptsHandler_ptr') -> "char *":
    """get_output_boolean_model_file(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_output_boolean_model_file(arg1)

def set_output_word_format(arg1: 'OptsHandler_ptr', i: 'int') -> "void":
    """set_output_word_format(OptsHandler_ptr arg1, int i)"""
    return _opt.set_output_word_format(arg1, i)

def get_output_word_format(arg1: 'OptsHandler_ptr') -> "int":
    """get_output_word_format(OptsHandler_ptr arg1) -> int"""
    return _opt.get_output_word_format(arg1)

def set_backward_comp(arg1: 'OptsHandler_ptr') -> "void":
    """set_backward_comp(OptsHandler_ptr arg1)"""
    return _opt.set_backward_comp(arg1)

def unset_backward_comp(arg1: 'OptsHandler_ptr') -> "void":
    """unset_backward_comp(OptsHandler_ptr arg1)"""
    return _opt.unset_backward_comp(arg1)

def opt_backward_comp(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_backward_comp(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_backward_comp(arg1)

def set_type_checking_warning_on(arg1: 'OptsHandler_ptr') -> "void":
    """set_type_checking_warning_on(OptsHandler_ptr arg1)"""
    return _opt.set_type_checking_warning_on(arg1)

def unset_type_checking_warning_on(arg1: 'OptsHandler_ptr') -> "void":
    """unset_type_checking_warning_on(OptsHandler_ptr arg1)"""
    return _opt.unset_type_checking_warning_on(arg1)

def opt_type_checking_warning_on(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_type_checking_warning_on(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_type_checking_warning_on(arg1)

def set_verbose_level(arg1: 'OptsHandler_ptr', arg2: 'int') -> "void":
    """set_verbose_level(OptsHandler_ptr arg1, int arg2)"""
    return _opt.set_verbose_level(arg1, arg2)

def get_verbose_level(arg1: 'OptsHandler_ptr') -> "int":
    """get_verbose_level(OptsHandler_ptr arg1) -> int"""
    return _opt.get_verbose_level(arg1)

def opt_verbose_level_eq(arg1: 'OptsHandler_ptr', arg2: 'int') -> "boolean":
    """opt_verbose_level_eq(OptsHandler_ptr arg1, int arg2) -> boolean"""
    return _opt.opt_verbose_level_eq(arg1, arg2)

def opt_verbose_level_gt(arg1: 'OptsHandler_ptr', arg2: 'int') -> "boolean":
    """opt_verbose_level_gt(OptsHandler_ptr arg1, int arg2) -> boolean"""
    return _opt.opt_verbose_level_gt(arg1, arg2)

def opt_verbose_level_ge(arg1: 'OptsHandler_ptr', arg2: 'int') -> "boolean":
    """opt_verbose_level_ge(OptsHandler_ptr arg1, int arg2) -> boolean"""
    return _opt.opt_verbose_level_ge(arg1, arg2)

def opt_verbose_level_lt(arg1: 'OptsHandler_ptr', arg2: 'int') -> "boolean":
    """opt_verbose_level_lt(OptsHandler_ptr arg1, int arg2) -> boolean"""
    return _opt.opt_verbose_level_lt(arg1, arg2)

def opt_verbose_level_le(arg1: 'OptsHandler_ptr', arg2: 'int') -> "boolean":
    """opt_verbose_level_le(OptsHandler_ptr arg1, int arg2) -> boolean"""
    return _opt.opt_verbose_level_le(arg1, arg2)

def set_pp_list(arg1: 'OptsHandler_ptr', arg2: 'char *') -> "void":
    """set_pp_list(OptsHandler_ptr arg1, char * arg2)"""
    return _opt.set_pp_list(arg1, arg2)

def get_pp_list(arg1: 'OptsHandler_ptr') -> "char *":
    """get_pp_list(OptsHandler_ptr arg1) -> char *"""
    return _opt.get_pp_list(arg1)

def set_shown_states_level(arg1: 'OptsHandler_ptr', arg2: 'int') -> "void":
    """set_shown_states_level(OptsHandler_ptr arg1, int arg2)"""
    return _opt.set_shown_states_level(arg1, arg2)

def opt_shown_states_level(arg1: 'OptsHandler_ptr') -> "int":
    """opt_shown_states_level(OptsHandler_ptr arg1) -> int"""
    return _opt.opt_shown_states_level(arg1)

def set_ignore_spec(arg1: 'OptsHandler_ptr') -> "void":
    """set_ignore_spec(OptsHandler_ptr arg1)"""
    return _opt.set_ignore_spec(arg1)

def unset_ignore_spec(arg1: 'OptsHandler_ptr') -> "void":
    """unset_ignore_spec(OptsHandler_ptr arg1)"""
    return _opt.unset_ignore_spec(arg1)

def opt_ignore_spec(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_ignore_spec(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_ignore_spec(arg1)

def set_ignore_compute(arg1: 'OptsHandler_ptr') -> "void":
    """set_ignore_compute(OptsHandler_ptr arg1)"""
    return _opt.set_ignore_compute(arg1)

def unset_ignore_compute(arg1: 'OptsHandler_ptr') -> "void":
    """unset_ignore_compute(OptsHandler_ptr arg1)"""
    return _opt.unset_ignore_compute(arg1)

def opt_ignore_compute(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_ignore_compute(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_ignore_compute(arg1)

def set_ignore_ltlspec(arg1: 'OptsHandler_ptr') -> "void":
    """set_ignore_ltlspec(OptsHandler_ptr arg1)"""
    return _opt.set_ignore_ltlspec(arg1)

def unset_ignore_ltlspec(arg1: 'OptsHandler_ptr') -> "void":
    """unset_ignore_ltlspec(OptsHandler_ptr arg1)"""
    return _opt.unset_ignore_ltlspec(arg1)

def opt_ignore_ltlspec(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_ignore_ltlspec(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_ignore_ltlspec(arg1)

def set_ignore_pslspec(arg1: 'OptsHandler_ptr') -> "void":
    """set_ignore_pslspec(OptsHandler_ptr arg1)"""
    return _opt.set_ignore_pslspec(arg1)

def unset_ignore_pslspec(arg1: 'OptsHandler_ptr') -> "void":
    """unset_ignore_pslspec(OptsHandler_ptr arg1)"""
    return _opt.unset_ignore_pslspec(arg1)

def opt_ignore_pslspec(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_ignore_pslspec(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_ignore_pslspec(arg1)

def set_check_fsm(arg1: 'OptsHandler_ptr') -> "void":
    """set_check_fsm(OptsHandler_ptr arg1)"""
    return _opt.set_check_fsm(arg1)

def unset_check_fsm(arg1: 'OptsHandler_ptr') -> "void":
    """unset_check_fsm(OptsHandler_ptr arg1)"""
    return _opt.unset_check_fsm(arg1)

def opt_check_fsm(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_check_fsm(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_check_fsm(arg1)

def set_ignore_invar(arg1: 'OptsHandler_ptr') -> "void":
    """set_ignore_invar(OptsHandler_ptr arg1)"""
    return _opt.set_ignore_invar(arg1)

def unset_ignore_invar(arg1: 'OptsHandler_ptr') -> "void":
    """unset_ignore_invar(OptsHandler_ptr arg1)"""
    return _opt.unset_ignore_invar(arg1)

def opt_ignore_invar(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_ignore_invar(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_ignore_invar(arg1)

def set_forward_search(arg1: 'OptsHandler_ptr') -> "void":
    """set_forward_search(OptsHandler_ptr arg1)"""
    return _opt.set_forward_search(arg1)

def unset_forward_search(arg1: 'OptsHandler_ptr') -> "void":
    """unset_forward_search(OptsHandler_ptr arg1)"""
    return _opt.unset_forward_search(arg1)

def opt_forward_search(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_forward_search(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_forward_search(arg1)

def set_ltl_tableau_forward_search(opt: 'OptsHandler_ptr') -> "void":
    """set_ltl_tableau_forward_search(OptsHandler_ptr opt)"""
    return _opt.set_ltl_tableau_forward_search(opt)

def unset_ltl_tableau_forward_search(opt: 'OptsHandler_ptr') -> "void":
    """unset_ltl_tableau_forward_search(OptsHandler_ptr opt)"""
    return _opt.unset_ltl_tableau_forward_search(opt)

def opt_ltl_tableau_forward_search(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_ltl_tableau_forward_search(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_ltl_tableau_forward_search(opt)

def set_print_reachable(arg1: 'OptsHandler_ptr') -> "void":
    """set_print_reachable(OptsHandler_ptr arg1)"""
    return _opt.set_print_reachable(arg1)

def unset_print_reachable(arg1: 'OptsHandler_ptr') -> "void":
    """unset_print_reachable(OptsHandler_ptr arg1)"""
    return _opt.unset_print_reachable(arg1)

def opt_print_reachable(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_print_reachable(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_print_reachable(arg1)

def set_reorder(arg1: 'OptsHandler_ptr') -> "void":
    """set_reorder(OptsHandler_ptr arg1)"""
    return _opt.set_reorder(arg1)

def unset_reorder(arg1: 'OptsHandler_ptr') -> "void":
    """unset_reorder(OptsHandler_ptr arg1)"""
    return _opt.unset_reorder(arg1)

def opt_reorder(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_reorder(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_reorder(arg1)

def set_reorder_method(arg1: 'OptsHandler_ptr', arg2: 'unsigned int') -> "void":
    """set_reorder_method(OptsHandler_ptr arg1, unsigned int arg2)"""
    return _opt.set_reorder_method(arg1, arg2)

def get_reorder_method(arg1: 'OptsHandler_ptr') -> "unsigned int":
    """get_reorder_method(OptsHandler_ptr arg1) -> unsigned int"""
    return _opt.get_reorder_method(arg1)

def set_dynamic_reorder(arg1: 'OptsHandler_ptr') -> "void":
    """set_dynamic_reorder(OptsHandler_ptr arg1)"""
    return _opt.set_dynamic_reorder(arg1)

def unset_dynamic_reorder(arg1: 'OptsHandler_ptr') -> "void":
    """unset_dynamic_reorder(OptsHandler_ptr arg1)"""
    return _opt.unset_dynamic_reorder(arg1)

def opt_dynamic_reorder(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_dynamic_reorder(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_dynamic_reorder(arg1)

def set_enable_sexp2bdd_caching(arg1: 'OptsHandler_ptr') -> "void":
    """set_enable_sexp2bdd_caching(OptsHandler_ptr arg1)"""
    return _opt.set_enable_sexp2bdd_caching(arg1)

def unset_enable_sexp2bdd_caching(arg1: 'OptsHandler_ptr') -> "void":
    """unset_enable_sexp2bdd_caching(OptsHandler_ptr arg1)"""
    return _opt.unset_enable_sexp2bdd_caching(arg1)

def opt_enable_sexp2bdd_caching(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_enable_sexp2bdd_caching(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_enable_sexp2bdd_caching(arg1)

def set_batch(arg1: 'OptsHandler_ptr') -> "void":
    """set_batch(OptsHandler_ptr arg1)"""
    return _opt.set_batch(arg1)

def unset_batch(arg1: 'OptsHandler_ptr') -> "void":
    """unset_batch(OptsHandler_ptr arg1)"""
    return _opt.unset_batch(arg1)

def opt_batch(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_batch(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_batch(arg1)

def set_partition_method(arg1: 'OptsHandler_ptr', arg2: 'TransType const') -> "void":
    """set_partition_method(OptsHandler_ptr arg1, TransType const arg2)"""
    return _opt.set_partition_method(arg1, arg2)

def get_partition_method(opt: 'OptsHandler_ptr') -> "TransType":
    """get_partition_method(OptsHandler_ptr opt) -> TransType"""
    return _opt.get_partition_method(opt)

def reset_partitioning_method(arg1: 'OptsHandler_ptr') -> "void":
    """reset_partitioning_method(OptsHandler_ptr arg1)"""
    return _opt.reset_partitioning_method(arg1)

def set_monolithic(arg1: 'OptsHandler_ptr') -> "void":
    """set_monolithic(OptsHandler_ptr arg1)"""
    return _opt.set_monolithic(arg1)

def set_conj_partitioning(arg1: 'OptsHandler_ptr') -> "void":
    """set_conj_partitioning(OptsHandler_ptr arg1)"""
    return _opt.set_conj_partitioning(arg1)

def set_iwls95cp_partitioning(arg1: 'OptsHandler_ptr') -> "void":
    """set_iwls95cp_partitioning(OptsHandler_ptr arg1)"""
    return _opt.set_iwls95cp_partitioning(arg1)

def opt_monolithic(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_monolithic(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_monolithic(arg1)

def opt_conj_partitioning(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_conj_partitioning(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_conj_partitioning(arg1)

def opt_iwls95cp_partitioning(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_iwls95cp_partitioning(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_iwls95cp_partitioning(arg1)

def set_conj_part_threshold(arg1: 'OptsHandler_ptr', arg2: 'int') -> "void":
    """set_conj_part_threshold(OptsHandler_ptr arg1, int arg2)"""
    return _opt.set_conj_part_threshold(arg1, arg2)

def reset_conj_part_threshold(arg1: 'OptsHandler_ptr') -> "void":
    """reset_conj_part_threshold(OptsHandler_ptr arg1)"""
    return _opt.reset_conj_part_threshold(arg1)

def get_conj_part_threshold(arg1: 'OptsHandler_ptr') -> "int":
    """get_conj_part_threshold(OptsHandler_ptr arg1) -> int"""
    return _opt.get_conj_part_threshold(arg1)

def set_image_cluster_size(arg1: 'OptsHandler_ptr', arg2: 'int') -> "void":
    """set_image_cluster_size(OptsHandler_ptr arg1, int arg2)"""
    return _opt.set_image_cluster_size(arg1, arg2)

def reset_image_cluster_size(arg1: 'OptsHandler_ptr') -> "void":
    """reset_image_cluster_size(OptsHandler_ptr arg1)"""
    return _opt.reset_image_cluster_size(arg1)

def get_image_cluster_size(arg1: 'OptsHandler_ptr') -> "int":
    """get_image_cluster_size(OptsHandler_ptr arg1) -> int"""
    return _opt.get_image_cluster_size(arg1)

def set_ignore_init_file(arg1: 'OptsHandler_ptr') -> "void":
    """set_ignore_init_file(OptsHandler_ptr arg1)"""
    return _opt.set_ignore_init_file(arg1)

def unset_ignore_init_file(arg1: 'OptsHandler_ptr') -> "void":
    """unset_ignore_init_file(OptsHandler_ptr arg1)"""
    return _opt.unset_ignore_init_file(arg1)

def opt_ignore_init_file(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_ignore_init_file(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_ignore_init_file(arg1)

def set_ag_only(arg1: 'OptsHandler_ptr') -> "void":
    """set_ag_only(OptsHandler_ptr arg1)"""
    return _opt.set_ag_only(arg1)

def unset_ag_only(arg1: 'OptsHandler_ptr') -> "void":
    """unset_ag_only(OptsHandler_ptr arg1)"""
    return _opt.unset_ag_only(arg1)

def opt_ag_only(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_ag_only(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_ag_only(arg1)

def set_cone_of_influence(arg1: 'OptsHandler_ptr') -> "void":
    """set_cone_of_influence(OptsHandler_ptr arg1)"""
    return _opt.set_cone_of_influence(arg1)

def unset_cone_of_influence(arg1: 'OptsHandler_ptr') -> "void":
    """unset_cone_of_influence(OptsHandler_ptr arg1)"""
    return _opt.unset_cone_of_influence(arg1)

def opt_cone_of_influence(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_cone_of_influence(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_cone_of_influence(arg1)

def set_list_properties(arg1: 'OptsHandler_ptr') -> "void":
    """set_list_properties(OptsHandler_ptr arg1)"""
    return _opt.set_list_properties(arg1)

def unset_list_properties(arg1: 'OptsHandler_ptr') -> "void":
    """unset_list_properties(OptsHandler_ptr arg1)"""
    return _opt.unset_list_properties(arg1)

def opt_list_properties(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_list_properties(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_list_properties(arg1)

def set_prop_print_method(opt: 'OptsHandler_ptr', threshold: 'int') -> "void":
    """set_prop_print_method(OptsHandler_ptr opt, int threshold)"""
    return _opt.set_prop_print_method(opt, threshold)

def reset_prop_print_method(opt: 'OptsHandler_ptr') -> "void":
    """reset_prop_print_method(OptsHandler_ptr opt)"""
    return _opt.reset_prop_print_method(opt)

def get_prop_print_method(opt: 'OptsHandler_ptr') -> "int":
    """get_prop_print_method(OptsHandler_ptr opt) -> int"""
    return _opt.get_prop_print_method(opt)

def set_prop_no(arg1: 'OptsHandler_ptr', n: 'int') -> "void":
    """set_prop_no(OptsHandler_ptr arg1, int n)"""
    return _opt.set_prop_no(arg1, n)

def get_prop_no(arg1: 'OptsHandler_ptr') -> "int":
    """get_prop_no(OptsHandler_ptr arg1) -> int"""
    return _opt.get_prop_no(arg1)

def print_partition_method(arg1: 'FILE *') -> "void":
    """print_partition_method(FILE * arg1)"""
    return _opt.print_partition_method(arg1)

def set_sat_solver(arg1: 'OptsHandler_ptr', arg2: 'char const *') -> "void":
    """set_sat_solver(OptsHandler_ptr arg1, char const * arg2)"""
    return _opt.set_sat_solver(arg1, arg2)

def get_sat_solver(arg1: 'OptsHandler_ptr') -> "char const *":
    """get_sat_solver(OptsHandler_ptr arg1) -> char const *"""
    return _opt.get_sat_solver(arg1)

def set_default_trace_plugin(opt: 'OptsHandler_ptr', plugin: 'int') -> "boolean":
    """set_default_trace_plugin(OptsHandler_ptr opt, int plugin) -> boolean"""
    return _opt.set_default_trace_plugin(opt, plugin)

def get_default_trace_plugin(opt: 'OptsHandler_ptr') -> "int":
    """get_default_trace_plugin(OptsHandler_ptr opt) -> int"""
    return _opt.get_default_trace_plugin(opt)

def set_iwls95_preorder(opt: 'OptsHandler_ptr') -> "void":
    """set_iwls95_preorder(OptsHandler_ptr opt)"""
    return _opt.set_iwls95_preorder(opt)

def unset_iwls95_preorder(opt: 'OptsHandler_ptr') -> "void":
    """unset_iwls95_preorder(OptsHandler_ptr opt)"""
    return _opt.unset_iwls95_preorder(opt)

def opt_iwls95_preorder(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_iwls95_preorder(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_iwls95_preorder(opt)

def set_affinity(arg1: 'OptsHandler_ptr') -> "void":
    """set_affinity(OptsHandler_ptr arg1)"""
    return _opt.set_affinity(arg1)

def unset_affinity(arg1: 'OptsHandler_ptr') -> "void":
    """unset_affinity(OptsHandler_ptr arg1)"""
    return _opt.unset_affinity(arg1)

def opt_affinity(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_affinity(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_affinity(arg1)

def set_append_clusters(arg1: 'OptsHandler_ptr') -> "void":
    """set_append_clusters(OptsHandler_ptr arg1)"""
    return _opt.set_append_clusters(arg1)

def unset_append_clusters(arg1: 'OptsHandler_ptr') -> "void":
    """unset_append_clusters(OptsHandler_ptr arg1)"""
    return _opt.unset_append_clusters(arg1)

def opt_append_clusters(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_append_clusters(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_append_clusters(arg1)

def set_counter_examples(arg1: 'OptsHandler_ptr') -> "void":
    """set_counter_examples(OptsHandler_ptr arg1)"""
    return _opt.set_counter_examples(arg1)

def unset_counter_examples(arg1: 'OptsHandler_ptr') -> "void":
    """unset_counter_examples(OptsHandler_ptr arg1)"""
    return _opt.unset_counter_examples(arg1)

def opt_counter_examples(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_counter_examples(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_counter_examples(arg1)

def set_traces_hiding_prefix(arg1: 'OptsHandler_ptr', arg2: 'char const *') -> "void":
    """set_traces_hiding_prefix(OptsHandler_ptr arg1, char const * arg2)"""
    return _opt.set_traces_hiding_prefix(arg1, arg2)

def opt_traces_hiding_prefix(arg1: 'OptsHandler_ptr') -> "char const *":
    """opt_traces_hiding_prefix(OptsHandler_ptr arg1) -> char const *"""
    return _opt.opt_traces_hiding_prefix(arg1)

def set_bdd_encoding_word_bits(opt: 'OptsHandler_ptr') -> "void":
    """set_bdd_encoding_word_bits(OptsHandler_ptr opt)"""
    return _opt.set_bdd_encoding_word_bits(opt)

def unset_bdd_encoding_word_bits(opt: 'OptsHandler_ptr') -> "void":
    """unset_bdd_encoding_word_bits(OptsHandler_ptr opt)"""
    return _opt.unset_bdd_encoding_word_bits(opt)

def reset_bdd_encoding_word_bits(opt: 'OptsHandler_ptr') -> "void":
    """reset_bdd_encoding_word_bits(OptsHandler_ptr opt)"""
    return _opt.reset_bdd_encoding_word_bits(opt)

def opt_bdd_encoding_word_bits(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_bdd_encoding_word_bits(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_bdd_encoding_word_bits(opt)

def set_on_failure_script_quits(arg1: 'OptsHandler_ptr') -> "void":
    """set_on_failure_script_quits(OptsHandler_ptr arg1)"""
    return _opt.set_on_failure_script_quits(arg1)

def unset_on_failure_script_quits(arg1: 'OptsHandler_ptr') -> "void":
    """unset_on_failure_script_quits(OptsHandler_ptr arg1)"""
    return _opt.unset_on_failure_script_quits(arg1)

def opt_on_failure_script_quits(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_on_failure_script_quits(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_on_failure_script_quits(arg1)

def set_write_order_dumps_bits(arg1: 'OptsHandler_ptr') -> "void":
    """set_write_order_dumps_bits(OptsHandler_ptr arg1)"""
    return _opt.set_write_order_dumps_bits(arg1)

def unset_write_order_dumps_bits(arg1: 'OptsHandler_ptr') -> "void":
    """unset_write_order_dumps_bits(OptsHandler_ptr arg1)"""
    return _opt.unset_write_order_dumps_bits(arg1)

def opt_write_order_dumps_bits(arg1: 'OptsHandler_ptr') -> "boolean":
    """opt_write_order_dumps_bits(OptsHandler_ptr arg1) -> boolean"""
    return _opt.opt_write_order_dumps_bits(arg1)

def unset_use_ansi_c_div_op(opt: 'OptsHandler_ptr') -> "void":
    """unset_use_ansi_c_div_op(OptsHandler_ptr opt)"""
    return _opt.unset_use_ansi_c_div_op(opt)

def opt_use_ansi_c_div_op(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_use_ansi_c_div_op(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_use_ansi_c_div_op(opt)

def set_vars_order_type(arg1: 'OptsHandler_ptr', arg2: 'VarsOrdType') -> "void":
    """set_vars_order_type(OptsHandler_ptr arg1, VarsOrdType arg2)"""
    return _opt.set_vars_order_type(arg1, arg2)

def get_vars_order_type(arg1: 'OptsHandler_ptr') -> "VarsOrdType":
    """get_vars_order_type(OptsHandler_ptr arg1) -> VarsOrdType"""
    return _opt.get_vars_order_type(arg1)

def set_bdd_static_order_heuristics(arg1: 'OptsHandler_ptr', value: 'BddSohEnum') -> "void":
    """set_bdd_static_order_heuristics(OptsHandler_ptr arg1, BddSohEnum value)"""
    return _opt.set_bdd_static_order_heuristics(arg1, value)

def get_bdd_static_order_heuristics(arg1: 'OptsHandler_ptr') -> "BddSohEnum":
    """get_bdd_static_order_heuristics(OptsHandler_ptr arg1) -> BddSohEnum"""
    return _opt.get_bdd_static_order_heuristics(arg1)

def set_symb_inlining(opt: 'OptsHandler_ptr') -> "void":
    """set_symb_inlining(OptsHandler_ptr opt)"""
    return _opt.set_symb_inlining(opt)

def unset_symb_inlining(opt: 'OptsHandler_ptr') -> "void":
    """unset_symb_inlining(OptsHandler_ptr opt)"""
    return _opt.unset_symb_inlining(opt)

def opt_symb_inlining(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_symb_inlining(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_symb_inlining(opt)

def set_rbc_inlining(opt: 'OptsHandler_ptr') -> "void":
    """set_rbc_inlining(OptsHandler_ptr opt)"""
    return _opt.set_rbc_inlining(opt)

def unset_rbc_inlining(opt: 'OptsHandler_ptr') -> "void":
    """unset_rbc_inlining(OptsHandler_ptr opt)"""
    return _opt.unset_rbc_inlining(opt)

def opt_rbc_inlining(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_rbc_inlining(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_rbc_inlining(opt)

def set_rbc_inlining_lazy(opt: 'OptsHandler_ptr') -> "void":
    """set_rbc_inlining_lazy(OptsHandler_ptr opt)"""
    return _opt.set_rbc_inlining_lazy(opt)

def unset_rbc_inlining_lazy(opt: 'OptsHandler_ptr') -> "void":
    """unset_rbc_inlining_lazy(OptsHandler_ptr opt)"""
    return _opt.unset_rbc_inlining_lazy(opt)

def opt_rbc_inlining_lazy(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_rbc_inlining_lazy(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_rbc_inlining_lazy(opt)

def set_use_coi_size_sorting(opt: 'OptsHandler_ptr') -> "void":
    """set_use_coi_size_sorting(OptsHandler_ptr opt)"""
    return _opt.set_use_coi_size_sorting(opt)

def unset_use_coi_size_sorting(opt: 'OptsHandler_ptr') -> "void":
    """unset_use_coi_size_sorting(OptsHandler_ptr opt)"""
    return _opt.unset_use_coi_size_sorting(opt)

def opt_use_coi_size_sorting(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_use_coi_size_sorting(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_use_coi_size_sorting(opt)

def opt_disable_syntactic_checks(opt: 'OptsHandler_ptr') -> "void":
    """opt_disable_syntactic_checks(OptsHandler_ptr opt)"""
    return _opt.opt_disable_syntactic_checks(opt)

def opt_enable_syntactic_checks(opt: 'OptsHandler_ptr') -> "void":
    """opt_enable_syntactic_checks(OptsHandler_ptr opt)"""
    return _opt.opt_enable_syntactic_checks(opt)

def opt_syntactic_checks_disabled(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_syntactic_checks_disabled(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_syntactic_checks_disabled(opt)

def set_keep_single_value_vars(opt: 'OptsHandler_ptr') -> "void":
    """set_keep_single_value_vars(OptsHandler_ptr opt)"""
    return _opt.set_keep_single_value_vars(opt)

def unset_keep_single_value_vars(opt: 'OptsHandler_ptr') -> "void":
    """unset_keep_single_value_vars(OptsHandler_ptr opt)"""
    return _opt.unset_keep_single_value_vars(opt)

def opt_keep_single_value_vars(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_keep_single_value_vars(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_keep_single_value_vars(opt)

def set_show_defines_in_traces(opt: 'OptsHandler_ptr') -> "void":
    """set_show_defines_in_traces(OptsHandler_ptr opt)"""
    return _opt.set_show_defines_in_traces(opt)

def unset_show_defines_in_traces(opt: 'OptsHandler_ptr') -> "void":
    """unset_show_defines_in_traces(OptsHandler_ptr opt)"""
    return _opt.unset_show_defines_in_traces(opt)

def opt_show_defines_in_traces(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_show_defines_in_traces(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_show_defines_in_traces(opt)

def set_show_defines_with_next(opt: 'OptsHandler_ptr') -> "void":
    """set_show_defines_with_next(OptsHandler_ptr opt)"""
    return _opt.set_show_defines_with_next(opt)

def unset_show_defines_with_next(opt: 'OptsHandler_ptr') -> "void":
    """unset_show_defines_with_next(OptsHandler_ptr opt)"""
    return _opt.unset_show_defines_with_next(opt)

def opt_show_defines_with_next(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_show_defines_with_next(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_show_defines_with_next(opt)

def set_check_invar_strategy(opt: 'OptsHandler_ptr', strategy: 'Check_Strategy') -> "void":
    """set_check_invar_strategy(OptsHandler_ptr opt, Check_Strategy strategy)"""
    return _opt.set_check_invar_strategy(opt, strategy)

def opt_check_invar_strategy(opt: 'OptsHandler_ptr') -> "Check_Strategy":
    """opt_check_invar_strategy(OptsHandler_ptr opt) -> Check_Strategy"""
    return _opt.opt_check_invar_strategy(opt)

def opt_check_invar_strategy_as_string(opt: 'OptsHandler_ptr') -> "char const *":
    """opt_check_invar_strategy_as_string(OptsHandler_ptr opt) -> char const *"""
    return _opt.opt_check_invar_strategy_as_string(opt)

def set_check_invar_fb_heuristic(opt: 'OptsHandler_ptr', strategy: 'FB_Heuristic') -> "void":
    """set_check_invar_fb_heuristic(OptsHandler_ptr opt, FB_Heuristic strategy)"""
    return _opt.set_check_invar_fb_heuristic(opt, strategy)

def opt_check_invar_fb_heuristic(opt: 'OptsHandler_ptr') -> "FB_Heuristic":
    """opt_check_invar_fb_heuristic(OptsHandler_ptr opt) -> FB_Heuristic"""
    return _opt.opt_check_invar_fb_heuristic(opt)

def opt_check_invar_fb_heuristic_as_string(opt: 'OptsHandler_ptr') -> "char const *":
    """opt_check_invar_fb_heuristic_as_string(OptsHandler_ptr opt) -> char const *"""
    return _opt.opt_check_invar_fb_heuristic_as_string(opt)

def set_check_invar_bddbmc_heuristic(opt: 'OptsHandler_ptr', strategy: 'Bdd2bmc_Heuristic') -> "void":
    """set_check_invar_bddbmc_heuristic(OptsHandler_ptr opt, Bdd2bmc_Heuristic strategy)"""
    return _opt.set_check_invar_bddbmc_heuristic(opt, strategy)

def opt_check_invar_bddbmc_heuristic(opt: 'OptsHandler_ptr') -> "Bdd2bmc_Heuristic":
    """opt_check_invar_bddbmc_heuristic(OptsHandler_ptr opt) -> Bdd2bmc_Heuristic"""
    return _opt.opt_check_invar_bddbmc_heuristic(opt)

def opt_check_invar_bddbmc_heuristic_as_string(opt: 'OptsHandler_ptr') -> "char const *":
    """opt_check_invar_bddbmc_heuristic_as_string(OptsHandler_ptr opt) -> char const *"""
    return _opt.opt_check_invar_bddbmc_heuristic_as_string(opt)

def set_check_invar_bddbmc_heuristic_threshold(opt: 'OptsHandler_ptr', t: 'int') -> "void":
    """set_check_invar_bddbmc_heuristic_threshold(OptsHandler_ptr opt, int t)"""
    return _opt.set_check_invar_bddbmc_heuristic_threshold(opt, t)

def opt_check_invar_bddbmc_heuristic_threshold(opt: 'OptsHandler_ptr') -> "int":
    """opt_check_invar_bddbmc_heuristic_threshold(OptsHandler_ptr opt) -> int"""
    return _opt.opt_check_invar_bddbmc_heuristic_threshold(opt)

def opt_is_daggifier_enabled(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_is_daggifier_enabled(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_is_daggifier_enabled(opt)

def opt_enable_daggifier(opt: 'OptsHandler_ptr') -> "void":
    """opt_enable_daggifier(OptsHandler_ptr opt)"""
    return _opt.opt_enable_daggifier(opt)

def opt_disable_daggifier(opt: 'OptsHandler_ptr') -> "void":
    """opt_disable_daggifier(OptsHandler_ptr opt)"""
    return _opt.opt_disable_daggifier(opt)

def opt_get_daggifier_counter_threshold(opt: 'OptsHandler_ptr') -> "int":
    """opt_get_daggifier_counter_threshold(OptsHandler_ptr opt) -> int"""
    return _opt.opt_get_daggifier_counter_threshold(opt)

def opt_set_daggifier_counter_threshold(opt: 'OptsHandler_ptr', x: 'int') -> "void":
    """opt_set_daggifier_counter_threshold(OptsHandler_ptr opt, int x)"""
    return _opt.opt_set_daggifier_counter_threshold(opt, x)

def opt_get_daggifier_depth_threshold(opt: 'OptsHandler_ptr') -> "int":
    """opt_get_daggifier_depth_threshold(OptsHandler_ptr opt) -> int"""
    return _opt.opt_get_daggifier_depth_threshold(opt)

def opt_set_daggifier_depth_threshold(opt: 'OptsHandler_ptr', x: 'int') -> "void":
    """opt_set_daggifier_depth_threshold(OptsHandler_ptr opt, int x)"""
    return _opt.opt_set_daggifier_depth_threshold(opt, x)

def opt_get_quiet_mode(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_get_quiet_mode(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_get_quiet_mode(opt)

def set_quiet_mode(opt: 'OptsHandler_ptr') -> "void":
    """set_quiet_mode(OptsHandler_ptr opt)"""
    return _opt.set_quiet_mode(opt)

def unset_quiet_mode(opt: 'OptsHandler_ptr') -> "void":
    """unset_quiet_mode(OptsHandler_ptr opt)"""
    return _opt.unset_quiet_mode(opt)

def opt_get_daggifier_statistics(opt: 'OptsHandler_ptr') -> "boolean":
    """opt_get_daggifier_statistics(OptsHandler_ptr opt) -> boolean"""
    return _opt.opt_get_daggifier_statistics(opt)

def set_daggifier_statistics(opt: 'OptsHandler_ptr') -> "void":
    """set_daggifier_statistics(OptsHandler_ptr opt)"""
    return _opt.set_daggifier_statistics(opt)

def unset_daggifier_statistics(opt: 'OptsHandler_ptr') -> "void":
    """unset_daggifier_statistics(OptsHandler_ptr opt)"""
    return _opt.unset_daggifier_statistics(opt)

def get_oreg_justice_emptiness_bdd_algorithm(opt: 'OptsHandler_ptr') -> "BddOregJusticeEmptinessBddAlgorithmType":
    """get_oreg_justice_emptiness_bdd_algorithm(OptsHandler_ptr opt) -> BddOregJusticeEmptinessBddAlgorithmType"""
    return _opt.get_oreg_justice_emptiness_bdd_algorithm(opt)

def set_oreg_justice_emptiness_bdd_algorithm(opt: 'OptsHandler_ptr', alg: 'BddOregJusticeEmptinessBddAlgorithmType') -> "void":
    """set_oreg_justice_emptiness_bdd_algorithm(OptsHandler_ptr opt, BddOregJusticeEmptinessBddAlgorithmType alg)"""
    return _opt.set_oreg_justice_emptiness_bdd_algorithm(opt, alg)

def reset_oreg_justice_emptiness_bdd_algorithm(opt: 'OptsHandler_ptr') -> "void":
    """reset_oreg_justice_emptiness_bdd_algorithm(OptsHandler_ptr opt)"""
    return _opt.reset_oreg_justice_emptiness_bdd_algorithm(opt)

def set_rbc2cnf_algorithm(opt: 'OptsHandler_ptr', algo: 'Rbc_2CnfAlgorithm') -> "void":
    """set_rbc2cnf_algorithm(OptsHandler_ptr opt, Rbc_2CnfAlgorithm algo)"""
    return _opt.set_rbc2cnf_algorithm(opt, algo)

def unset_rbc2cnf_algorithm(opt: 'OptsHandler_ptr') -> "void":
    """unset_rbc2cnf_algorithm(OptsHandler_ptr opt)"""
    return _opt.unset_rbc2cnf_algorithm(opt)

def get_rbc2cnf_algorithm(opt: 'OptsHandler_ptr') -> "Rbc_2CnfAlgorithm":
    """get_rbc2cnf_algorithm(OptsHandler_ptr opt) -> Rbc_2CnfAlgorithm"""
    return _opt.get_rbc2cnf_algorithm(opt)

def set_default_simulation_steps(arg1: 'OptsHandler_ptr', arg2: 'int') -> "void":
    """set_default_simulation_steps(OptsHandler_ptr arg1, int arg2)"""
    return _opt.set_default_simulation_steps(arg1, arg2)

def reset_default_simulation_steps(arg1: 'OptsHandler_ptr') -> "void":
    """reset_default_simulation_steps(OptsHandler_ptr arg1)"""
    return _opt.reset_default_simulation_steps(arg1)

def get_default_simulation_steps(arg1: 'OptsHandler_ptr') -> "int":
    """get_default_simulation_steps(OptsHandler_ptr arg1) -> int"""
    return _opt.get_default_simulation_steps(arg1)
GENERIC_OPTION = _opt.GENERIC_OPTION
USER_OPTION = _opt.USER_OPTION
INTEGER_OPTION = _opt.INTEGER_OPTION
ENUM_OPTION = _opt.ENUM_OPTION
BOOL_OPTION = _opt.BOOL_OPTION
ACTION_SET = _opt.ACTION_SET
ACTION_RESET = _opt.ACTION_RESET
ACTION_GET = _opt.ACTION_GET
class _Opts_EnumRec(_object):
    """Proxy of C _Opts_EnumRec struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _Opts_EnumRec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _Opts_EnumRec, name)
    __repr__ = _swig_repr
    __swig_setmethods__["v"] = _opt._Opts_EnumRec_v_set
    __swig_getmethods__["v"] = _opt._Opts_EnumRec_v_get
    if _newclass:
        v = _swig_property(_opt._Opts_EnumRec_v_get, _opt._Opts_EnumRec_v_set)
    __swig_setmethods__["e"] = _opt._Opts_EnumRec_e_set
    __swig_getmethods__["e"] = _opt._Opts_EnumRec_e_get
    if _newclass:
        e = _swig_property(_opt._Opts_EnumRec_e_get, _opt._Opts_EnumRec_e_set)

    def __init__(self):
        """__init__(_Opts_EnumRec self) -> _Opts_EnumRec"""
        this = _opt.new__Opts_EnumRec()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _opt.delete__Opts_EnumRec
    __del__ = lambda self: None
_Opts_EnumRec_swigregister = _opt._Opts_EnumRec_swigregister
_Opts_EnumRec_swigregister(_Opts_EnumRec)

OPTS_TRUE_VALUE = _opt.OPTS_TRUE_VALUE
OPTS_FALSE_VALUE = _opt.OPTS_FALSE_VALUE

def OptsHandler_get_instance() -> "OptsHandler_ptr":
    """OptsHandler_get_instance() -> OptsHandler_ptr"""
    return _opt.OptsHandler_get_instance()

def OptsHandler_instance_destroy() -> "void":
    """OptsHandler_instance_destroy()"""
    return _opt.OptsHandler_instance_destroy()

def OptsHandler_create() -> "OptsHandler_ptr":
    """OptsHandler_create() -> OptsHandler_ptr"""
    return _opt.OptsHandler_create()

def OptsHandler_destroy(h: 'OptsHandler_ptr') -> "void":
    """OptsHandler_destroy(OptsHandler_ptr h)"""
    return _opt.OptsHandler_destroy(h)

def OptsHandler_is_option_registered(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_option_registered(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_option_registered(arg1, name)

def OptsHandler_is_option_not_registered(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_option_not_registered(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_option_not_registered(arg1, name)

def OptsHandler_register_option(arg1: 'OptsHandler_ptr', name: 'char const *', arg3: 'char const *', check: 'Opts_CheckFnType', get: 'Opts_ReturnFnType', is_public: 'boolean', type: 'Option_Type') -> "boolean":
    """OptsHandler_register_option(OptsHandler_ptr arg1, char const * name, char const * arg3, Opts_CheckFnType check, Opts_ReturnFnType get, boolean is_public, Option_Type type) -> boolean"""
    return _opt.OptsHandler_register_option(arg1, name, arg3, check, get, is_public, type)

def OptsHandler_register_generic_option(arg1: 'OptsHandler_ptr', name: 'char const *', arg3: 'char const *', is_public: 'boolean') -> "boolean":
    """OptsHandler_register_generic_option(OptsHandler_ptr arg1, char const * name, char const * arg3, boolean is_public) -> boolean"""
    return _opt.OptsHandler_register_generic_option(arg1, name, arg3, is_public)

def OptsHandler_register_user_option(arg1: 'OptsHandler_ptr', name: 'char const *', arg3: 'char const *') -> "boolean":
    """OptsHandler_register_user_option(OptsHandler_ptr arg1, char const * name, char const * arg3) -> boolean"""
    return _opt.OptsHandler_register_user_option(arg1, name, arg3)

def OptsHandler_register_bool_option(arg1: 'OptsHandler_ptr', name: 'char const *', value: 'boolean', is_public: 'boolean') -> "boolean":
    """OptsHandler_register_bool_option(OptsHandler_ptr arg1, char const * name, boolean value, boolean is_public) -> boolean"""
    return _opt.OptsHandler_register_bool_option(arg1, name, value, is_public)

def OptsHandler_register_enum_option(arg1: 'OptsHandler_ptr', name: 'char const *', arg3: 'char const *', pv: '_Opts_EnumRec', npv: 'int', is_public: 'boolean') -> "boolean":
    """OptsHandler_register_enum_option(OptsHandler_ptr arg1, char const * name, char const * arg3, _Opts_EnumRec pv, int npv, boolean is_public) -> boolean"""
    return _opt.OptsHandler_register_enum_option(arg1, name, arg3, pv, npv, is_public)

def OptsHandler_register_int_option(arg1: 'OptsHandler_ptr', name: 'char const *', value: 'int', is_public: 'boolean') -> "boolean":
    """OptsHandler_register_int_option(OptsHandler_ptr arg1, char const * name, int value, boolean is_public) -> boolean"""
    return _opt.OptsHandler_register_int_option(arg1, name, value, is_public)

def OptsHandler_is_option_public(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_option_public(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_option_public(arg1, name)

def OptsHandler_is_enum_option(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_enum_option(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_enum_option(arg1, name)

def OptsHandler_is_generic_option(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_generic_option(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_generic_option(arg1, name)

def OptsHandler_is_user_option(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_user_option(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_user_option(arg1, name)

def OptsHandler_is_bool_option(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_bool_option(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_bool_option(arg1, name)

def OptsHandler_is_int_option(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_is_int_option(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_is_int_option(arg1, name)

def OptsHandler_unregister_option(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_unregister_option(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_unregister_option(arg1, name)

def OptsHandler_set_option_value(arg1: 'OptsHandler_ptr', name: 'char const *', value: 'char const *') -> "boolean":
    """OptsHandler_set_option_value(OptsHandler_ptr arg1, char const * name, char const * value) -> boolean"""
    return _opt.OptsHandler_set_option_value(arg1, name, value)

def OptsHandler_get_enum_option_values(arg1: 'OptsHandler_ptr', name: 'char const *', values: 'char ***', num_values: 'int *') -> "void":
    """OptsHandler_get_enum_option_values(OptsHandler_ptr arg1, char const * name, char *** values, int * num_values)"""
    return _opt.OptsHandler_get_enum_option_values(arg1, name, values, num_values)

def OptsHandler_set_enum_option_value(arg1: 'OptsHandler_ptr', name: 'char const *', value: 'char const *') -> "boolean":
    """OptsHandler_set_enum_option_value(OptsHandler_ptr arg1, char const * name, char const * value) -> boolean"""
    return _opt.OptsHandler_set_enum_option_value(arg1, name, value)

def OptsHandler_get_enum_option_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "int":
    """OptsHandler_get_enum_option_value(OptsHandler_ptr arg1, char const * name) -> int"""
    return _opt.OptsHandler_get_enum_option_value(arg1, name)

def OptsHandler_get_enum_option_default_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "int":
    """OptsHandler_get_enum_option_default_value(OptsHandler_ptr arg1, char const * name) -> int"""
    return _opt.OptsHandler_get_enum_option_default_value(arg1, name)

def OptsHandler_set_bool_option_value(arg1: 'OptsHandler_ptr', name: 'char const *', value: 'boolean') -> "boolean":
    """OptsHandler_set_bool_option_value(OptsHandler_ptr arg1, char const * name, boolean value) -> boolean"""
    return _opt.OptsHandler_set_bool_option_value(arg1, name, value)

def OptsHandler_set_int_option_value(arg1: 'OptsHandler_ptr', name: 'char const *', value: 'int') -> "boolean":
    """OptsHandler_set_int_option_value(OptsHandler_ptr arg1, char const * name, int value) -> boolean"""
    return _opt.OptsHandler_set_int_option_value(arg1, name, value)

def OptsHandler_reset_option_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_reset_option_value(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_reset_option_value(arg1, name)

def OptsHandler_get_option_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "void *":
    """OptsHandler_get_option_value(OptsHandler_ptr arg1, char const * name) -> void *"""
    return _opt.OptsHandler_get_option_value(arg1, name)

def OptsHandler_get_option_default_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "void *":
    """OptsHandler_get_option_default_value(OptsHandler_ptr arg1, char const * name) -> void *"""
    return _opt.OptsHandler_get_option_default_value(arg1, name)

def OptsHandler_get_string_option_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "char *":
    """OptsHandler_get_string_option_value(OptsHandler_ptr arg1, char const * name) -> char *"""
    return _opt.OptsHandler_get_string_option_value(arg1, name)

def OptsHandler_get_string_representation_option_default_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "char *":
    """OptsHandler_get_string_representation_option_default_value(OptsHandler_ptr arg1, char const * name) -> char *"""
    return _opt.OptsHandler_get_string_representation_option_default_value(arg1, name)

def OptsHandler_get_string_representation_option_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "char *":
    """OptsHandler_get_string_representation_option_value(OptsHandler_ptr arg1, char const * name) -> char *"""
    return _opt.OptsHandler_get_string_representation_option_value(arg1, name)

def OptsHandler_get_bool_option_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_get_bool_option_value(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_get_bool_option_value(arg1, name)

def OptsHandler_get_bool_option_default_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "boolean":
    """OptsHandler_get_bool_option_default_value(OptsHandler_ptr arg1, char const * name) -> boolean"""
    return _opt.OptsHandler_get_bool_option_default_value(arg1, name)

def OptsHandler_get_int_option_default_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "int":
    """OptsHandler_get_int_option_default_value(OptsHandler_ptr arg1, char const * name) -> int"""
    return _opt.OptsHandler_get_int_option_default_value(arg1, name)

def OptsHandler_get_int_option_value(arg1: 'OptsHandler_ptr', name: 'char const *') -> "int":
    """OptsHandler_get_int_option_value(OptsHandler_ptr arg1, char const * name) -> int"""
    return _opt.OptsHandler_get_int_option_value(arg1, name)

def OptsHandler_add_option_trigger(arg1: 'OptsHandler_ptr', name: 'char const *', trigger: 'Opts_TriggerFnType') -> "boolean":
    """OptsHandler_add_option_trigger(OptsHandler_ptr arg1, char const * name, Opts_TriggerFnType trigger) -> boolean"""
    return _opt.OptsHandler_add_option_trigger(arg1, name, trigger)

def OptsHandler_remove_option_trigger(arg1: 'OptsHandler_ptr', name: 'char const *', trigger: 'Opts_TriggerFnType') -> "boolean":
    """OptsHandler_remove_option_trigger(OptsHandler_ptr arg1, char const * name, Opts_TriggerFnType trigger) -> boolean"""
    return _opt.OptsHandler_remove_option_trigger(arg1, name, trigger)

def Opts_Gen_init(arg1: 'OptsHandler_ptr') -> "void":
    """Opts_Gen_init(OptsHandler_ptr arg1)"""
    return _opt.Opts_Gen_init(arg1)

def Opts_Gen_next(arg1: 'OptsHandler_ptr', name: 'char **', value: 'char **') -> "int":
    """Opts_Gen_next(OptsHandler_ptr arg1, char ** name, char ** value) -> int"""
    return _opt.Opts_Gen_next(arg1, name, value)

def Opts_Gen_deinit(arg1: 'OptsHandler_ptr') -> "void":
    """Opts_Gen_deinit(OptsHandler_ptr arg1)"""
    return _opt.Opts_Gen_deinit(arg1)

def OptsHandler_print_all_options(arg1: 'OptsHandler_ptr', fd: 'FILE *', print_private: 'boolean') -> "void":
    """OptsHandler_print_all_options(OptsHandler_ptr arg1, FILE * fd, boolean print_private)"""
    return _opt.OptsHandler_print_all_options(arg1, fd, print_private)

def OptsHandler_generate_test(arg1: 'OptsHandler_ptr', of: 'FILE *', gen_unset: 'boolean') -> "void":
    """OptsHandler_generate_test(OptsHandler_ptr arg1, FILE * of, boolean gen_unset)"""
    return _opt.OptsHandler_generate_test(arg1, of, gen_unset)
# This file is compatible with both classic and new-style classes.


