java -Xmx6000000000 -jar ./plugins/org.eclipse.equinox.launcher_1.3.100.v20150511-1540.jar -data ./data --generate-csv --csv-dir ../../../releaseScripts/default/UAutomizer-linux/csv -tc ../../../trunk/examples/toolchains/AbstractInterpretationC.xml -s ../../../trunk/examples/settings/ai/eq-bench/svcomp-DerefFreeMemtrack-32bit-Automizer_Camel+AI_EQ_imprecise.epf -i ../../../trunk/examples/svcomp/forester-heap/sll-buckets_true-unreach-call_true-valid-memsafety.i


--------------------------------------------------------------------------------


This is Ultimate 0.1.23-6b94a2f
[2018-01-24 16:34:21,030 INFO  L170        SettingsManager]: Resetting all preferences to default values...
[2018-01-24 16:34:21,031 INFO  L174        SettingsManager]: Resetting UltimateCore preferences to default values
[2018-01-24 16:34:21,047 INFO  L177        SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring...
[2018-01-24 16:34:21,047 INFO  L174        SettingsManager]: Resetting Boogie Preprocessor preferences to default values
[2018-01-24 16:34:21,048 INFO  L174        SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values
[2018-01-24 16:34:21,050 INFO  L174        SettingsManager]: Resetting Abstract Interpretation preferences to default values
[2018-01-24 16:34:21,051 INFO  L174        SettingsManager]: Resetting LassoRanker preferences to default values
[2018-01-24 16:34:21,053 INFO  L174        SettingsManager]: Resetting Reaching Definitions preferences to default values
[2018-01-24 16:34:21,054 INFO  L174        SettingsManager]: Resetting SyntaxChecker preferences to default values
[2018-01-24 16:34:21,055 INFO  L177        SettingsManager]: Büchi Program Product provides no preferences, ignoring...
[2018-01-24 16:34:21,055 INFO  L174        SettingsManager]: Resetting LTL2Aut preferences to default values
[2018-01-24 16:34:21,056 INFO  L174        SettingsManager]: Resetting BlockEncodingV2 preferences to default values
[2018-01-24 16:34:21,058 INFO  L174        SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values
[2018-01-24 16:34:21,059 INFO  L174        SettingsManager]: Resetting BuchiAutomizer preferences to default values
[2018-01-24 16:34:21,061 INFO  L174        SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values
[2018-01-24 16:34:21,063 INFO  L174        SettingsManager]: Resetting CodeCheck preferences to default values
[2018-01-24 16:34:21,066 INFO  L174        SettingsManager]: Resetting InvariantSynthesis preferences to default values
[2018-01-24 16:34:21,067 INFO  L174        SettingsManager]: Resetting RCFGBuilder preferences to default values
[2018-01-24 16:34:21,068 INFO  L174        SettingsManager]: Resetting TraceAbstraction preferences to default values
[2018-01-24 16:34:21,071 INFO  L177        SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring...
[2018-01-24 16:34:21,071 INFO  L177        SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring...
[2018-01-24 16:34:21,071 INFO  L174        SettingsManager]: Resetting IcfgTransformer preferences to default values
[2018-01-24 16:34:21,072 INFO  L174        SettingsManager]: Resetting Boogie Printer preferences to default values
[2018-01-24 16:34:21,073 INFO  L174        SettingsManager]: Resetting Witness Printer preferences to default values
[2018-01-24 16:34:21,074 INFO  L177        SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring...
[2018-01-24 16:34:21,075 INFO  L174        SettingsManager]: Resetting CDTParser preferences to default values
[2018-01-24 16:34:21,076 INFO  L177        SettingsManager]: PEA to Boogie provides no preferences, ignoring...
[2018-01-24 16:34:21,076 INFO  L177        SettingsManager]: AutomataScriptParser provides no preferences, ignoring...
[2018-01-24 16:34:21,076 INFO  L174        SettingsManager]: Resetting Witness Parser preferences to default values
[2018-01-24 16:34:21,077 INFO  L181        SettingsManager]: Finished resetting all preferences to default values...
[2018-01-24 16:34:21,077 INFO  L98         SettingsManager]: Beginning loading settings from /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/settings/ai/eq-bench/svcomp-DerefFreeMemtrack-32bit-Automizer_Camel+AI_EQ_imprecise.epf
[2018-01-24 16:34:21,087 INFO  L110        SettingsManager]: Loading preferences was successful
[2018-01-24 16:34:21,088 INFO  L112        SettingsManager]: Preferences different from defaults after loading the file:
[2018-01-24 16:34:21,088 INFO  L131        SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults:
[2018-01-24 16:34:21,089 INFO  L133        SettingsManager]:  * to procedures, called more than once=true
[2018-01-24 16:34:21,089 INFO  L131        SettingsManager]: Preferences of Abstract Interpretation differ from their defaults:
[2018-01-24 16:34:21,089 INFO  L133        SettingsManager]:  * Deactivate Weak Equivalences=true
[2018-01-24 16:34:21,089 INFO  L133        SettingsManager]:  * Abstract domain for RCFG-of-the-future=VPDomain
[2018-01-24 16:34:21,090 INFO  L133        SettingsManager]:  * Use the RCFG-of-the-future interface=true
[2018-01-24 16:34:21,090 INFO  L131        SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults:
[2018-01-24 16:34:21,090 INFO  L133        SettingsManager]:  * sizeof long=4
[2018-01-24 16:34:21,091 INFO  L133        SettingsManager]:  * Check unreachability of error function in SV-COMP mode=false
[2018-01-24 16:34:21,091 INFO  L133        SettingsManager]:  * Overapproximate operations on floating types=true
[2018-01-24 16:34:21,091 INFO  L133        SettingsManager]:  * sizeof POINTER=4
[2018-01-24 16:34:21,091 INFO  L133        SettingsManager]:  * Check division by zero=IGNORE
[2018-01-24 16:34:21,091 INFO  L133        SettingsManager]:  * Check for the main procedure if all allocated memory was freed=true
[2018-01-24 16:34:21,092 INFO  L133        SettingsManager]:  * Bitprecise bitfields=true
[2018-01-24 16:34:21,092 INFO  L133        SettingsManager]:  * SV-COMP memtrack compatibility mode=true
[2018-01-24 16:34:21,092 INFO  L133        SettingsManager]:  * If two pointers are subtracted or compared they have the same base address=IGNORE
[2018-01-24 16:34:21,092 INFO  L133        SettingsManager]:  * sizeof long double=12
[2018-01-24 16:34:21,092 INFO  L131        SettingsManager]: Preferences of RCFGBuilder differ from their defaults:
[2018-01-24 16:34:21,093 INFO  L133        SettingsManager]:  * Size of a code block=SequenceOfStatements
[2018-01-24 16:34:21,093 INFO  L133        SettingsManager]:  * To the following directory=./dump/
[2018-01-24 16:34:21,093 INFO  L133        SettingsManager]:  * Add additional assume for each assert=false
[2018-01-24 16:34:21,093 INFO  L133        SettingsManager]:  * SMT solver=External_DefaultMode
[2018-01-24 16:34:21,093 INFO  L133        SettingsManager]:  * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000
[2018-01-24 16:34:21,094 INFO  L131        SettingsManager]: Preferences of TraceAbstraction differ from their defaults:
[2018-01-24 16:34:21,094 INFO  L133        SettingsManager]:  * Interpolant automaton=TWOTRACK
[2018-01-24 16:34:21,094 INFO  L133        SettingsManager]:  * Compute Interpolants along a Counterexample=FPandBP
[2018-01-24 16:34:21,094 INFO  L133        SettingsManager]:  * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles
[2018-01-24 16:34:21,094 INFO  L133        SettingsManager]:  * Trace refinement strategy=CAMEL
[2018-01-24 16:34:21,095 INFO  L133        SettingsManager]:  * SMT solver=External_ModelsAndUnsatCoreMode
[2018-01-24 16:34:21,095 INFO  L133        SettingsManager]:  * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in
[2018-01-24 16:34:21,095 INFO  L133        SettingsManager]:  * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true
[2018-01-24 16:34:21,096 INFO  L131        SettingsManager]: Preferences of IcfgTransformer differ from their defaults:
[2018-01-24 16:34:21,096 INFO  L133        SettingsManager]:  * TransformationType=HEAP_SEPARATOR
[2018-01-24 16:34:21,131 INFO  L81    nceAwareModelManager]: Repository-Root is: /tmp
[2018-01-24 16:34:21,144 INFO  L266   ainManager$Toolchain]: [Toolchain 1]: Parser(s) successfully initialized
[2018-01-24 16:34:21,149 INFO  L222   ainManager$Toolchain]: [Toolchain 1]: Toolchain data selected.
[2018-01-24 16:34:21,150 INFO  L271        PluginConnector]: Initializing CDTParser...
[2018-01-24 16:34:21,151 INFO  L276        PluginConnector]: CDTParser initialized
[2018-01-24 16:34:21,152 INFO  L431   ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/forester-heap/sll-buckets_true-unreach-call_true-valid-memsafety.i
[2018-01-24 16:34:21,324 INFO  L304   ainManager$Toolchain]: ####################### [Toolchain 1] #######################
[2018-01-24 16:34:21,331 INFO  L131        ToolchainWalker]: Walking toolchain with 4 elements.
[2018-01-24 16:34:21,332 INFO  L113        PluginConnector]: ------------------------CACSL2BoogieTranslator----------------------------
[2018-01-24 16:34:21,333 INFO  L271        PluginConnector]: Initializing CACSL2BoogieTranslator...
[2018-01-24 16:34:21,339 INFO  L276        PluginConnector]: CACSL2BoogieTranslator initialized
[2018-01-24 16:34:21,340 INFO  L185        PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,342 INFO  L205        PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@67ce22e9 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21, skipping insertion in model container
[2018-01-24 16:34:21,343 INFO  L185        PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,363 INFO  L153             Dispatcher]: Using SV-COMP mode
[2018-01-24 16:34:21,408 INFO  L153             Dispatcher]: Using SV-COMP mode
[2018-01-24 16:34:21,532 INFO  L450          PostProcessor]: Settings: Checked method=main
[2018-01-24 16:34:21,561 INFO  L450          PostProcessor]: Settings: Checked method=main
[2018-01-24 16:34:21,569 INFO  L202        PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21 WrapperNode
[2018-01-24 16:34:21,570 INFO  L132        PluginConnector]: ------------------------ END CACSL2BoogieTranslator----------------------------
[2018-01-24 16:34:21,570 INFO  L113        PluginConnector]: ------------------------Boogie Preprocessor----------------------------
[2018-01-24 16:34:21,570 INFO  L271        PluginConnector]: Initializing Boogie Preprocessor...
[2018-01-24 16:34:21,571 INFO  L276        PluginConnector]: Boogie Preprocessor initialized
[2018-01-24 16:34:21,584 INFO  L185        PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,584 INFO  L185        PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,596 INFO  L185        PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,596 INFO  L185        PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,601 INFO  L185        PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,607 INFO  L185        PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,608 INFO  L185        PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
[2018-01-24 16:34:21,611 INFO  L132        PluginConnector]: ------------------------ END Boogie Preprocessor----------------------------
[2018-01-24 16:34:21,612 INFO  L113        PluginConnector]: ------------------------RCFGBuilder----------------------------
[2018-01-24 16:34:21,612 INFO  L271        PluginConnector]: Initializing RCFGBuilder...
[2018-01-24 16:34:21,612 INFO  L276        PluginConnector]: RCFGBuilder initialized
[2018-01-24 16:34:21,613 INFO  L185        PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 24.01 04:34:21" (1/1) ...
No working directory specified, using /storage/ultimate/releaseScripts/default/UAutomizer-linux/z3
Starting monitored process 1 with z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 (exit command is (exit), workingDir is null)
Waiting until toolchain timeout for monitored process 1 with z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000
[2018-01-24 16:34:21,660 INFO  L136     BoogieDeclarations]: Found implementation of procedure ULTIMATE.init
[2018-01-24 16:34:21,661 INFO  L136     BoogieDeclarations]: Found implementation of procedure ULTIMATE.start
[2018-01-24 16:34:21,661 INFO  L136     BoogieDeclarations]: Found implementation of procedure main
[2018-01-24 16:34:21,661 INFO  L128     BoogieDeclarations]: Found specification of procedure write~int
[2018-01-24 16:34:21,661 INFO  L128     BoogieDeclarations]: Found specification of procedure read~int
[2018-01-24 16:34:21,661 INFO  L128     BoogieDeclarations]: Found specification of procedure write~$Pointer$
[2018-01-24 16:34:21,661 INFO  L128     BoogieDeclarations]: Found specification of procedure read~$Pointer$
[2018-01-24 16:34:21,661 INFO  L128     BoogieDeclarations]: Found specification of procedure ULTIMATE.free
[2018-01-24 16:34:21,661 INFO  L128     BoogieDeclarations]: Found specification of procedure ULTIMATE.dealloc
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure #Ultimate.alloc
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure malloc
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure free
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure __VERIFIER_nondet_int
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure __VERIFIER_error
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure main
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure ULTIMATE.init
[2018-01-24 16:34:21,662 INFO  L128     BoogieDeclarations]: Found specification of procedure ULTIMATE.start
[2018-01-24 16:34:22,308 INFO  L257             CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start)
[2018-01-24 16:34:22,309 INFO  L202        PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 24.01 04:34:22 BoogieIcfgContainer
[2018-01-24 16:34:22,309 INFO  L132        PluginConnector]: ------------------------ END RCFGBuilder----------------------------
[2018-01-24 16:34:22,310 INFO  L113        PluginConnector]: ------------------------Abstract Interpretation----------------------------
[2018-01-24 16:34:22,310 INFO  L271        PluginConnector]: Initializing Abstract Interpretation...
[2018-01-24 16:34:22,311 INFO  L276        PluginConnector]: Abstract Interpretation initialized
[2018-01-24 16:34:22,312 INFO  L185        PluginConnector]: Executing the observer AbstractInterpretationRcfgObserver from plugin Abstract Interpretation for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 24.01 04:34:22" (1/1) ...
[2018-01-24 16:34:22,379 INFO  L101         FixpointEngine]: Starting fixpoint engine with domain VPDomain (maxUnwinding=3, maxParallelStates=2)
[2018-01-24 16:34:27,539 INFO  L259    AbstractInterpreter]: Some error location(s) were reachable
[2018-01-24 16:34:27,584 WARN  L343   cessorBacktranslator]: Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true)
[2018-01-24 16:34:27,603 INFO  L268    AbstractInterpreter]: Visited 183 different actions 1087 times. Merged at 101 different actions 597 times. Widened at 11 different actions 38 times. Found 67 fixpoints after 27 different actions. Largest state had 58 variables.
[2018-01-24 16:34:27,606 INFO  L132        PluginConnector]: ------------------------ END Abstract Interpretation----------------------------
[2018-01-24 16:34:27,607 INFO  L168              Benchmark]: Toolchain (without parser) took 6282.55 ms. Allocated memory was 307.8 MB in the beginning and 910.7 MB in the end (delta: 602.9 MB). Free memory was 267.8 MB in the beginning and 347.2 MB in the end (delta: -79.4 MB). Peak memory consumption was 523.5 MB. Max. memory is 5.3 GB.
[2018-01-24 16:34:27,608 INFO  L168              Benchmark]: CDTParser took 0.18 ms. Allocated memory is still 307.8 MB. Free memory is still 273.8 MB. There was no memory consumed. Max. memory is 5.3 GB.
[2018-01-24 16:34:27,608 INFO  L168              Benchmark]: CACSL2BoogieTranslator took 237.59 ms. Allocated memory is still 307.8 MB. Free memory was 266.8 MB in the beginning and 254.6 MB in the end (delta: 12.2 MB). Peak memory consumption was 12.2 MB. Max. memory is 5.3 GB.
[2018-01-24 16:34:27,609 INFO  L168              Benchmark]: Boogie Preprocessor took 40.92 ms. Allocated memory is still 307.8 MB. Free memory was 254.6 MB in the beginning and 252.6 MB in the end (delta: 2.0 MB). Peak memory consumption was 2.0 MB. Max. memory is 5.3 GB.
[2018-01-24 16:34:27,609 INFO  L168              Benchmark]: RCFGBuilder took 698.01 ms. Allocated memory is still 307.8 MB. Free memory was 252.6 MB in the beginning and 213.1 MB in the end (delta: 39.4 MB). Peak memory consumption was 39.4 MB. Max. memory is 5.3 GB.
[2018-01-24 16:34:27,610 INFO  L168              Benchmark]: Abstract Interpretation took 5296.05 ms. Allocated memory was 307.8 MB in the beginning and 910.7 MB in the end (delta: 602.9 MB). Free memory was 213.1 MB in the beginning and 347.2 MB in the end (delta: -134.0 MB). Peak memory consumption was 468.9 MB. Max. memory is 5.3 GB.
[2018-01-24 16:34:27,611 INFO  L344   ainManager$Toolchain]: #######################  End [Toolchain 1] #######################
 --- Results ---
 * Results from de.uni_freiburg.informatik.ultimate.core:
  - StatisticsResult: Toolchain Benchmarks
    Benchmark results are:
 * CDTParser took 0.18 ms. Allocated memory is still 307.8 MB. Free memory is still 273.8 MB. There was no memory consumed. Max. memory is 5.3 GB.
 * CACSL2BoogieTranslator took 237.59 ms. Allocated memory is still 307.8 MB. Free memory was 266.8 MB in the beginning and 254.6 MB in the end (delta: 12.2 MB). Peak memory consumption was 12.2 MB. Max. memory is 5.3 GB.
 * Boogie Preprocessor took 40.92 ms. Allocated memory is still 307.8 MB. Free memory was 254.6 MB in the beginning and 252.6 MB in the end (delta: 2.0 MB). Peak memory consumption was 2.0 MB. Max. memory is 5.3 GB.
 * RCFGBuilder took 698.01 ms. Allocated memory is still 307.8 MB. Free memory was 252.6 MB in the beginning and 213.1 MB in the end (delta: 39.4 MB). Peak memory consumption was 39.4 MB. Max. memory is 5.3 GB.
 * Abstract Interpretation took 5296.05 ms. Allocated memory was 307.8 MB in the beginning and 910.7 MB in the end (delta: 602.9 MB). Free memory was 213.1 MB in the beginning and 347.2 MB in the end (delta: -134.0 MB). Peak memory consumption was 468.9 MB. Max. memory is 5.3 GB.
 * Results from de.uni_freiburg.informatik.ultimate.plugins.analysis.abstractinterpretationv2:
  - StatisticsResult: ArrayEqualityDomainStatistics
    
#Locations                               :     131 
LocStat_MAX_WEQGRAPH_SIZE                :       0 
LocStat_MAX_SIZEOF_WEQEDGELABEL          :       0 
LocStat_NO_SUPPORTING_EQUALITIES         :    1849 
LocStat_NO_SUPPORTING_DISEQUALITIES      :    1040 
LocStat_NO_DISJUNCTIONS                  :    -262 
LocStat_MAX_NO_DISJUNCTIONS              :      -1 
#Transitions                             :     187 
TransStat_MAX_WEQGRAPH_SIZE              :       0 
TransStat_MAX_SIZEOF_WEQEDGELABEL        :       0 
TransStat_NO_SUPPORTING_EQUALITIES       :     257 
TransStat_NO_SUPPORTING_DISEQUALITIES    :      75 
TransStat_NO_DISJUNCTIONS                :     210 
TransStat_MAX_NO_DISJUNCTIONS            :       4 

  - StatisticsResult: EqConstraintFactoryStatistics
    
CONJOIN_DISJUNCTIVE(MILLISECONDS)        : 0.695012 
RENAME_VARIABLES(MILLISECONDS)           : 0.014733 
UNFREEZE(MILLISECONDS)                   : 0.000000 
CONJOIN(MILLISECONDS)                    : 0.529519 
PROJECTAWAY(MILLISECONDS)                : 1.352900 
ADD_WEAK_EQUALITY(MILLISECONDS)          : 0.001409 
DISJOIN(MILLISECONDS)                    : 0.429217 
RENAME_VARIABLES_DISJUNCTIVE(MILLISECONDS) : 0.029815 
ADD_EQUALITY(MILLISECONDS)               : 0.010684 
DISJOIN_DISJUNCTIVE(MILLISECONDS)        : 0.000000 
ADD_DISEQUALITY(MILLISECONDS)            : 0.024558 
#CONJOIN_DISJUNCTIVE                     :    1925 
#RENAME_VARIABLES                        :    3858 
#UNFREEZE                                :       0 
#CONJOIN                                 :    2299 
#PROJECTAWAY                             :    1917 
#ADD_WEAK_EQUALITY                       :     107 
#DISJOIN                                 :     581 
#RENAME_VARIABLES_DISJUNCTIVE            :    3747 
#ADD_EQUALITY                            :     309 
#DISJOIN_DISJUNCTIVE                     :       0 
#ADD_DISEQUALITY                         :      61 

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]  EXPR, FCALL  malloc(sizeof(BCK))
[L993]               BCK* bucket = malloc(sizeof(BCK));
[L994]  FCALL        bucket->data = 0

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]  EXPR, FCALL  malloc(sizeof(BCK))
[L993]               BCK* bucket = malloc(sizeof(BCK));
[L994]  FCALL        bucket->data = 0
[L995]  FCALL        bucket->list = ((void*)0)

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]  EXPR, FCALL  malloc(sizeof(BCK))
[L993]               BCK* bucket = malloc(sizeof(BCK));
[L994]  FCALL        bucket->data = 0
[L995]  FCALL        bucket->list = ((void*)0)
[L997]  EXPR, FCALL  malloc(sizeof(BCK))
[L997]  FCALL        bucket->next = malloc(sizeof(BCK))

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]  EXPR, FCALL  malloc(sizeof(BCK))
[L993]               BCK* bucket = malloc(sizeof(BCK));
[L994]  FCALL        bucket->data = 0
[L995]  FCALL        bucket->list = ((void*)0)
[L997]  EXPR, FCALL  malloc(sizeof(BCK))
[L997]  FCALL        bucket->next = malloc(sizeof(BCK))

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]  EXPR, FCALL  malloc(sizeof(BCK))
[L993]               BCK* bucket = malloc(sizeof(BCK));
[L994]  FCALL        bucket->data = 0
[L995]  FCALL        bucket->list = ((void*)0)
[L997]  EXPR, FCALL  malloc(sizeof(BCK))
[L997]  FCALL        bucket->next = malloc(sizeof(BCK))
[L998]  FCALL        bucket->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]  EXPR, FCALL  malloc(sizeof(BCK))
[L993]               BCK* bucket = malloc(sizeof(BCK));
[L994]  FCALL        bucket->data = 0
[L995]  FCALL        bucket->list = ((void*)0)
[L997]  EXPR, FCALL  malloc(sizeof(BCK))
[L997]  FCALL        bucket->next = malloc(sizeof(BCK))
[L998]  EXPR, FCALL  bucket->next
[L998]               BCK* bcki = bucket->next;
[L999]  FCALL        bcki->data = 1

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  FCALL        bcki->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  FCALL        bcki->list

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  FCALL        bcki->list

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND FALSE   !(__VERIFIER_nondet_int())
[L1016]  COND TRUE    __VERIFIER_nondet_int()
[L1017]  FCALL        item->data = 1

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND FALSE   !(__VERIFIER_nondet_int())
[L1016]  COND FALSE   !(__VERIFIER_nondet_int())
[L1019]  FCALL        item->data = 2

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  FCALL        item->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  FCALL        item->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  EXPR, FCALL  item->next
[L1049]               item = item->next
[L1050]  FCALL        itr->data

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND FALSE   !(item != ((void*)0))
[L1053]  COND FALSE   !(!(item == ((void*)0)))
[L1053]  COND FALSE   !(0)
[L1054]               bucket = bcki
[L1055]  FCALL        bcki->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  EXPR, FCALL  item->next
[L1049]               item = item->next
[L1050]  FCALL        itr->data
[L1050]  FCALL        bcki->data

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  FCALL        bcki->data

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  FCALL        bcki->data

  - UnprovableResult [Line: 1]: Unable to prove that free always succeeds
    Unable to prove that free always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  EXPR, FCALL  item->next
[L1049]               item = item->next
[L1050]  EXPR, FCALL  itr->data
[L1050]  EXPR, FCALL  bcki->data
[L1050]  COND FALSE   !(!(itr->data == bcki->data))
[L1050]  COND FALSE   !(0)
[L1051]  FCALL        free(itr)

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  FCALL        bcki->data
[L1025]  FCALL        item->data

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND TRUE    bcki->data != item->data
[L1026]  FCALL        bcki->next

  - UnprovableResult [Line: 990]: Unable to prove that all allocated memory was freed
    Unable to prove that all allocated memory was freed
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND FALSE   !(item != ((void*)0))
[L1053]  COND FALSE   !(!(item == ((void*)0)))
[L1053]  COND FALSE   !(0)
[L1054]               bucket = bcki
[L1055]  EXPR, FCALL  bcki->next
[L1055]               bcki = bcki->next
[L1056]  FCALL        free(bucket)
[L1057]               bucket = ((void*)0)
[L1042]  COND FALSE   !(bcki != ((void*)0))
[L1060]               return 0;

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND FALSE   !(bcki->data != item->data)
[L1027]  COND FALSE   !(!(bcki != ((void*)0)))
[L1027]  COND FALSE   !(0)
[L1029]  FCALL        bcki->list

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  EXPR, FCALL  item->next
[L1049]               item = item->next
[L1050]  EXPR, FCALL  itr->data
[L1050]  EXPR, FCALL  bcki->data
[L1050]  COND FALSE   !(!(itr->data == bcki->data))
[L1050]  COND FALSE   !(0)
[L1051]  FCALL        free(itr)
[L1046]  COND FALSE   !(item != ((void*)0))
[L1053]  COND FALSE   !(!(item == ((void*)0)))
[L1053]  COND FALSE   !(0)
[L1054]               bucket = bcki
[L1055]  FCALL        bcki->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  EXPR, FCALL  item->next
[L1049]               item = item->next
[L1050]  EXPR, FCALL  itr->data
[L1050]  EXPR, FCALL  bcki->data
[L1050]  COND FALSE   !(!(itr->data == bcki->data))
[L1050]  COND FALSE   !(0)
[L1051]  FCALL        free(itr)
[L1046]  COND TRUE    item != ((void*)0)
[L1048]               itr = item
[L1049]  EXPR, FCALL  item->next
[L1049]               item = item->next
[L1050]  FCALL        itr->data
[L1050]  FCALL        bcki->data

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND FALSE   !(bcki->data != item->data)
[L1027]  COND FALSE   !(!(bcki != ((void*)0)))
[L1027]  COND FALSE   !(0)
[L1029]  EXPR, FCALL  bcki->list
[L1029]  COND FALSE   !(bcki->list == ((void*)0))
[L1033]  FCALL        bcki->list

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND FALSE   !(bcki->data != item->data)
[L1027]  COND FALSE   !(!(bcki != ((void*)0)))
[L1027]  COND FALSE   !(0)
[L1029]  EXPR, FCALL  bcki->list
[L1029]  COND TRUE    bcki->list == ((void*)0)
[L1030]  FCALL        bcki->list = item

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND FALSE   !(bcki->data != item->data)
[L1027]  COND FALSE   !(!(bcki != ((void*)0)))
[L1027]  COND FALSE   !(0)
[L1029]  EXPR, FCALL  bcki->list
[L1029]  COND FALSE   !(bcki->list == ((void*)0))
[L1033]  EXPR, FCALL  bcki->list
[L1033]               itr = bcki->list
[L1034]  FCALL        itr->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND FALSE   !(bcki->data != item->data)
[L1027]  COND FALSE   !(!(bcki != ((void*)0)))
[L1027]  COND FALSE   !(0)
[L1029]  EXPR, FCALL  bcki->list
[L1029]  COND FALSE   !(bcki->list == ((void*)0))
[L1033]  EXPR, FCALL  bcki->list
[L1033]               itr = bcki->list
[L1034]  FCALL        itr->next

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND FALSE   !(bcki->data != item->data)
[L1027]  COND FALSE   !(!(bcki != ((void*)0)))
[L1027]  COND FALSE   !(0)
[L1029]  EXPR, FCALL  bcki->list
[L1029]  COND FALSE   !(bcki->list == ((void*)0))
[L1033]  EXPR, FCALL  bcki->list
[L1033]               itr = bcki->list
[L1034]  EXPR, FCALL  itr->next
[L1034]  COND FALSE   !(itr->next != ((void*)0))
[L1036]  FCALL        itr->next = item

  - UnprovableResult [Line: 1]: Unable to prove that pointer dereference always succeeds
    Unable to prove that pointer dereference always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND TRUE    __VERIFIER_nondet_int()
[L1012]  EXPR, FCALL  malloc(sizeof(SLL))
[L1012]               item = malloc(sizeof(SLL))
[L1013]  FCALL        item->next = ((void*)0)
[L1014]  COND TRUE    __VERIFIER_nondet_int()
[L1015]  FCALL        item->data = 0
[L1021]               bcki = bucket
[L1023]  COND FALSE   !(!(bcki != ((void*)0)))
[L1023]  COND FALSE   !(0)
[L1024]  COND FALSE   !(!(item != ((void*)0)))
[L1024]  COND FALSE   !(0)
[L1025]  EXPR, FCALL  bcki->data
[L1025]  EXPR, FCALL  item->data
[L1025]  COND FALSE   !(bcki->data != item->data)
[L1027]  COND FALSE   !(!(bcki != ((void*)0)))
[L1027]  COND FALSE   !(0)
[L1029]  EXPR, FCALL  bcki->list
[L1029]  COND FALSE   !(bcki->list == ((void*)0))
[L1033]  EXPR, FCALL  bcki->list
[L1033]               itr = bcki->list
[L1034]  EXPR, FCALL  itr->next
[L1034]  COND TRUE    itr->next != ((void*)0)
[L1035]  FCALL        itr->next

  - UnprovableResult [Line: 1]: Unable to prove that free always succeeds
    Unable to prove that free always succeeds
 Reason: abstract domain could reach this error location. 
Possible FailurePath: 
[L993]   EXPR, FCALL  malloc(sizeof(BCK))
[L993]                BCK* bucket = malloc(sizeof(BCK));
[L994]   FCALL        bucket->data = 0
[L995]   FCALL        bucket->list = ((void*)0)
[L997]   EXPR, FCALL  malloc(sizeof(BCK))
[L997]   FCALL        bucket->next = malloc(sizeof(BCK))
[L998]   EXPR, FCALL  bucket->next
[L998]                BCK* bcki = bucket->next;
[L999]   FCALL        bcki->data = 1
[L1000]  FCALL        bcki->list = ((void*)0)
[L1002]  EXPR, FCALL  malloc(sizeof(BCK))
[L1002]  FCALL        bcki->next = malloc(sizeof(BCK))
[L1003]  EXPR, FCALL  bcki->next
[L1003]               bcki = bcki->next
[L1004]  FCALL        bcki->data = 2
[L1005]  FCALL        bcki->list = ((void*)0)
[L1006]  FCALL        bcki->next = ((void*)0)
[L1008]               struct TSLL* item = ((void*)0);
[L1009]               struct TSLL* itr = ((void*)0);
[L1010]  COND FALSE   !(__VERIFIER_nondet_int())
[L1041]               bcki = bucket
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND FALSE   !(item != ((void*)0))
[L1053]  COND FALSE   !(!(item == ((void*)0)))
[L1053]  COND FALSE   !(0)
[L1054]               bucket = bcki
[L1055]  EXPR, FCALL  bcki->next
[L1055]               bcki = bcki->next
[L1056]  FCALL        free(bucket)
[L1057]               bucket = ((void*)0)
[L1042]  COND TRUE    bcki != ((void*)0)
[L1044]  EXPR, FCALL  bcki->list
[L1044]               item = bcki->list
[L1045]  FCALL        bcki->list = ((void*)0)
[L1046]  COND FALSE   !(item != ((void*)0))
[L1053]  COND FALSE   !(!(item == ((void*)0)))
[L1053]  COND FALSE   !(0)
[L1054]               bucket = bcki
[L1055]  EXPR, FCALL  bcki->next
[L1055]               bcki = bcki->next
[L1056]  FCALL        free(bucket)

  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: free always succeeds
    For all program executions holds that free always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: free always succeeds
    For all program executions holds that free always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
  - PositiveResult [Line: 1]: pointer dereference always succeeds
    For all program executions holds that pointer dereference always succeeds at this location
 * Results from de.uni_freiburg.informatik.ultimate.boogie.preprocessor:
  - GenericResult: Unfinished Backtranslation
    Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true)
RESULT: Ultimate could not prove your program: unable to determine feasibility of some traces
Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-buckets_true-unreach-call_true-valid-memsafety.i_svcomp-DerefFreeMemtrack-32bit-Automizer_Camel+AI_EQ_imprecise.epf_AbstractInterpretationC.xml/Csv-Benchmark-0-2018-01-24_16-34-27-623.csv
Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-buckets_true-unreach-call_true-valid-memsafety.i_svcomp-DerefFreeMemtrack-32bit-Automizer_Camel+AI_EQ_imprecise.epf_AbstractInterpretationC.xml/Csv-VPDomainBenchmark-0-2018-01-24_16-34-27-623.csv
Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-buckets_true-unreach-call_true-valid-memsafety.i_svcomp-DerefFreeMemtrack-32bit-Automizer_Camel+AI_EQ_imprecise.epf_AbstractInterpretationC.xml/Csv-BenchmarkWithCounters-0-2018-01-24_16-34-27-623.csv
Received shutdown request...