# This is an auto-generated file, DO NOT EDIT!
# Run ant to generate it.

# Possible log levels in descending order 
# (lower levels include higher ones):
# OFF:      no logs published
# SEVERE:   error messages
# WARNING:  warnings
# INFO:     messages
# FINE:     logs on main application level
# FINER:    logs on central CPA algorithm level
# FINEST:   logs published by specific CPAs
# ALL:      debugging information
# Care must be taken with levels of FINER or lower, as output files may
# become quite large and memory usage might become an issue.

# single levels to be excluded from being logged
log.consoleExclude = ImmutableList.of()

# log level of console output
log.consoleLevel = Level.INFO

# name of the log file
log.file = "CPALog.txt"

# single levels to be excluded from being logged
log.fileExclude = ImmutableList.of()

# log level of file output
log.level = Level.OFF

# maximum size of log output strings before they will be truncated
log.truncateSize = 10000

# use colors for log messages on console
log.useColors = true

# all used options are printed
log.usedOptions.export = false

# disable all default output files
# (any explicitly given file will still be written)
output.disable = false

# directory to put all output files in
output.path = "output/"

# base directory for all input & output files
# (except for the configuration file itself)
rootDirectory = "."


# maximum number of condition adjustments (-1 for infinite)
adjustableconditions.adjustmentLimit = -1

# stop CPAchecker after startup (internal option, not intended for users)
analysis.disable = false

# entry function
analysis.entryFunction = "main"

# use CBMC as an external tool from CPAchecker
analysis.externalCBMC = false

# run interprocedural analysis
analysis.interprocedural = true

# C programs to analyze (currently only one file is supported)
analysis.programNames = no default value

# which reached set implementation to use?
# NORMAL: just a simple set
# LOCATIONMAPPED: a different set per location (faster, elements with
# different locations cannot be merged)
# PARTITIONED: partitioning depending on CPAs (e.g Location, Callstack etc.)
analysis.reachedSet = PARTITIONED
  enum:     [NORMAL, LOCATIONMAPPED, PARTITIONED]

# restart the algorithm using a different CPA after unknown result
analysis.restartAfterUnknown = false

# stop after the first error has been found
analysis.stopAfterError = true

# which strategy to adopt for visiting states? TOPSORT is deprecated, use the
# option analysis.traversal.useTopsort instead
analysis.traversal.order = DFS
  enum:     [DFS, BFS, TOPSORT, RAND]

# handle states with a deeper callstack first?
# This needs the CallstackCPA to have any effect.
analysis.traversal.useCallstack = false

# handle more abstract states (with less information) first? (only for
# ExplicitCPA)
analysis.traversal.useExplicitInformation = false

# Use an implementation of topsort strategy that allows to select a secondary
# strategy that is used if there are two elements with the same topsort id.
# The secondary strategy is selected with 'analysis.traversal.order'. The
# secondary strategy may not be TOPSORT.
analysis.traversal.useTopsort = false

# use adjustable conditions algorithm
analysis.useAdjustableConditions = false

# use assumption collecting algorithm
analysis.useAssumptionCollector = false

# use a BMC like algorithm that checks for satisfiability after the analysis
# has finished, works only with PredicateCPA
analysis.useBMC = false

# use CBMC to double-check counter-examples
analysis.useCBMC = false

# use CBMC and the FeatureVars Restriction option
analysis.useFeatureVarsRestriction = false

# add declarations for global variables before entry function
analysis.useGlobalVars = true

# Use McMillan's Impact algorithm for lazy interpolation
analysis.useImpactAlgorithm = false

# use a proof check algorithm to validate a previously generated proof
analysis.useProofCheckAlgorithm = false

# whether or not to use refinement or not
# use CEGAR algorithm for lazy counter-example guided analysis
# You need to specify a refiner with the cegar.refiner option.
# Currently all refiner require the use of the ARTCPA.
analysis.useRefinement = false

# write collected assumptions as automaton to file
assumptions.automatonFile = "AssumptionAutomaton.txt"

# write collected assumptions to file
assumptions.export = true
assumptions.file = "assumptions.txt"

# Allow reduction of function entries; calculate abstractions alwasy at
# function entries?
blockreducer.allowReduceFunctionEntries = true

# Allow reduction of function exits; calculate abstractions alwasy at
# function exits?
blockreducer.allowReduceFunctionExits = true

# Allow reduction of loop heads; calculate abstractions alwasy at loop heads?
blockreducer.allowReduceLoopHeads = false

# write the reduced cfa to the specified file.
blockreducer.reducedCfaFile = "ReducedCfa.rsf"

# Do at most n summarizations on a node.
blockreducer.reductionThreshold = 100

# If BMC did not find a bug, check whether the bounding did actually remove
# parts of the state space (this is similar to CBMC's unwinding assertions).
bmc.boundingAssertions = true

# Check reachability of target states after analysis (classical BMC). The
# alternative is to check the reachability as soon as the target states are
# discovered, which is done if cpa.predicate.targetStateSatCheck=true.
bmc.checkTargetStates = true

# dump counterexample formula to file
bmc.dumpCounterexampleFormula = "counterexample.msat"

# try using induction to verify programs with loops
bmc.induction = false

# configuration file for invariant generation
bmc.invariantGenerationConfigFile = no default value

# generate invariants for induction in parallel to the analysis
bmc.parallelInvariantGeneration = false

# file name where to put the path program that is generated as input for
# CBMC. A temporary file is used if this is unspecified.
cbmc.dumpCBMCfile = no default value

# specify the name of the error label
cbmc.options.errorLabel = "ERROR"

# set width of int (16, 32 or 64)
cbmc.options.intWidth = 32

# disable unwinding assertions violation error
cbmc.options.nuaf = false

# specify the limit for unwindings (0 is infinite)
cbmc.options.unwindings = 0

# maximum time limit for CBMC (use milliseconds or specify a unit; 0 for
# infinite)
# maximum time limit for CBMC (0 is infinite)
cbmc.timelimit = 0

# Which refinement algorithm to use? (give class name, required for CEGAR) If
# the package name starts with 'org.sosy_lab.cpachecker.', this prefix can be
# omitted.
cegar.refiner = no default value

# completely restart analysis on refinement by removing everything from the
# reached set
cegar.restartOnRefinement = false

# export CFA as .dot file
cfa.export = true

# export individual CFAs for function as .dot files
cfa.exportPerFunction = true

# export CFA as .dot file
cfa.file = "cfa.dot"

# remove paths from CFA that cannot lead to a error location
cfa.removeIrrelevantForErrorLocations = false

# combine sequences of simple edges into a single edge
cfa.useMultiEdges = false

# which model checker to use for verifying counterexamples as a second check
# Currently CBMC or CPAchecker with a different config can be used.
counterexample.checker = "CBMC"
  allowed values: [CBMC, CPACHECKER]

# configuration file for counterexample checks with CPAchecker
counterexample.checker.config = "config/explicitAnalysis-no-cbmc.properties"

# continue analysis after an counterexample was found that was denied by the
# second check
counterexample.continueAfterInfeasibleError = true

# If continueAfterInfeasibleError is true, remove the infeasible
# counterexample before continuing.Setting this to false may prevent a lot of
# similar infeasible counterexamples to get discovered, but is unsound
counterexample.removeInfeasibleErrors = false

# CPA to use (see doc/Configuration.txt for more documentation on this)
cpa = CompositeCPA.class.getCanonicalName()

# if enabled, cache queries also consider blocks with non-matching precision
# for reuse.
cpa.abm.aggressiveCaching = true

# Type of partitioning (FunctionAndLoopPartitioning or
# DelayedFunctionAndLoopPartitioning)
# or any class that implements a PartitioningHeuristic
cpa.abm.blockHeuristic = FunctionAndLoopPartitioning.class

# if enabled, the reached set cache is analysed for each cache miss to find
# the cause of the miss.
cpa.abm.gatherCacheMissStatistics = false

# export one variable assignment for error path to file, if one is found
cpa.art.errorPath.assignment = "ErrorPathAssignment.txt"

# export error path to file, if one is found
cpa.art.errorPath.core = "ErrorPathCore.txt"
cpa.art.errorPath.export = true
cpa.art.errorPath.file = "ErrorPath.txt"
cpa.art.errorPath.graph = "ErrorPath.dot"
cpa.art.errorPath.json = "ErrorPath.json"
cpa.art.errorPath.source = "ErrorPath.c"

# export final ART as .dot file
cpa.art.export = true
cpa.art.file = "ART.dot"

# whether to keep covered states in the reached set as addition to keeping
# them in the ART
cpa.art.keepCoveredStatesInReached = false

# signal the analysis to break in case of reached error state
cpa.automaton.breakOnTargetState = true

# export automaton to file
cpa.automaton.dotExport = false

# file for saving the automaton in DOT format (%s will be replaced with
# automaton name)
cpa.automaton.dotExportFile = "%s.dot"

# file with automaton specification for ObserverAutomatonCPA and
# ControlAutomatonCPA
cpa.automaton.inputFile = no default value

# which composite merge operator to use (plain or agree)
# Both delegate to the component cpas, but agree only allows merging if all
# cpas agree on this. This is probably what you want.
cpa.composite.merge = "AGREE"
  allowed values: [PLAIN, AGREE]

# which precision adjustment strategy to use (ignorant or omniscient)
# While an ignorant strategy keeps the domain knowledge seperated, and
# delegates to the component precision adjustment operators, the omniscient
# strategy may operate on global knowledge.
cpa.composite.precAdjust = "IGNORANT"
  allowed values: [IGNORANT, OMNISCIENT]

# Limit for Java heap memory used by CPAchecker (in MiB; -1 for infinite)
cpa.conditions.global.memory.heap = -1

# Limit for process memory used by CPAchecker (in MiB; -1 for infinite)
cpa.conditions.global.memory.process = -1

# Limit for size of reached set (-1 for infinite)
cpa.conditions.global.reached.size = -1

# Limit for cpu time used by CPAchecker (use milliseconds or specify a unit;
# -1 for infinite)
cpa.conditions.global.time.cpu = -1

# Hard limit for cpu time used by CPAchecker (use milliseconds or specify a
# unit; -1 for infinite)
# When using adjustable conditions, analysis will end after this threshold
cpa.conditions.global.time.cpu.hardlimit = -1

# Limit for wall time used by CPAchecker (use milliseconds or specify a unit;
# -1 for infinite)
cpa.conditions.global.time.wall = -1

# Hard limit for wall time used by CPAchecker (use milliseconds or specify a
# unit; -1 for infinite)
# When using adjustable conditions, analysis will end after this threshold
cpa.conditions.global.time.wall.hardlimit = -1

# whether or not to track unique assignments only
cpa.conditions.path.assignments.demandUniqueness = true

# file name where to put the extended stats file
cpa.conditions.path.assignments.extendedStatsFile = no default value

# maximum number of assignments (-1 for infinite)
cpa.conditions.path.assignments.threshold = -1

# maximum number of assume edges length (-1 for infinite)
cpa.conditions.path.assumeedges.limit = -1

# The condition
cpa.conditions.path.condition = no default value

# maximum path length (-1 for infinite)
cpa.conditions.path.length.limit = -1

# maximum repetitions of any edge in a path (-1 for infinite)
cpa.conditions.path.repetitions.limit = -1

# which merge operator to use for DefUseCPA
cpa.defuse.merge = "sep"
  allowed values: [sep, join]

# which merge operator to use for ExplicitCPA
cpa.explicit.merge = "SEP"
  allowed values: [SEP, JOIN]

# threshold for amount of different values that are tracked for one variable
# per path (-1 means infinitely)
cpa.explicit.precision.path.defaultThreshold = -1

# threshold for amount of different values that are tracked for one variable
# within the reached set (-1 means infinitely)
cpa.explicit.precision.reachedSet.defaultThreshold = -1

# which stop operator to use for ExplicitCPA
cpa.explicit.stop = "SEP"
  allowed values: [SEP, JOIN, NEVER]

# blacklist regex for variables that won't be tracked by ExplicitCPA
cpa.explicit.variableBlacklist = ""

# whitelist regex for variables that will be tracked by FeatureVarsCPA
cpa.featurevars.variableWhitelist = ""

# whether function pointers with invalid targets (e.g., 0) should be tracked
# in order to find calls to such pointers
cpa.functionpointer.trackInvalidFunctionPointers = false

# which type of merge operator to use for IntervalAnalysisCPA
cpa.interval.merge = "SEP"
  allowed values: [SEP, JOIN]

# decides whether one (false) or two (true) successors should be created when
# an inequality-check is encountered
cpa.interval.splitIntervals = false

# at most that many intervals will be tracked per variable
cpa.interval.threshold = 0

# which merge operator to use for InvariantCPA
cpa.invariants.merge = "JOIN"
  allowed values: [JOIN, SEP]

# threshold for unrolling loops of the program (0 is infinite)
# works only if assumption storage CPA is enabled, because otherwise it would
# be unsound
cpa.loopstack.maxLoopIterations = 0

# time limit for a single post computation (use milliseconds or specify a
# unit; 0 for infinite)
cpa.monitor.limit = 0

# time limit for all computations on a path in milliseconds (use milliseconds
# or specify a unit; 0 for infinite)
cpa.monitor.pathcomputationlimit = 0

# which merge operator to use for OctagonCPA?
cpa.octagon.merge = "SEP"
  allowed values: [SEP, JOIN]

# which merge operator to use for PointerCPA?
cpa.pointer.merge = "sep"
  allowed values: [sep, join]

# print warnings during analysis when unsafe pointer operations are found
cpa.pointer.printWarnings = true

# which merge operator to use for PointerACPA
cpa.pointerA.merge = "SEP"
  allowed values: [SEP, JOIN]

# which stop operator to use for PointerACPA
cpa.pointerA.stop = "SEP"
  allowed values: [SEP, JOIN, NEVER]

# whether to use auxiliary predidates for reduction
cpa.predicate.abm.auxiliaryPredicateComputer = true

# use caching of region to formula conversions
# use caching of abstractions
cpa.predicate.abs.useCache = true

# whether to use Boolean (false) or Cartesian (true) abstraction
cpa.predicate.abstraction.cartesian = false

# dump the abstraction formulas if they took to long
cpa.predicate.abstraction.dumpHardQueries = false

# get an initial set of predicates from a file in MSAT format
cpa.predicate.abstraction.initialPredicates = no default value

# What to use for storing abstractions
cpa.predicate.abstraction.type = "BDD"
  allowed values: [BDD, FORMULA]

# force abstractions immediately after threshold is reached (no effect if
# threshold = 0)
cpa.predicate.blk.alwaysAfterThreshold = true

# abstraction always and only on explicitly computed abstraction nodes.
cpa.predicate.blk.alwaysAndOnlyAtExplicitNodes = false

# force abstractions at each function calls/returns, regardless of threshold
cpa.predicate.blk.alwaysAtFunctions = true

# force abstractions at loop heads, regardless of threshold
cpa.predicate.blk.alwaysAtLoops = true

# abstractions at function calls/returns if threshold has been reached (no
# effect if threshold = 0)
cpa.predicate.blk.functions = false

# abstractions at loop heads if threshold has been reached (no effect if
# threshold = 0)
cpa.predicate.blk.loops = false

# maximum blocksize before abstraction is forced
# (non-negative number, special values: 0 = don't check threshold, 1 = SBE)
cpa.predicate.blk.threshold = 0

# use caching of path formulas
cpa.predicate.blk.useCache = true

# always check satisfiability at end of block, even if precision is empty
cpa.predicate.checkBlockFeasibility = false

# Enable the possibility to precompute explicit abstraction locations.
cpa.predicate.enableBlockreducer = false

# where to dump interpolation and abstraction problems (format string)
cpa.predicate.formulaDumpFilePattern = "%s%04d-%s%03d.msat"

# handle Pointers
cpa.predicate.handlePointerAliasing = true

# initialize all variables to 0 when they are declared
cpa.predicate.initAllVars = false

# the machine model used for functions sizeof and alignof
cpa.predicate.machineModel = LINUX32
  enum:     [LINUX32, LINUX64]

# With of the bitvectors if useBitwise is true.
cpa.predicate.mathsat.bitWidth = 32

# use uninterpreted functions for *, & and array access
cpa.predicate.mathsat.lvalsAsUIFs = false

# Whether to use signed or unsigned variables if useBitwise is true.
cpa.predicate.mathsat.signed = true

# Encode program variables of bitvectors of a fixed size,instead of using
# REALS. No interpolation and thus no refinement issupported in this case.
cpa.predicate.mathsat.useBitwise = false

# use a combination of theories (this is incomplete)
cpa.predicate.mathsat.useDtc = false

# encode program variables as INTEGERs in MathSAT, instead of using REALs.
# Since interpolation is not really supported by the laz solver, when
# computing interpolants we still use the LA solver, but encoding variables
# as ints might still be a good idea: we can tighten strict inequalities, and
# split negated equalities
cpa.predicate.mathsat.useIntegers = false

# Use UIFs (recommended because its more precise)
cpa.predicate.mathsat.useUIFs = true

# list of functions that provide new memory on the heap. This is only used,
# when handling of pointers is enabled.
cpa.predicate.memoryAllocationFunctions = {
      "malloc", "__kmalloc", "kzalloc"
      }

# which merge operator to use for predicate cpa (usually ABE should be used)
cpa.predicate.merge = "ABE"
  allowed values: [SEP, ABE]

# list of functions that should be considered as giving a non-deterministic
# return value
#  Only predicate analysis honors this option. If you specify this option,
# the default values are not added automatically to the list, so you need to
# specify them explicitly if you need them. Mentioning a function in this
# list has only an effect, if it is an 'external function', i.e., no source
# is given in the code for this function.
cpa.predicate.nondetFunctions = {
      "malloc", "__kmalloc", "kzalloc",
      "sscanf",
      "int_nondet", "nondet_int", "random", "__VERIFIER_nondet_int", "__VERIFIER_nondet_pointer",
      "__VERIFIER_nondet_short", "__VERIFIER_nondet_char", "__VERIFIER_nondet_float"
      }

# export final predicate map, if the error location is not reached
cpa.predicate.predmap.export = true
cpa.predicate.predmap.file = "predmap.txt"

# refinement will add all discovered predicates to all the locations in the
# abstract trace
cpa.predicate.refinement.addPredicatesGlobally = false

# refinement will try to build 'well-scoped' predicates, by cutting spurious
# traces as explained in Section 5.2 of the paper 'Abstractions From Proofs'
# (this does not work with function inlining).
# THIS FEATURE IS CURRENTLY NOT AVAILABLE. 
cpa.predicate.refinement.addWellScopedPredicates = false

# only use the atoms from the interpolants as predicates, and not the whole
# interpolant
cpa.predicate.refinement.atomicPredicates = true

# try again with a second solver if refinement timed out
cpa.predicate.refinement.changesolverontimeout = false

# dump all interpolation problems
cpa.predicate.refinement.dumpInterpolationProblems = false

# apply deletion-filter to the abstract counterexample, to get a minimal set
# of blocks, before applying interpolation-based refinement
cpa.predicate.refinement.getUsefulBlocks = false

# Which interpolating solver to use for interpolant generation?
# DEFAULT means to use the solver used for everything else as well.
cpa.predicate.refinement.interpolatingProver = "DEFAULT"
  allowed values: [DEFAULT, CSISAT]

# skip refinement if input formula is larger than this amount of bytes
# (ignored if 0)
cpa.predicate.refinement.maxRefinementSize = 0

# where to dump the counterexample formula in case the error location is
# reached
cpa.predicate.refinement.msatCexFile = "counterexample.msat"

# use incremental search in counterexample analysis, to find the minimal
# infeasible prefix
cpa.predicate.refinement.shortestCexTrace = false

# if shortestCexTrace is used, start from the end with the incremental search
cpa.predicate.refinement.shortestCexTraceUseSuffix = false

# if shortestCexTrace is used, alternatingly search from start and end of the
# trace
cpa.predicate.refinement.shortestCexTraceZigZag = false

# split arithmetic equalities when extracting predicates from interpolants
cpa.predicate.refinement.splitItpAtoms = false

# time limit for refinement (use milliseconds or specify a unit; 0 for
# infinite)
cpa.predicate.refinement.timelimit = 0

# verify if the interpolants fulfill the interpolant properties
cpa.predicate.refinement.verifyInterpolants = false

# maximum blocksize before a satisfiability check is done
# (non-negative number, 0 means never, if positive should be smaller than
# blocksize)
cpa.predicate.satCheck = 0

# Whether to use MathSAT 4, MathSAT 5 or YICES (in combination with Mathsat
# 4) as SMT solver
cpa.predicate.solver = "MATHSAT4"
  allowed values: [MATHSAT4, MATHSAT5, YICES]

# whether to include the symbolic path formula in the coverage checks or do
# only the fast abstract checks
cpa.predicate.symbolicCoverageCheck = false

# check satisfiability when a target state has been found (should be true)
cpa.predicate.targetStateSatCheck = true

# try to add some useful static-learning-like axioms for bitwise operations
# (which are encoded as UFs): essentially, we simply collect all the numbers
# used in bitwise operations, and add axioms like (0 & n = 0)
cpa.predicate.useBitwiseAxioms = false

# add special information to formulas about non-deterministic functions
cpa.predicate.useNondetFlags = false

# which merge operator to use for UninitializedVariablesCPA?
cpa.uninitvars.merge = "sep"
  allowed values: [sep, join]

# print warnings during analysis when uninitialized variables are used
cpa.uninitvars.printWarnings = "true"

# which stop operator to use for UninitializedVariablesCPA?
cpa.uninitvars.stop = "sep"
  allowed values: [sep, join]

# enable the Forced Covering optimization
impact.useForcedCovering = true

# C dialect for parser
parser.dialect = GNUC
  enum:     [C99, GNUC]

# Ignore all casts that appear in the source code.
parser.ignoreCasts = false

# file in which ART representation needed for proof checking is stored
pcc.proofFile = "art.obj"

pcc.proofgen.doPCC = false

# print reached set to text file
reachedSet.export = true
reachedSet.file = "reached.txt"

# list of files with configurations to use
restartAlgorithm.configFiles = no default value

# comma-separated list of files with specifications that should be checked
# (see config/specification/ for examples)
specification = no default value

# write some statistics to disk
statistics.export = true
statistics.file = "Statistics.txt"

# track memory usage of JVM during runtime
statistics.memory = true

# print statistics to console
statistics.print = false

