java -ea -Xmx8000000000 -jar /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/plugins/org.eclipse.equinox.launcher_1.3.100.v20150511-1540.jar -data @noDefault -ultimatedata /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data -tc ../../../trunk/examples/toolchains/AutomizerCInline_WitnessPrinter.xml -s ../../../trunk/examples/settings/default/automizer/svcomp-Reach-32bit-Automizer_Default.epf -i ../../../trunk/examples/svcomp/list-properties/alternating_list_false-unreach-call_false-valid-memcleanup.i


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


This is Ultimate 0.1.23-61f4311
[2018-11-23 12:52:13,547 INFO  L170        SettingsManager]: Resetting all preferences to default values...
[2018-11-23 12:52:13,549 INFO  L174        SettingsManager]: Resetting UltimateCore preferences to default values
[2018-11-23 12:52:13,561 INFO  L177        SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring...
[2018-11-23 12:52:13,562 INFO  L174        SettingsManager]: Resetting Boogie Preprocessor preferences to default values
[2018-11-23 12:52:13,563 INFO  L174        SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values
[2018-11-23 12:52:13,564 INFO  L174        SettingsManager]: Resetting Abstract Interpretation preferences to default values
[2018-11-23 12:52:13,566 INFO  L174        SettingsManager]: Resetting LassoRanker preferences to default values
[2018-11-23 12:52:13,568 INFO  L174        SettingsManager]: Resetting Reaching Definitions preferences to default values
[2018-11-23 12:52:13,569 INFO  L174        SettingsManager]: Resetting SyntaxChecker preferences to default values
[2018-11-23 12:52:13,570 INFO  L177        SettingsManager]: Büchi Program Product provides no preferences, ignoring...
[2018-11-23 12:52:13,570 INFO  L174        SettingsManager]: Resetting LTL2Aut preferences to default values
[2018-11-23 12:52:13,571 INFO  L174        SettingsManager]: Resetting PEA to Boogie preferences to default values
[2018-11-23 12:52:13,572 INFO  L174        SettingsManager]: Resetting BlockEncodingV2 preferences to default values
[2018-11-23 12:52:13,573 INFO  L174        SettingsManager]: Resetting ChcToBoogie preferences to default values
[2018-11-23 12:52:13,574 INFO  L174        SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values
[2018-11-23 12:52:13,575 INFO  L174        SettingsManager]: Resetting BuchiAutomizer preferences to default values
[2018-11-23 12:52:13,580 INFO  L174        SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values
[2018-11-23 12:52:13,587 INFO  L174        SettingsManager]: Resetting CodeCheck preferences to default values
[2018-11-23 12:52:13,589 INFO  L174        SettingsManager]: Resetting InvariantSynthesis preferences to default values
[2018-11-23 12:52:13,593 INFO  L174        SettingsManager]: Resetting RCFGBuilder preferences to default values
[2018-11-23 12:52:13,595 INFO  L174        SettingsManager]: Resetting TraceAbstraction preferences to default values
[2018-11-23 12:52:13,597 INFO  L177        SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring...
[2018-11-23 12:52:13,597 INFO  L177        SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring...
[2018-11-23 12:52:13,598 INFO  L174        SettingsManager]: Resetting TreeAutomizer preferences to default values
[2018-11-23 12:52:13,599 INFO  L174        SettingsManager]: Resetting IcfgTransformer preferences to default values
[2018-11-23 12:52:13,600 INFO  L174        SettingsManager]: Resetting Boogie Printer preferences to default values
[2018-11-23 12:52:13,601 INFO  L174        SettingsManager]: Resetting ReqPrinter preferences to default values
[2018-11-23 12:52:13,601 INFO  L174        SettingsManager]: Resetting Witness Printer preferences to default values
[2018-11-23 12:52:13,603 INFO  L177        SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring...
[2018-11-23 12:52:13,603 INFO  L174        SettingsManager]: Resetting CDTParser preferences to default values
[2018-11-23 12:52:13,604 INFO  L177        SettingsManager]: AutomataScriptParser provides no preferences, ignoring...
[2018-11-23 12:52:13,604 INFO  L177        SettingsManager]: ReqParser provides no preferences, ignoring...
[2018-11-23 12:52:13,604 INFO  L174        SettingsManager]: Resetting SmtParser preferences to default values
[2018-11-23 12:52:13,605 INFO  L174        SettingsManager]: Resetting Witness Parser preferences to default values
[2018-11-23 12:52:13,606 INFO  L181        SettingsManager]: Finished resetting all preferences to default values...
[2018-11-23 12:52:13,606 INFO  L98         SettingsManager]: Beginning loading settings from /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/settings/default/automizer/svcomp-Reach-32bit-Automizer_Default.epf
[2018-11-23 12:52:13,622 INFO  L110        SettingsManager]: Loading preferences was successful
[2018-11-23 12:52:13,622 INFO  L112        SettingsManager]: Preferences different from defaults after loading the file:
[2018-11-23 12:52:13,623 INFO  L131        SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults:
[2018-11-23 12:52:13,623 INFO  L133        SettingsManager]:  * ... calls to implemented procedures=ONLY_FOR_CONCURRENT_PROGRAMS
[2018-11-23 12:52:13,624 INFO  L131        SettingsManager]: Preferences of BlockEncodingV2 differ from their defaults:
[2018-11-23 12:52:13,624 INFO  L133        SettingsManager]:  * Create parallel compositions if possible=false
[2018-11-23 12:52:13,624 INFO  L133        SettingsManager]:  * Use SBE=true
[2018-11-23 12:52:13,624 INFO  L131        SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults:
[2018-11-23 12:52:13,625 INFO  L133        SettingsManager]:  * sizeof long=4
[2018-11-23 12:52:13,625 INFO  L133        SettingsManager]:  * Overapproximate operations on floating types=true
[2018-11-23 12:52:13,625 INFO  L133        SettingsManager]:  * sizeof POINTER=4
[2018-11-23 12:52:13,625 INFO  L133        SettingsManager]:  * Check division by zero=IGNORE
[2018-11-23 12:52:13,625 INFO  L133        SettingsManager]:  * Pointer to allocated memory at dereference=IGNORE
[2018-11-23 12:52:13,626 INFO  L133        SettingsManager]:  * If two pointers are subtracted or compared they have the same base address=IGNORE
[2018-11-23 12:52:13,626 INFO  L133        SettingsManager]:  * Check array bounds for arrays that are off heap=IGNORE
[2018-11-23 12:52:13,626 INFO  L133        SettingsManager]:  * sizeof long double=12
[2018-11-23 12:52:13,626 INFO  L133        SettingsManager]:  * Check if freed pointer was valid=false
[2018-11-23 12:52:13,626 INFO  L133        SettingsManager]:  * Use constant arrays=true
[2018-11-23 12:52:13,626 INFO  L133        SettingsManager]:  * Pointer base address is valid at dereference=IGNORE
[2018-11-23 12:52:13,627 INFO  L131        SettingsManager]: Preferences of RCFGBuilder differ from their defaults:
[2018-11-23 12:52:13,627 INFO  L133        SettingsManager]:  * Size of a code block=SequenceOfStatements
[2018-11-23 12:52:13,627 INFO  L133        SettingsManager]:  * To the following directory=./dump/
[2018-11-23 12:52:13,627 INFO  L133        SettingsManager]:  * SMT solver=External_DefaultMode
[2018-11-23 12:52:13,627 INFO  L133        SettingsManager]:  * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000
[2018-11-23 12:52:13,628 INFO  L131        SettingsManager]: Preferences of TraceAbstraction differ from their defaults:
[2018-11-23 12:52:13,628 INFO  L133        SettingsManager]:  * Compute Interpolants along a Counterexample=FPandBP
[2018-11-23 12:52:13,628 INFO  L133        SettingsManager]:  * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles
[2018-11-23 12:52:13,628 INFO  L133        SettingsManager]:  * Trace refinement strategy=CAMEL
[2018-11-23 12:52:13,628 INFO  L133        SettingsManager]:  * SMT solver=External_ModelsAndUnsatCoreMode
[2018-11-23 12:52:13,629 INFO  L133        SettingsManager]:  * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in
[2018-11-23 12:52:13,629 INFO  L133        SettingsManager]:  * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true
[2018-11-23 12:52:13,679 INFO  L81    nceAwareModelManager]: Repository-Root is: /tmp
[2018-11-23 12:52:13,696 INFO  L258   ainManager$Toolchain]: [Toolchain 1]: Applicable parser(s) successfully (re)initialized
[2018-11-23 12:52:13,702 INFO  L214   ainManager$Toolchain]: [Toolchain 1]: Toolchain selected.
[2018-11-23 12:52:13,704 INFO  L271        PluginConnector]: Initializing CDTParser...
[2018-11-23 12:52:13,704 INFO  L276        PluginConnector]: CDTParser initialized
[2018-11-23 12:52:13,705 INFO  L418   ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/list-properties/alternating_list_false-unreach-call_false-valid-memcleanup.i
[2018-11-23 12:52:13,776 INFO  L221              CDTParser]: Created temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/a06ac9bc9/7a54b4d9b0dd44679d2167747f7c890d/FLAGa1cd68ee4
[2018-11-23 12:52:14,288 INFO  L307              CDTParser]: Found 1 translation units.
[2018-11-23 12:52:14,289 INFO  L161              CDTParser]: Scanning /storage/repos/ultimate/trunk/examples/svcomp/list-properties/alternating_list_false-unreach-call_false-valid-memcleanup.i
[2018-11-23 12:52:14,303 INFO  L355              CDTParser]: About to delete temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/a06ac9bc9/7a54b4d9b0dd44679d2167747f7c890d/FLAGa1cd68ee4
[2018-11-23 12:52:14,597 INFO  L363              CDTParser]: Successfully deleted /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/a06ac9bc9/7a54b4d9b0dd44679d2167747f7c890d
[2018-11-23 12:52:14,607 INFO  L296   ainManager$Toolchain]: ####################### [Toolchain 1] #######################
[2018-11-23 12:52:14,608 INFO  L131        ToolchainWalker]: Walking toolchain with 6 elements.
[2018-11-23 12:52:14,609 INFO  L113        PluginConnector]: ------------------------CACSL2BoogieTranslator----------------------------
[2018-11-23 12:52:14,610 INFO  L271        PluginConnector]: Initializing CACSL2BoogieTranslator...
[2018-11-23 12:52:14,613 INFO  L276        PluginConnector]: CACSL2BoogieTranslator initialized
[2018-11-23 12:52:14,615 INFO  L185        PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:52:14" (1/1) ...
[2018-11-23 12:52:14,618 INFO  L205        PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@4d11a47 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:14, skipping insertion in model container
[2018-11-23 12:52:14,618 INFO  L185        PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:52:14" (1/1) ...
[2018-11-23 12:52:14,631 INFO  L145         MainTranslator]: Starting translation in SV-COMP mode 
[2018-11-23 12:52:14,688 INFO  L176         MainTranslator]: Built tables and reachable declarations
[2018-11-23 12:52:15,097 INFO  L201          PostProcessor]: Analyzing one entry point: main
[2018-11-23 12:52:15,109 INFO  L191         MainTranslator]: Completed pre-run
[2018-11-23 12:52:15,189 INFO  L201          PostProcessor]: Analyzing one entry point: main
[2018-11-23 12:52:15,250 INFO  L195         MainTranslator]: Completed translation
[2018-11-23 12:52:15,251 INFO  L202        PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15 WrapperNode
[2018-11-23 12:52:15,251 INFO  L132        PluginConnector]: ------------------------ END CACSL2BoogieTranslator----------------------------
[2018-11-23 12:52:15,252 INFO  L113        PluginConnector]: ------------------------Boogie Procedure Inliner----------------------------
[2018-11-23 12:52:15,252 INFO  L271        PluginConnector]: Initializing Boogie Procedure Inliner...
[2018-11-23 12:52:15,252 INFO  L276        PluginConnector]: Boogie Procedure Inliner initialized
[2018-11-23 12:52:15,335 INFO  L185        PluginConnector]: Executing the observer TypeChecker from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,359 INFO  L185        PluginConnector]: Executing the observer Inliner from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,369 INFO  L132        PluginConnector]: ------------------------ END Boogie Procedure Inliner----------------------------
[2018-11-23 12:52:15,369 INFO  L113        PluginConnector]: ------------------------Boogie Preprocessor----------------------------
[2018-11-23 12:52:15,369 INFO  L271        PluginConnector]: Initializing Boogie Preprocessor...
[2018-11-23 12:52:15,369 INFO  L276        PluginConnector]: Boogie Preprocessor initialized
[2018-11-23 12:52:15,377 INFO  L185        PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,377 INFO  L185        PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,381 INFO  L185        PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,382 INFO  L185        PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,403 INFO  L185        PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,413 INFO  L185        PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,415 INFO  L185        PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
[2018-11-23 12:52:15,418 INFO  L132        PluginConnector]: ------------------------ END Boogie Preprocessor----------------------------
[2018-11-23 12:52:15,419 INFO  L113        PluginConnector]: ------------------------RCFGBuilder----------------------------
[2018-11-23 12:52:15,419 INFO  L271        PluginConnector]: Initializing RCFGBuilder...
[2018-11-23 12:52:15,419 INFO  L276        PluginConnector]: RCFGBuilder initialized
[2018-11-23 12:52:15,420 INFO  L185        PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (1/1) ...
No working directory specified, using /storage/repos/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-11-23 12:52:15,479 INFO  L130     BoogieDeclarations]: Found specification of procedure #Ultimate.alloc
[2018-11-23 12:52:15,480 INFO  L130     BoogieDeclarations]: Found specification of procedure read~int
[2018-11-23 12:52:15,480 INFO  L130     BoogieDeclarations]: Found specification of procedure exit
[2018-11-23 12:52:15,480 INFO  L138     BoogieDeclarations]: Found implementation of procedure exit
[2018-11-23 12:52:15,480 INFO  L130     BoogieDeclarations]: Found specification of procedure write~int
[2018-11-23 12:52:15,480 INFO  L130     BoogieDeclarations]: Found specification of procedure ULTIMATE.init
[2018-11-23 12:52:15,481 INFO  L138     BoogieDeclarations]: Found implementation of procedure ULTIMATE.init
[2018-11-23 12:52:15,481 INFO  L130     BoogieDeclarations]: Found specification of procedure main
[2018-11-23 12:52:15,482 INFO  L138     BoogieDeclarations]: Found implementation of procedure main
[2018-11-23 12:52:15,482 INFO  L130     BoogieDeclarations]: Found specification of procedure write~$Pointer$
[2018-11-23 12:52:15,482 INFO  L130     BoogieDeclarations]: Found specification of procedure read~$Pointer$
[2018-11-23 12:52:15,482 INFO  L130     BoogieDeclarations]: Found specification of procedure ULTIMATE.dealloc
[2018-11-23 12:52:15,482 INFO  L130     BoogieDeclarations]: Found specification of procedure ULTIMATE.start
[2018-11-23 12:52:15,482 INFO  L138     BoogieDeclarations]: Found implementation of procedure ULTIMATE.start
[2018-11-23 12:52:16,288 INFO  L275             CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start)
[2018-11-23 12:52:16,288 INFO  L280             CfgBuilder]: Removed 3 assue(true) statements.
[2018-11-23 12:52:16,288 INFO  L202        PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:52:16 BoogieIcfgContainer
[2018-11-23 12:52:16,289 INFO  L132        PluginConnector]: ------------------------ END RCFGBuilder----------------------------
[2018-11-23 12:52:16,290 INFO  L113        PluginConnector]: ------------------------TraceAbstraction----------------------------
[2018-11-23 12:52:16,290 INFO  L271        PluginConnector]: Initializing TraceAbstraction...
[2018-11-23 12:52:16,293 INFO  L276        PluginConnector]: TraceAbstraction initialized
[2018-11-23 12:52:16,294 INFO  L185        PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "CDTParser AST 23.11 12:52:14" (1/3) ...
[2018-11-23 12:52:16,294 INFO  L205        PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3573fc0f and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:52:16, skipping insertion in model container
[2018-11-23 12:52:16,295 INFO  L185        PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:52:15" (2/3) ...
[2018-11-23 12:52:16,295 INFO  L205        PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3573fc0f and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:52:16, skipping insertion in model container
[2018-11-23 12:52:16,295 INFO  L185        PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:52:16" (3/3) ...
[2018-11-23 12:52:16,297 INFO  L112   eAbstractionObserver]: Analyzing ICFG alternating_list_false-unreach-call_false-valid-memcleanup.i
[2018-11-23 12:52:16,308 INFO  L156   ceAbstractionStarter]: Automizer settings: Hoare:true NWA Interpolation:FPandBP Determinization: PREDICATE_ABSTRACTION
[2018-11-23 12:52:16,317 INFO  L168   ceAbstractionStarter]: Appying trace abstraction to program that has 1 error locations.
[2018-11-23 12:52:16,337 INFO  L257      AbstractCegarLoop]: Starting to check reachability of 1 error locations.
[2018-11-23 12:52:16,373 INFO  L133   ementStrategyFactory]: Using default assertion order modulation
[2018-11-23 12:52:16,374 INFO  L382      AbstractCegarLoop]: Interprodecural is true
[2018-11-23 12:52:16,374 INFO  L383      AbstractCegarLoop]: Hoare is true
[2018-11-23 12:52:16,375 INFO  L384      AbstractCegarLoop]: Compute interpolants for FPandBP
[2018-11-23 12:52:16,376 INFO  L385      AbstractCegarLoop]: Backedges is STRAIGHT_LINE
[2018-11-23 12:52:16,376 INFO  L386      AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION
[2018-11-23 12:52:16,376 INFO  L387      AbstractCegarLoop]: Difference is false
[2018-11-23 12:52:16,377 INFO  L388      AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA
[2018-11-23 12:52:16,377 INFO  L393      AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == AllErrorsAtOnce========
[2018-11-23 12:52:16,397 INFO  L276                IsEmpty]: Start isEmpty. Operand 35 states.
[2018-11-23 12:52:16,404 INFO  L282                IsEmpty]: Finished isEmpty. Found accepting run of length 16
[2018-11-23 12:52:16,404 INFO  L394         BasicCegarLoop]: Found error trace
[2018-11-23 12:52:16,405 INFO  L402         BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2018-11-23 12:52:16,408 INFO  L423      AbstractCegarLoop]: === Iteration 1 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]===
[2018-11-23 12:52:16,414 INFO  L141       PredicateUnifier]: Initialized classic predicate unifier
[2018-11-23 12:52:16,415 INFO  L82        PathProgramCache]: Analyzing trace with hash 985352840, now seen corresponding path program 1 times
[2018-11-23 12:52:16,417 INFO  L223   ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS
[2018-11-23 12:52:16,418 INFO  L69    tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy
[2018-11-23 12:52:16,475 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:16,475 INFO  L103   rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY
[2018-11-23 12:52:16,476 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:16,518 INFO  L136    AnnotateAndAsserter]: Conjunction of SSA is unsat
[2018-11-23 12:52:16,578 INFO  L256        TraceCheckUtils]: 0: Hoare triple {38#true} call ULTIMATE.init(); {38#true} is VALID
[2018-11-23 12:52:16,581 INFO  L273        TraceCheckUtils]: 1: Hoare triple {38#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {38#true} is VALID
[2018-11-23 12:52:16,582 INFO  L273        TraceCheckUtils]: 2: Hoare triple {38#true} assume true; {38#true} is VALID
[2018-11-23 12:52:16,582 INFO  L268        TraceCheckUtils]: 3: Hoare quadruple {38#true} {38#true} #97#return; {38#true} is VALID
[2018-11-23 12:52:16,583 INFO  L256        TraceCheckUtils]: 4: Hoare triple {38#true} call #t~ret10 := main(); {38#true} is VALID
[2018-11-23 12:52:16,583 INFO  L273        TraceCheckUtils]: 5: Hoare triple {38#true} ~flag~0 := 1;call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset; {38#true} is VALID
[2018-11-23 12:52:16,583 INFO  L273        TraceCheckUtils]: 6: Hoare triple {38#true} assume !(~a~0.base == 0 && ~a~0.offset == 0); {38#true} is VALID
[2018-11-23 12:52:16,584 INFO  L273        TraceCheckUtils]: 7: Hoare triple {38#true} havoc ~t~0.base, ~t~0.offset;~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset; {38#true} is VALID
[2018-11-23 12:52:16,587 INFO  L273        TraceCheckUtils]: 8: Hoare triple {38#true} assume !true; {39#false} is VALID
[2018-11-23 12:52:16,587 INFO  L273        TraceCheckUtils]: 9: Hoare triple {39#false} call write~int(3, ~p~0.base, ~p~0.offset, 4);~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;~flag~0 := 1; {39#false} is VALID
[2018-11-23 12:52:16,588 INFO  L273        TraceCheckUtils]: 10: Hoare triple {39#false} call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4); {39#false} is VALID
[2018-11-23 12:52:16,588 INFO  L273        TraceCheckUtils]: 11: Hoare triple {39#false} assume !!(3 != #t~mem4);havoc #t~mem4; {39#false} is VALID
[2018-11-23 12:52:16,589 INFO  L273        TraceCheckUtils]: 12: Hoare triple {39#false} assume !(0 != ~flag~0);~flag~0 := 1;call #t~mem6 := read~int(~p~0.base, ~p~0.offset, 4); {39#false} is VALID
[2018-11-23 12:52:16,589 INFO  L273        TraceCheckUtils]: 13: Hoare triple {39#false} assume 2 != #t~mem6;havoc #t~mem6; {39#false} is VALID
[2018-11-23 12:52:16,589 INFO  L273        TraceCheckUtils]: 14: Hoare triple {39#false} assume !false; {39#false} is VALID
[2018-11-23 12:52:16,592 INFO  L134       CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked.
[2018-11-23 12:52:16,594 INFO  L312   seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences.
[2018-11-23 12:52:16,595 INFO  L327   seRefinementStrategy]: Number of different interpolants: perfect sequences [2] imperfect sequences [] total 2
[2018-11-23 12:52:16,600 INFO  L78                 Accepts]: Start accepts. Automaton has 2 states. Word has length 15
[2018-11-23 12:52:16,603 INFO  L84                 Accepts]: Finished accepts. word is accepted.
[2018-11-23 12:52:16,606 INFO  L86        InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states.
[2018-11-23 12:52:16,678 INFO  L119       InductivityCheck]: Floyd-Hoare automaton has 15 edges. 15 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. 
[2018-11-23 12:52:16,678 INFO  L459      AbstractCegarLoop]: Interpolant automaton has 2 states
[2018-11-23 12:52:16,688 INFO  L142   InterpolantAutomaton]: Constructing interpolant automaton starting with 2 interpolants.
[2018-11-23 12:52:16,689 INFO  L144   InterpolantAutomaton]: CoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2
[2018-11-23 12:52:16,692 INFO  L87              Difference]: Start difference. First operand 35 states. Second operand 2 states.
[2018-11-23 12:52:17,018 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:17,018 INFO  L93              Difference]: Finished difference Result 52 states and 69 transitions.
[2018-11-23 12:52:17,018 INFO  L142   InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 2 states. 
[2018-11-23 12:52:17,018 INFO  L78                 Accepts]: Start accepts. Automaton has 2 states. Word has length 15
[2018-11-23 12:52:17,019 INFO  L84                 Accepts]: Finished accepts. some prefix is accepted.
[2018-11-23 12:52:17,020 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 2 states.
[2018-11-23 12:52:17,035 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 69 transitions.
[2018-11-23 12:52:17,035 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 2 states.
[2018-11-23 12:52:17,040 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 69 transitions.
[2018-11-23 12:52:17,040 INFO  L86        InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states and 69 transitions.
[2018-11-23 12:52:17,326 INFO  L119       InductivityCheck]: Floyd-Hoare automaton has 69 edges. 69 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. 
[2018-11-23 12:52:17,337 INFO  L225             Difference]: With dead ends: 52
[2018-11-23 12:52:17,337 INFO  L226             Difference]: Without dead ends: 23
[2018-11-23 12:52:17,341 INFO  L631         BasicCegarLoop]: 0 DeclaredPredicates, 2 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 0 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2
[2018-11-23 12:52:17,359 INFO  L82        GeneralOperation]: Start minimizeSevpa. Operand 23 states.
[2018-11-23 12:52:17,378 INFO  L88        GeneralOperation]: Finished minimizeSevpa. Reduced states from 23 to 23.
[2018-11-23 12:52:17,379 INFO  L214    AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa
[2018-11-23 12:52:17,379 INFO  L82        GeneralOperation]: Start isEquivalent. First operand 23 states. Second operand 23 states.
[2018-11-23 12:52:17,380 INFO  L74              IsIncluded]: Start isIncluded. First operand 23 states. Second operand 23 states.
[2018-11-23 12:52:17,380 INFO  L87              Difference]: Start difference. First operand 23 states. Second operand 23 states.
[2018-11-23 12:52:17,383 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:17,384 INFO  L93              Difference]: Finished difference Result 23 states and 27 transitions.
[2018-11-23 12:52:17,384 INFO  L276                IsEmpty]: Start isEmpty. Operand 23 states and 27 transitions.
[2018-11-23 12:52:17,384 INFO  L282                IsEmpty]: Finished isEmpty. No accepting run.
[2018-11-23 12:52:17,385 INFO  L83              IsIncluded]: Finished isIncluded. Language is included
[2018-11-23 12:52:17,385 INFO  L74              IsIncluded]: Start isIncluded. First operand 23 states. Second operand 23 states.
[2018-11-23 12:52:17,385 INFO  L87              Difference]: Start difference. First operand 23 states. Second operand 23 states.
[2018-11-23 12:52:17,391 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:17,391 INFO  L93              Difference]: Finished difference Result 23 states and 27 transitions.
[2018-11-23 12:52:17,392 INFO  L276                IsEmpty]: Start isEmpty. Operand 23 states and 27 transitions.
[2018-11-23 12:52:17,392 INFO  L282                IsEmpty]: Finished isEmpty. No accepting run.
[2018-11-23 12:52:17,394 INFO  L83              IsIncluded]: Finished isIncluded. Language is included
[2018-11-23 12:52:17,394 INFO  L88        GeneralOperation]: Finished isEquivalent.
[2018-11-23 12:52:17,394 INFO  L221    AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa
[2018-11-23 12:52:17,395 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 23 states.
[2018-11-23 12:52:17,397 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 27 transitions.
[2018-11-23 12:52:17,399 INFO  L78                 Accepts]: Start accepts. Automaton has 23 states and 27 transitions. Word has length 15
[2018-11-23 12:52:17,399 INFO  L84                 Accepts]: Finished accepts. word is rejected.
[2018-11-23 12:52:17,399 INFO  L480      AbstractCegarLoop]: Abstraction has 23 states and 27 transitions.
[2018-11-23 12:52:17,399 INFO  L481      AbstractCegarLoop]: Interpolant automaton has 2 states.
[2018-11-23 12:52:17,400 INFO  L276                IsEmpty]: Start isEmpty. Operand 23 states and 27 transitions.
[2018-11-23 12:52:17,400 INFO  L282                IsEmpty]: Finished isEmpty. Found accepting run of length 17
[2018-11-23 12:52:17,401 INFO  L394         BasicCegarLoop]: Found error trace
[2018-11-23 12:52:17,401 INFO  L402         BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2018-11-23 12:52:17,401 INFO  L423      AbstractCegarLoop]: === Iteration 2 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]===
[2018-11-23 12:52:17,401 INFO  L141       PredicateUnifier]: Initialized classic predicate unifier
[2018-11-23 12:52:17,402 INFO  L82        PathProgramCache]: Analyzing trace with hash -811727628, now seen corresponding path program 1 times
[2018-11-23 12:52:17,402 INFO  L223   ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS
[2018-11-23 12:52:17,402 INFO  L69    tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy
[2018-11-23 12:52:17,403 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:17,403 INFO  L103   rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY
[2018-11-23 12:52:17,403 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:17,441 INFO  L136    AnnotateAndAsserter]: Conjunction of SSA is unsat
[2018-11-23 12:52:17,520 INFO  L256        TraceCheckUtils]: 0: Hoare triple {185#true} call ULTIMATE.init(); {185#true} is VALID
[2018-11-23 12:52:17,520 INFO  L273        TraceCheckUtils]: 1: Hoare triple {185#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {185#true} is VALID
[2018-11-23 12:52:17,521 INFO  L273        TraceCheckUtils]: 2: Hoare triple {185#true} assume true; {185#true} is VALID
[2018-11-23 12:52:17,522 INFO  L268        TraceCheckUtils]: 3: Hoare quadruple {185#true} {185#true} #97#return; {185#true} is VALID
[2018-11-23 12:52:17,522 INFO  L256        TraceCheckUtils]: 4: Hoare triple {185#true} call #t~ret10 := main(); {185#true} is VALID
[2018-11-23 12:52:17,522 INFO  L273        TraceCheckUtils]: 5: Hoare triple {185#true} ~flag~0 := 1;call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset; {185#true} is VALID
[2018-11-23 12:52:17,523 INFO  L273        TraceCheckUtils]: 6: Hoare triple {185#true} assume !(~a~0.base == 0 && ~a~0.offset == 0); {185#true} is VALID
[2018-11-23 12:52:17,523 INFO  L273        TraceCheckUtils]: 7: Hoare triple {185#true} havoc ~t~0.base, ~t~0.offset;~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset; {185#true} is VALID
[2018-11-23 12:52:17,523 INFO  L273        TraceCheckUtils]: 8: Hoare triple {185#true} assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; {185#true} is VALID
[2018-11-23 12:52:17,524 INFO  L273        TraceCheckUtils]: 9: Hoare triple {185#true} assume !(0 != #t~nondet1);havoc #t~nondet1; {185#true} is VALID
[2018-11-23 12:52:17,526 INFO  L273        TraceCheckUtils]: 10: Hoare triple {185#true} call write~int(3, ~p~0.base, ~p~0.offset, 4);~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;~flag~0 := 1; {187#(= main_~flag~0 1)} is VALID
[2018-11-23 12:52:17,526 INFO  L273        TraceCheckUtils]: 11: Hoare triple {187#(= main_~flag~0 1)} call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4); {187#(= main_~flag~0 1)} is VALID
[2018-11-23 12:52:17,528 INFO  L273        TraceCheckUtils]: 12: Hoare triple {187#(= main_~flag~0 1)} assume !!(3 != #t~mem4);havoc #t~mem4; {187#(= main_~flag~0 1)} is VALID
[2018-11-23 12:52:17,528 INFO  L273        TraceCheckUtils]: 13: Hoare triple {187#(= main_~flag~0 1)} assume !(0 != ~flag~0);~flag~0 := 1;call #t~mem6 := read~int(~p~0.base, ~p~0.offset, 4); {186#false} is VALID
[2018-11-23 12:52:17,529 INFO  L273        TraceCheckUtils]: 14: Hoare triple {186#false} assume 2 != #t~mem6;havoc #t~mem6; {186#false} is VALID
[2018-11-23 12:52:17,529 INFO  L273        TraceCheckUtils]: 15: Hoare triple {186#false} assume !false; {186#false} is VALID
[2018-11-23 12:52:17,531 INFO  L134       CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked.
[2018-11-23 12:52:17,532 INFO  L312   seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences.
[2018-11-23 12:52:17,532 INFO  L327   seRefinementStrategy]: Number of different interpolants: perfect sequences [3] imperfect sequences [] total 3
[2018-11-23 12:52:17,533 INFO  L78                 Accepts]: Start accepts. Automaton has 3 states. Word has length 16
[2018-11-23 12:52:17,534 INFO  L84                 Accepts]: Finished accepts. word is accepted.
[2018-11-23 12:52:17,534 INFO  L86        InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states.
[2018-11-23 12:52:17,654 INFO  L119       InductivityCheck]: Floyd-Hoare automaton has 16 edges. 16 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. 
[2018-11-23 12:52:17,654 INFO  L459      AbstractCegarLoop]: Interpolant automaton has 3 states
[2018-11-23 12:52:17,654 INFO  L142   InterpolantAutomaton]: Constructing interpolant automaton starting with 3 interpolants.
[2018-11-23 12:52:17,654 INFO  L144   InterpolantAutomaton]: CoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6
[2018-11-23 12:52:17,655 INFO  L87              Difference]: Start difference. First operand 23 states and 27 transitions. Second operand 3 states.
[2018-11-23 12:52:18,172 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:18,172 INFO  L93              Difference]: Finished difference Result 51 states and 61 transitions.
[2018-11-23 12:52:18,172 INFO  L142   InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 3 states. 
[2018-11-23 12:52:18,172 INFO  L78                 Accepts]: Start accepts. Automaton has 3 states. Word has length 16
[2018-11-23 12:52:18,173 INFO  L84                 Accepts]: Finished accepts. some prefix is accepted.
[2018-11-23 12:52:18,173 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 3 states.
[2018-11-23 12:52:18,176 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 61 transitions.
[2018-11-23 12:52:18,176 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 3 states.
[2018-11-23 12:52:18,178 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 61 transitions.
[2018-11-23 12:52:18,179 INFO  L86        InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states and 61 transitions.
[2018-11-23 12:52:18,370 INFO  L119       InductivityCheck]: Floyd-Hoare automaton has 61 edges. 61 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. 
[2018-11-23 12:52:18,373 INFO  L225             Difference]: With dead ends: 51
[2018-11-23 12:52:18,373 INFO  L226             Difference]: Without dead ends: 36
[2018-11-23 12:52:18,375 INFO  L631         BasicCegarLoop]: 0 DeclaredPredicates, 3 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 1 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6
[2018-11-23 12:52:18,375 INFO  L82        GeneralOperation]: Start minimizeSevpa. Operand 36 states.
[2018-11-23 12:52:18,392 INFO  L88        GeneralOperation]: Finished minimizeSevpa. Reduced states from 36 to 33.
[2018-11-23 12:52:18,392 INFO  L214    AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa
[2018-11-23 12:52:18,392 INFO  L82        GeneralOperation]: Start isEquivalent. First operand 36 states. Second operand 33 states.
[2018-11-23 12:52:18,392 INFO  L74              IsIncluded]: Start isIncluded. First operand 36 states. Second operand 33 states.
[2018-11-23 12:52:18,393 INFO  L87              Difference]: Start difference. First operand 36 states. Second operand 33 states.
[2018-11-23 12:52:18,395 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:18,396 INFO  L93              Difference]: Finished difference Result 36 states and 40 transitions.
[2018-11-23 12:52:18,396 INFO  L276                IsEmpty]: Start isEmpty. Operand 36 states and 40 transitions.
[2018-11-23 12:52:18,397 INFO  L282                IsEmpty]: Finished isEmpty. No accepting run.
[2018-11-23 12:52:18,397 INFO  L83              IsIncluded]: Finished isIncluded. Language is included
[2018-11-23 12:52:18,397 INFO  L74              IsIncluded]: Start isIncluded. First operand 33 states. Second operand 36 states.
[2018-11-23 12:52:18,397 INFO  L87              Difference]: Start difference. First operand 33 states. Second operand 36 states.
[2018-11-23 12:52:18,400 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:18,400 INFO  L93              Difference]: Finished difference Result 36 states and 40 transitions.
[2018-11-23 12:52:18,400 INFO  L276                IsEmpty]: Start isEmpty. Operand 36 states and 40 transitions.
[2018-11-23 12:52:18,401 INFO  L282                IsEmpty]: Finished isEmpty. No accepting run.
[2018-11-23 12:52:18,401 INFO  L83              IsIncluded]: Finished isIncluded. Language is included
[2018-11-23 12:52:18,401 INFO  L88        GeneralOperation]: Finished isEquivalent.
[2018-11-23 12:52:18,401 INFO  L221    AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa
[2018-11-23 12:52:18,402 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 33 states.
[2018-11-23 12:52:18,404 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 33 states to 33 states and 38 transitions.
[2018-11-23 12:52:18,404 INFO  L78                 Accepts]: Start accepts. Automaton has 33 states and 38 transitions. Word has length 16
[2018-11-23 12:52:18,404 INFO  L84                 Accepts]: Finished accepts. word is rejected.
[2018-11-23 12:52:18,405 INFO  L480      AbstractCegarLoop]: Abstraction has 33 states and 38 transitions.
[2018-11-23 12:52:18,405 INFO  L481      AbstractCegarLoop]: Interpolant automaton has 3 states.
[2018-11-23 12:52:18,405 INFO  L276                IsEmpty]: Start isEmpty. Operand 33 states and 38 transitions.
[2018-11-23 12:52:18,406 INFO  L282                IsEmpty]: Finished isEmpty. Found accepting run of length 17
[2018-11-23 12:52:18,406 INFO  L394         BasicCegarLoop]: Found error trace
[2018-11-23 12:52:18,406 INFO  L402         BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2018-11-23 12:52:18,406 INFO  L423      AbstractCegarLoop]: === Iteration 3 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]===
[2018-11-23 12:52:18,406 INFO  L141       PredicateUnifier]: Initialized classic predicate unifier
[2018-11-23 12:52:18,407 INFO  L82        PathProgramCache]: Analyzing trace with hash -811734572, now seen corresponding path program 1 times
[2018-11-23 12:52:18,407 INFO  L223   ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS
[2018-11-23 12:52:18,407 INFO  L69    tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy
[2018-11-23 12:52:18,408 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:18,408 INFO  L103   rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY
[2018-11-23 12:52:18,409 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:18,421 INFO  L136    AnnotateAndAsserter]: Conjunction of SSA is unsat
[2018-11-23 12:52:18,560 INFO  L256        TraceCheckUtils]: 0: Hoare triple {368#true} call ULTIMATE.init(); {368#true} is VALID
[2018-11-23 12:52:18,560 INFO  L273        TraceCheckUtils]: 1: Hoare triple {368#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {368#true} is VALID
[2018-11-23 12:52:18,560 INFO  L273        TraceCheckUtils]: 2: Hoare triple {368#true} assume true; {368#true} is VALID
[2018-11-23 12:52:18,561 INFO  L268        TraceCheckUtils]: 3: Hoare quadruple {368#true} {368#true} #97#return; {368#true} is VALID
[2018-11-23 12:52:18,561 INFO  L256        TraceCheckUtils]: 4: Hoare triple {368#true} call #t~ret10 := main(); {368#true} is VALID
[2018-11-23 12:52:18,562 INFO  L273        TraceCheckUtils]: 5: Hoare triple {368#true} ~flag~0 := 1;call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset; {368#true} is VALID
[2018-11-23 12:52:18,562 INFO  L273        TraceCheckUtils]: 6: Hoare triple {368#true} assume !(~a~0.base == 0 && ~a~0.offset == 0); {368#true} is VALID
[2018-11-23 12:52:18,563 INFO  L273        TraceCheckUtils]: 7: Hoare triple {368#true} havoc ~t~0.base, ~t~0.offset;~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset; {370#(and (= main_~p~0.offset main_~a~0.offset) (= main_~p~0.base main_~a~0.base))} is VALID
[2018-11-23 12:52:18,564 INFO  L273        TraceCheckUtils]: 8: Hoare triple {370#(and (= main_~p~0.offset main_~a~0.offset) (= main_~p~0.base main_~a~0.base))} assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; {370#(and (= main_~p~0.offset main_~a~0.offset) (= main_~p~0.base main_~a~0.base))} is VALID
[2018-11-23 12:52:18,564 INFO  L273        TraceCheckUtils]: 9: Hoare triple {370#(and (= main_~p~0.offset main_~a~0.offset) (= main_~p~0.base main_~a~0.base))} assume !(0 != #t~nondet1);havoc #t~nondet1; {370#(and (= main_~p~0.offset main_~a~0.offset) (= main_~p~0.base main_~a~0.base))} is VALID
[2018-11-23 12:52:18,565 INFO  L273        TraceCheckUtils]: 10: Hoare triple {370#(and (= main_~p~0.offset main_~a~0.offset) (= main_~p~0.base main_~a~0.base))} call write~int(3, ~p~0.base, ~p~0.offset, 4);~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;~flag~0 := 1; {371#(= 3 (select (select |#memory_int| main_~p~0.base) main_~p~0.offset))} is VALID
[2018-11-23 12:52:18,566 INFO  L273        TraceCheckUtils]: 11: Hoare triple {371#(= 3 (select (select |#memory_int| main_~p~0.base) main_~p~0.offset))} call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4); {372#(= |main_#t~mem4| 3)} is VALID
[2018-11-23 12:52:18,567 INFO  L273        TraceCheckUtils]: 12: Hoare triple {372#(= |main_#t~mem4| 3)} assume !!(3 != #t~mem4);havoc #t~mem4; {369#false} is VALID
[2018-11-23 12:52:18,567 INFO  L273        TraceCheckUtils]: 13: Hoare triple {369#false} assume 0 != ~flag~0;~flag~0 := 0;call #t~mem5 := read~int(~p~0.base, ~p~0.offset, 4); {369#false} is VALID
[2018-11-23 12:52:18,568 INFO  L273        TraceCheckUtils]: 14: Hoare triple {369#false} assume 1 != #t~mem5;havoc #t~mem5; {369#false} is VALID
[2018-11-23 12:52:18,568 INFO  L273        TraceCheckUtils]: 15: Hoare triple {369#false} assume !false; {369#false} is VALID
[2018-11-23 12:52:18,570 INFO  L134       CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked.
[2018-11-23 12:52:18,570 INFO  L312   seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences.
[2018-11-23 12:52:18,571 INFO  L327   seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5
[2018-11-23 12:52:18,571 INFO  L78                 Accepts]: Start accepts. Automaton has 5 states. Word has length 16
[2018-11-23 12:52:18,571 INFO  L84                 Accepts]: Finished accepts. word is accepted.
[2018-11-23 12:52:18,572 INFO  L86        InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states.
[2018-11-23 12:52:18,596 INFO  L119       InductivityCheck]: Floyd-Hoare automaton has 16 edges. 16 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. 
[2018-11-23 12:52:18,597 INFO  L459      AbstractCegarLoop]: Interpolant automaton has 5 states
[2018-11-23 12:52:18,597 INFO  L142   InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants.
[2018-11-23 12:52:18,598 INFO  L144   InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20
[2018-11-23 12:52:18,598 INFO  L87              Difference]: Start difference. First operand 33 states and 38 transitions. Second operand 5 states.
[2018-11-23 12:52:18,943 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:18,943 INFO  L93              Difference]: Finished difference Result 61 states and 69 transitions.
[2018-11-23 12:52:18,943 INFO  L142   InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. 
[2018-11-23 12:52:18,944 INFO  L78                 Accepts]: Start accepts. Automaton has 5 states. Word has length 16
[2018-11-23 12:52:18,944 INFO  L84                 Accepts]: Finished accepts. some prefix is accepted.
[2018-11-23 12:52:18,944 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 5 states.
[2018-11-23 12:52:18,947 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 54 transitions.
[2018-11-23 12:52:18,947 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 5 states.
[2018-11-23 12:52:18,949 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 54 transitions.
[2018-11-23 12:52:18,949 INFO  L86        InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 54 transitions.
[2018-11-23 12:52:19,048 INFO  L119       InductivityCheck]: Floyd-Hoare automaton has 54 edges. 54 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. 
[2018-11-23 12:52:19,050 INFO  L225             Difference]: With dead ends: 61
[2018-11-23 12:52:19,050 INFO  L226             Difference]: Without dead ends: 46
[2018-11-23 12:52:19,051 INFO  L631         BasicCegarLoop]: 0 DeclaredPredicates, 8 GetRequests, 2 SyntacticMatches, 1 SemanticMatches, 5 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=17, Invalid=25, Unknown=0, NotChecked=0, Total=42
[2018-11-23 12:52:19,051 INFO  L82        GeneralOperation]: Start minimizeSevpa. Operand 46 states.
[2018-11-23 12:52:19,071 INFO  L88        GeneralOperation]: Finished minimizeSevpa. Reduced states from 46 to 35.
[2018-11-23 12:52:19,072 INFO  L214    AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa
[2018-11-23 12:52:19,072 INFO  L82        GeneralOperation]: Start isEquivalent. First operand 46 states. Second operand 35 states.
[2018-11-23 12:52:19,072 INFO  L74              IsIncluded]: Start isIncluded. First operand 46 states. Second operand 35 states.
[2018-11-23 12:52:19,072 INFO  L87              Difference]: Start difference. First operand 46 states. Second operand 35 states.
[2018-11-23 12:52:19,076 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:19,076 INFO  L93              Difference]: Finished difference Result 46 states and 51 transitions.
[2018-11-23 12:52:19,076 INFO  L276                IsEmpty]: Start isEmpty. Operand 46 states and 51 transitions.
[2018-11-23 12:52:19,077 INFO  L282                IsEmpty]: Finished isEmpty. No accepting run.
[2018-11-23 12:52:19,077 INFO  L83              IsIncluded]: Finished isIncluded. Language is included
[2018-11-23 12:52:19,077 INFO  L74              IsIncluded]: Start isIncluded. First operand 35 states. Second operand 46 states.
[2018-11-23 12:52:19,078 INFO  L87              Difference]: Start difference. First operand 35 states. Second operand 46 states.
[2018-11-23 12:52:19,080 INFO  L144             Difference]: Subtrahend was deterministic. Have not used determinization.
[2018-11-23 12:52:19,081 INFO  L93              Difference]: Finished difference Result 46 states and 51 transitions.
[2018-11-23 12:52:19,081 INFO  L276                IsEmpty]: Start isEmpty. Operand 46 states and 51 transitions.
[2018-11-23 12:52:19,082 INFO  L282                IsEmpty]: Finished isEmpty. No accepting run.
[2018-11-23 12:52:19,082 INFO  L83              IsIncluded]: Finished isIncluded. Language is included
[2018-11-23 12:52:19,082 INFO  L88        GeneralOperation]: Finished isEquivalent.
[2018-11-23 12:52:19,082 INFO  L221    AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa
[2018-11-23 12:52:19,082 INFO  L82        GeneralOperation]: Start removeUnreachable. Operand 35 states.
[2018-11-23 12:52:19,084 INFO  L88        GeneralOperation]: Finished removeUnreachable. Reduced from 35 states to 35 states and 40 transitions.
[2018-11-23 12:52:19,085 INFO  L78                 Accepts]: Start accepts. Automaton has 35 states and 40 transitions. Word has length 16
[2018-11-23 12:52:19,085 INFO  L84                 Accepts]: Finished accepts. word is rejected.
[2018-11-23 12:52:19,085 INFO  L480      AbstractCegarLoop]: Abstraction has 35 states and 40 transitions.
[2018-11-23 12:52:19,085 INFO  L481      AbstractCegarLoop]: Interpolant automaton has 5 states.
[2018-11-23 12:52:19,085 INFO  L276                IsEmpty]: Start isEmpty. Operand 35 states and 40 transitions.
[2018-11-23 12:52:19,086 INFO  L282                IsEmpty]: Finished isEmpty. Found accepting run of length 23
[2018-11-23 12:52:19,086 INFO  L394         BasicCegarLoop]: Found error trace
[2018-11-23 12:52:19,087 INFO  L402         BasicCegarLoop]: trace histogram [2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2018-11-23 12:52:19,087 INFO  L423      AbstractCegarLoop]: === Iteration 4 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]===
[2018-11-23 12:52:19,087 INFO  L141       PredicateUnifier]: Initialized classic predicate unifier
[2018-11-23 12:52:19,087 INFO  L82        PathProgramCache]: Analyzing trace with hash -506955009, now seen corresponding path program 1 times
[2018-11-23 12:52:19,088 INFO  L223   ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS
[2018-11-23 12:52:19,088 INFO  L69    tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy
[2018-11-23 12:52:19,089 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:19,089 INFO  L103   rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY
[2018-11-23 12:52:19,089 INFO  L119   rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY
[2018-11-23 12:52:19,122 INFO  L136    AnnotateAndAsserter]: Conjunction of SSA is sat
[2018-11-23 12:52:19,144 INFO  L136    AnnotateAndAsserter]: Conjunction of SSA is sat
[2018-11-23 12:52:19,174 INFO  L469         BasicCegarLoop]: Counterexample might be feasible
-----
class de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.RCFGBacktranslator
[?]  CALL  call ULTIMATE.init();
     VAL   [|#NULL.base|=16, |#NULL.offset|=10, |old(#NULL.base)|=16, |old(#NULL.offset)|=10]
[?]        #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];
     VAL   [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=16, |old(#NULL.offset)|=10]
[?]        assume true;
     VAL   [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=16, |old(#NULL.offset)|=10]
[?]  RET   #97#return;
     VAL   [|#NULL.base|=0, |#NULL.offset|=0]
[?]  CALL  call #t~ret10 := main();
     VAL   [|#NULL.base|=0, |#NULL.offset|=0]
[?]        ~flag~0 := 1;call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        assume !(~a~0.base == 0 && ~a~0.offset == 0);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        havoc ~t~0.base, ~t~0.offset;~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~nondet1|=1]
[?]        assume !!(0 != #t~nondet1);havoc #t~nondet1;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        assume 0 != ~flag~0;call write~int(2, ~p~0.base, ~p~0.offset, 4);~flag~0 := 0;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        call #t~malloc2.base, #t~malloc2.offset := #Ultimate.alloc(8);~t~0.base, ~t~0.offset := #t~malloc2.base, #t~malloc2.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume !(~t~0.base == 0 && ~t~0.offset == 0);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        call write~$Pointer$(~t~0.base, ~t~0.offset, ~p~0.base, 4 + ~p~0.offset, 4);call #t~mem3.base, #t~mem3.offset := read~$Pointer$(~p~0.base, 4 + ~p~0.offset, 4);~p~0.base, ~p~0.offset := #t~mem3.base, #t~mem3.offset;havoc #t~mem3.base, #t~mem3.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=17, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=17, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0, |main_#t~nondet1|=0]
[?]        assume !(0 != #t~nondet1);havoc #t~nondet1;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=17, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        call write~int(3, ~p~0.base, ~p~0.offset, 4);~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;~flag~0 := 1;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0, |main_#t~mem4|=2]
[?]        assume !!(3 != #t~mem4);havoc #t~mem4;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume 0 != ~flag~0;~flag~0 := 0;call #t~mem5 := read~int(~p~0.base, ~p~0.offset, 4);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0, |main_#t~mem5|=2]
[?]        assume 1 != #t~mem5;havoc #t~mem5;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume !false;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]


[?]          CALL  call ULTIMATE.init();
             VAL   [#NULL.base=16, #NULL.offset=10, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                #NULL.base, #NULL.offset := 0, 0;
[?]                #valid := #valid[0 := 0];
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                ensures true;
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]          RET   call ULTIMATE.init();
             VAL   [#NULL.base=0, #NULL.offset=0]
[?]          CALL  call #t~ret10 := main();
             VAL   [#NULL.base=0, #NULL.offset=0]
[L627]             ~flag~0 := 1;
[L628]             call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);
[L628]             ~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L629]             assume !(~a~0.base == 0 && ~a~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L630]             havoc ~t~0.base, ~t~0.offset;
[L631]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~nondet1=1, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632-L644]        assume !!(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L633-L639]        assume 0 != ~flag~0;
[L634]             call write~int(2, ~p~0.base, ~p~0.offset, 4);
[L635]             ~flag~0 := 0;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0]
[L640]             call #t~malloc2.base, #t~malloc2.offset := #Ultimate.alloc(8);
[L640]             ~t~0.base, ~t~0.offset := #t~malloc2.base, #t~malloc2.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L641]             assume !(~t~0.base == 0 && ~t~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L642]             call write~$Pointer$(~t~0.base, ~t~0.offset, ~p~0.base, 4 + ~p~0.offset, 4);
[L643]             call #t~mem3.base, #t~mem3.offset := read~$Pointer$(~p~0.base, 4 + ~p~0.offset, 4);
[L643]             ~p~0.base, ~p~0.offset := #t~mem3.base, #t~mem3.offset;
[L643]             havoc #t~mem3.base, #t~mem3.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~nondet1=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632-L644]        assume !(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L645]             call write~int(3, ~p~0.base, ~p~0.offset, 4);
[L646]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
[L647]             ~flag~0 := 1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648]             call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem4=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648-L659]        assume !!(3 != #t~mem4);
[L648]             havoc #t~mem4;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L649-L657]        assume 0 != ~flag~0;
[L650]             ~flag~0 := 0;
[L651]             call #t~mem5 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem5=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L651-L652]        assume 1 != #t~mem5;
[L651]             havoc #t~mem5;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L668]             assert false;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]

-----
-----
class de.uni_freiburg.informatik.ultimate.boogie.preprocessor.BoogiePreprocessorBacktranslator
[?]          CALL  call ULTIMATE.init();
             VAL   [#NULL.base=16, #NULL.offset=10, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                #NULL.base, #NULL.offset := 0, 0;
[?]                #valid := #valid[0 := 0];
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                ensures true;
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]          RET   call ULTIMATE.init();
             VAL   [#NULL.base=0, #NULL.offset=0]
[?]          CALL  call #t~ret10 := main();
             VAL   [#NULL.base=0, #NULL.offset=0]
[L627]             ~flag~0 := 1;
[L628]             call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);
[L628]             ~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L629]             assume !(~a~0.base == 0 && ~a~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L630]             havoc ~t~0.base, ~t~0.offset;
[L631]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~nondet1=1, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632-L644]        assume !!(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L633-L639]        assume 0 != ~flag~0;
[L634]             call write~int(2, ~p~0.base, ~p~0.offset, 4);
[L635]             ~flag~0 := 0;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0]
[L640]             call #t~malloc2.base, #t~malloc2.offset := #Ultimate.alloc(8);
[L640]             ~t~0.base, ~t~0.offset := #t~malloc2.base, #t~malloc2.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L641]             assume !(~t~0.base == 0 && ~t~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L642]             call write~$Pointer$(~t~0.base, ~t~0.offset, ~p~0.base, 4 + ~p~0.offset, 4);
[L643]             call #t~mem3.base, #t~mem3.offset := read~$Pointer$(~p~0.base, 4 + ~p~0.offset, 4);
[L643]             ~p~0.base, ~p~0.offset := #t~mem3.base, #t~mem3.offset;
[L643]             havoc #t~mem3.base, #t~mem3.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~nondet1=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632-L644]        assume !(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L645]             call write~int(3, ~p~0.base, ~p~0.offset, 4);
[L646]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
[L647]             ~flag~0 := 1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648]             call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem4=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648-L659]        assume !!(3 != #t~mem4);
[L648]             havoc #t~mem4;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L649-L657]        assume 0 != ~flag~0;
[L650]             ~flag~0 := 0;
[L651]             call #t~mem5 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem5=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L651-L652]        assume 1 != #t~mem5;
[L651]             havoc #t~mem5;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L668]             assert false;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]


[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]

-----
-----
class de.uni_freiburg.informatik.ultimate.boogie.procedureinliner.backtranslation.InlinerBacktranslator
[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]


[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]

-----
-----
class de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.CACSL2BoogieBacktranslator
[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]


[L627]              int flag = 1;
[L628]              List a = (List) malloc(sizeof(struct node));
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}]
[L629]  COND FALSE  !(a == 0)
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}]
[L630]              List t;
[L631]              List p = a;
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, p={14:0}]
[L632]  COND TRUE   __VERIFIER_nondet_int()
[L633]  COND TRUE   \read(flag)
[L634]              p->h = 2
[L635]              flag = 0
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, p={14:0}]
[L640]              t = (List) malloc(sizeof(struct node))
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L641]  COND FALSE  !(t == 0)
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L642]              p->n = t
[L643]  EXPR        p->n
[L643]              p = p->n
[L632]  COND FALSE  !(__VERIFIER_nondet_int())
[L645]              p->h = 3
[L646]              p = a
[L647]              flag = 1
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L648]  EXPR        p->h
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, p->h=2, t={17:0}]
[L648]  COND TRUE   p->h != 3
[L649]  COND TRUE   \read(flag)
[L650]              flag = 0
[L651]  EXPR        p->h
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, p->h=2, t={17:0}]
[L651]  COND TRUE   p->h != 1
[L668]              __VERIFIER_error()
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]

-----
[2018-11-23 12:52:19,280 WARN  L170   areAnnotationChecker]: exitENTRY has no Hoare annotation
[2018-11-23 12:52:19,280 WARN  L170   areAnnotationChecker]: ULTIMATE.initENTRY has no Hoare annotation
[2018-11-23 12:52:19,281 WARN  L170   areAnnotationChecker]: ULTIMATE.startENTRY has no Hoare annotation
[2018-11-23 12:52:19,281 WARN  L170   areAnnotationChecker]: ULTIMATE.startENTRY has no Hoare annotation
[2018-11-23 12:52:19,281 WARN  L170   areAnnotationChecker]: mainENTRY has no Hoare annotation
[2018-11-23 12:52:19,281 WARN  L170   areAnnotationChecker]: L624 has no Hoare annotation
[2018-11-23 12:52:19,281 WARN  L170   areAnnotationChecker]: ULTIMATE.initFINAL has no Hoare annotation
[2018-11-23 12:52:19,281 WARN  L170   areAnnotationChecker]: L-1 has no Hoare annotation
[2018-11-23 12:52:19,281 WARN  L170   areAnnotationChecker]: L-1 has no Hoare annotation
[2018-11-23 12:52:19,282 WARN  L170   areAnnotationChecker]: L629 has no Hoare annotation
[2018-11-23 12:52:19,282 WARN  L170   areAnnotationChecker]: L629 has no Hoare annotation
[2018-11-23 12:52:19,283 WARN  L170   areAnnotationChecker]: ULTIMATE.initEXIT has no Hoare annotation
[2018-11-23 12:52:19,283 WARN  L170   areAnnotationChecker]: ULTIMATE.startFINAL has no Hoare annotation
[2018-11-23 12:52:19,283 WARN  L170   areAnnotationChecker]: L629-1 has no Hoare annotation
[2018-11-23 12:52:19,283 WARN  L170   areAnnotationChecker]: L629-1 has no Hoare annotation
[2018-11-23 12:52:19,283 WARN  L170   areAnnotationChecker]: L629-3 has no Hoare annotation
[2018-11-23 12:52:19,283 WARN  L170   areAnnotationChecker]: L632-3 has no Hoare annotation
[2018-11-23 12:52:19,283 WARN  L170   areAnnotationChecker]: L632-3 has no Hoare annotation
[2018-11-23 12:52:19,284 WARN  L170   areAnnotationChecker]: L632-4 has no Hoare annotation
[2018-11-23 12:52:19,284 WARN  L170   areAnnotationChecker]: L632-1 has no Hoare annotation
[2018-11-23 12:52:19,284 WARN  L170   areAnnotationChecker]: L632-1 has no Hoare annotation
[2018-11-23 12:52:19,284 WARN  L170   areAnnotationChecker]: L648-3 has no Hoare annotation
[2018-11-23 12:52:19,284 WARN  L170   areAnnotationChecker]: L648-3 has no Hoare annotation
[2018-11-23 12:52:19,284 WARN  L170   areAnnotationChecker]: L633 has no Hoare annotation
[2018-11-23 12:52:19,285 WARN  L170   areAnnotationChecker]: L633 has no Hoare annotation
[2018-11-23 12:52:19,285 WARN  L170   areAnnotationChecker]: L648-4 has no Hoare annotation
[2018-11-23 12:52:19,285 WARN  L170   areAnnotationChecker]: L648-1 has no Hoare annotation
[2018-11-23 12:52:19,285 WARN  L170   areAnnotationChecker]: L648-1 has no Hoare annotation
[2018-11-23 12:52:19,285 WARN  L170   areAnnotationChecker]: L633-2 has no Hoare annotation
[2018-11-23 12:52:19,285 WARN  L170   areAnnotationChecker]: L661-3 has no Hoare annotation
[2018-11-23 12:52:19,285 WARN  L170   areAnnotationChecker]: L661-3 has no Hoare annotation
[2018-11-23 12:52:19,286 WARN  L170   areAnnotationChecker]: L649 has no Hoare annotation
[2018-11-23 12:52:19,286 WARN  L170   areAnnotationChecker]: L649 has no Hoare annotation
[2018-11-23 12:52:19,286 WARN  L170   areAnnotationChecker]: L641 has no Hoare annotation
[2018-11-23 12:52:19,286 WARN  L170   areAnnotationChecker]: L641 has no Hoare annotation
[2018-11-23 12:52:19,286 WARN  L170   areAnnotationChecker]: L661-4 has no Hoare annotation
[2018-11-23 12:52:19,286 WARN  L170   areAnnotationChecker]: L661-1 has no Hoare annotation
[2018-11-23 12:52:19,286 WARN  L170   areAnnotationChecker]: L661-1 has no Hoare annotation
[2018-11-23 12:52:19,287 WARN  L170   areAnnotationChecker]: L651 has no Hoare annotation
[2018-11-23 12:52:19,287 WARN  L170   areAnnotationChecker]: L651 has no Hoare annotation
[2018-11-23 12:52:19,287 WARN  L170   areAnnotationChecker]: L655 has no Hoare annotation
[2018-11-23 12:52:19,287 WARN  L170   areAnnotationChecker]: L655 has no Hoare annotation
[2018-11-23 12:52:19,287 WARN  L170   areAnnotationChecker]: L641-1 has no Hoare annotation
[2018-11-23 12:52:19,287 WARN  L170   areAnnotationChecker]: L641-1 has no Hoare annotation
[2018-11-23 12:52:19,287 WARN  L170   areAnnotationChecker]: L641-3 has no Hoare annotation
[2018-11-23 12:52:19,288 WARN  L170   areAnnotationChecker]: mainFINAL has no Hoare annotation
[2018-11-23 12:52:19,288 WARN  L170   areAnnotationChecker]: L656 has no Hoare annotation
[2018-11-23 12:52:19,288 WARN  L170   areAnnotationChecker]: L656 has no Hoare annotation
[2018-11-23 12:52:19,288 WARN  L170   areAnnotationChecker]: L649-2 has no Hoare annotation
[2018-11-23 12:52:19,288 WARN  L170   areAnnotationChecker]: mainEXIT has no Hoare annotation
[2018-11-23 12:52:19,288 INFO  L163   areAnnotationChecker]: CFG has 0 edges. 0 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. 0 times interpolants missing.
[2018-11-23 12:52:19,293 INFO  L202        PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction CFG 23.11 12:52:19 BoogieIcfgContainer
[2018-11-23 12:52:19,293 INFO  L132        PluginConnector]: ------------------------ END TraceAbstraction----------------------------
[2018-11-23 12:52:19,294 INFO  L113        PluginConnector]: ------------------------Witness Printer----------------------------
[2018-11-23 12:52:19,294 INFO  L271        PluginConnector]: Initializing Witness Printer...
[2018-11-23 12:52:19,295 INFO  L276        PluginConnector]: Witness Printer initialized
[2018-11-23 12:52:19,295 INFO  L185        PluginConnector]: Executing the observer RCFGCatcher from plugin Witness Printer for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:52:16" (3/4) ...
[2018-11-23 12:52:19,299 INFO  L138         WitnessPrinter]: Generating witness for reachability counterexample
-----
class de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.RCFGBacktranslator
[?]  CALL  call ULTIMATE.init();
     VAL   [|#NULL.base|=16, |#NULL.offset|=10, |old(#NULL.base)|=16, |old(#NULL.offset)|=10]
[?]        #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];
     VAL   [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=16, |old(#NULL.offset)|=10]
[?]        assume true;
     VAL   [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=16, |old(#NULL.offset)|=10]
[?]  RET   #97#return;
     VAL   [|#NULL.base|=0, |#NULL.offset|=0]
[?]  CALL  call #t~ret10 := main();
     VAL   [|#NULL.base|=0, |#NULL.offset|=0]
[?]        ~flag~0 := 1;call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        assume !(~a~0.base == 0 && ~a~0.offset == 0);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        havoc ~t~0.base, ~t~0.offset;~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~nondet1|=1]
[?]        assume !!(0 != #t~nondet1);havoc #t~nondet1;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        assume 0 != ~flag~0;call write~int(2, ~p~0.base, ~p~0.offset, 4);~flag~0 := 0;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0]
[?]        call #t~malloc2.base, #t~malloc2.offset := #Ultimate.alloc(8);~t~0.base, ~t~0.offset := #t~malloc2.base, #t~malloc2.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume !(~t~0.base == 0 && ~t~0.offset == 0);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        call write~$Pointer$(~t~0.base, ~t~0.offset, ~p~0.base, 4 + ~p~0.offset, 4);call #t~mem3.base, #t~mem3.offset := read~$Pointer$(~p~0.base, 4 + ~p~0.offset, 4);~p~0.base, ~p~0.offset := #t~mem3.base, #t~mem3.offset;havoc #t~mem3.base, #t~mem3.offset;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=17, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=17, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0, |main_#t~nondet1|=0]
[?]        assume !(0 != #t~nondet1);havoc #t~nondet1;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=17, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        call write~int(3, ~p~0.base, ~p~0.offset, 4);~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;~flag~0 := 1;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0, |main_#t~mem4|=2]
[?]        assume !!(3 != #t~mem4);havoc #t~mem4;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=1, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume 0 != ~flag~0;~flag~0 := 0;call #t~mem5 := read~int(~p~0.base, ~p~0.offset, 4);
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0, |main_#t~mem5|=2]
[?]        assume 1 != #t~mem5;havoc #t~mem5;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]
[?]        assume !false;
     VAL   [main_~a~0.base=14, main_~a~0.offset=0, main_~flag~0=0, main_~p~0.base=14, main_~p~0.offset=0, main_~t~0.base=17, main_~t~0.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~malloc0.base|=14, |main_#t~malloc0.offset|=0, |main_#t~malloc2.base|=17, |main_#t~malloc2.offset|=0]


[?]          CALL  call ULTIMATE.init();
             VAL   [#NULL.base=16, #NULL.offset=10, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                #NULL.base, #NULL.offset := 0, 0;
[?]                #valid := #valid[0 := 0];
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                ensures true;
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]          RET   call ULTIMATE.init();
             VAL   [#NULL.base=0, #NULL.offset=0]
[?]          CALL  call #t~ret10 := main();
             VAL   [#NULL.base=0, #NULL.offset=0]
[L627]             ~flag~0 := 1;
[L628]             call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);
[L628]             ~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L629]             assume !(~a~0.base == 0 && ~a~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L630]             havoc ~t~0.base, ~t~0.offset;
[L631]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~nondet1=1, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632-L644]        assume !!(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L633-L639]        assume 0 != ~flag~0;
[L634]             call write~int(2, ~p~0.base, ~p~0.offset, 4);
[L635]             ~flag~0 := 0;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0]
[L640]             call #t~malloc2.base, #t~malloc2.offset := #Ultimate.alloc(8);
[L640]             ~t~0.base, ~t~0.offset := #t~malloc2.base, #t~malloc2.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L641]             assume !(~t~0.base == 0 && ~t~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L642]             call write~$Pointer$(~t~0.base, ~t~0.offset, ~p~0.base, 4 + ~p~0.offset, 4);
[L643]             call #t~mem3.base, #t~mem3.offset := read~$Pointer$(~p~0.base, 4 + ~p~0.offset, 4);
[L643]             ~p~0.base, ~p~0.offset := #t~mem3.base, #t~mem3.offset;
[L643]             havoc #t~mem3.base, #t~mem3.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~nondet1=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632-L644]        assume !(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L645]             call write~int(3, ~p~0.base, ~p~0.offset, 4);
[L646]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
[L647]             ~flag~0 := 1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648]             call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem4=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648-L659]        assume !!(3 != #t~mem4);
[L648]             havoc #t~mem4;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L649-L657]        assume 0 != ~flag~0;
[L650]             ~flag~0 := 0;
[L651]             call #t~mem5 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem5=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L651-L652]        assume 1 != #t~mem5;
[L651]             havoc #t~mem5;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L668]             assert false;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]

-----
-----
class de.uni_freiburg.informatik.ultimate.boogie.preprocessor.BoogiePreprocessorBacktranslator
[?]          CALL  call ULTIMATE.init();
             VAL   [#NULL.base=16, #NULL.offset=10, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                #NULL.base, #NULL.offset := 0, 0;
[?]                #valid := #valid[0 := 0];
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]                ensures true;
             VAL   [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=16, old(#NULL.offset)=10]
[?]          RET   call ULTIMATE.init();
             VAL   [#NULL.base=0, #NULL.offset=0]
[?]          CALL  call #t~ret10 := main();
             VAL   [#NULL.base=0, #NULL.offset=0]
[L627]             ~flag~0 := 1;
[L628]             call #t~malloc0.base, #t~malloc0.offset := #Ultimate.alloc(8);
[L628]             ~a~0.base, ~a~0.offset := #t~malloc0.base, #t~malloc0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L629]             assume !(~a~0.base == 0 && ~a~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1]
[L630]             havoc ~t~0.base, ~t~0.offset;
[L631]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~nondet1=1, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L632-L644]        assume !!(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0]
[L633-L639]        assume 0 != ~flag~0;
[L634]             call write~int(2, ~p~0.base, ~p~0.offset, 4);
[L635]             ~flag~0 := 0;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0]
[L640]             call #t~malloc2.base, #t~malloc2.offset := #Ultimate.alloc(8);
[L640]             ~t~0.base, ~t~0.offset := #t~malloc2.base, #t~malloc2.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L641]             assume !(~t~0.base == 0 && ~t~0.offset == 0);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L642]             call write~$Pointer$(~t~0.base, ~t~0.offset, ~p~0.base, 4 + ~p~0.offset, 4);
[L643]             call #t~mem3.base, #t~mem3.offset := read~$Pointer$(~p~0.base, 4 + ~p~0.offset, 4);
[L643]             ~p~0.base, ~p~0.offset := #t~mem3.base, #t~mem3.offset;
[L643]             havoc #t~mem3.base, #t~mem3.offset;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632]             assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~nondet1=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L632-L644]        assume !(0 != #t~nondet1);
[L632]             havoc #t~nondet1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=17, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L645]             call write~int(3, ~p~0.base, ~p~0.offset, 4);
[L646]             ~p~0.base, ~p~0.offset := ~a~0.base, ~a~0.offset;
[L647]             ~flag~0 := 1;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648]             call #t~mem4 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem4=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L648-L659]        assume !!(3 != #t~mem4);
[L648]             havoc #t~mem4;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=1, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L649-L657]        assume 0 != ~flag~0;
[L650]             ~flag~0 := 0;
[L651]             call #t~mem5 := read~int(~p~0.base, ~p~0.offset, 4);
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, #t~mem5=2, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L651-L652]        assume 1 != #t~mem5;
[L651]             havoc #t~mem5;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]
[L668]             assert false;
             VAL   [#NULL.base=0, #NULL.offset=0, #t~malloc0.base=14, #t~malloc0.offset=0, #t~malloc2.base=17, #t~malloc2.offset=0, ~a~0.base=14, ~a~0.offset=0, ~flag~0=0, ~p~0.base=14, ~p~0.offset=0, ~t~0.base=17, ~t~0.offset=0]


[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]

-----
-----
class de.uni_freiburg.informatik.ultimate.boogie.procedureinliner.backtranslation.InlinerBacktranslator
[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]


[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]

-----
-----
class de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.CACSL2BoogieBacktranslator
[?]          CALL        call ULTIMATE.init();
             VAL         [#NULL!base=16, #NULL!offset=10, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]                      #NULL := { base: 0, offset: 0 };
[?]                      #valid[0] := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=16, old(#NULL!offset)=10]
[?]          RET         call ULTIMATE.init();
             VAL         [#NULL!base=0, #NULL!offset=0]
[?]          CALL        call #t~ret10 := main();
             VAL         [#NULL!base=0, #NULL!offset=0]
[L627]                   ~flag~0 := 1;
[L628]       FCALL       call #t~malloc0 := #Ultimate.alloc(8);
[L628]                   ~a~0 := #t~malloc0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L629]       COND FALSE  !(~a~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1]
[L630]                   havoc ~t~0;
[L631]                   ~p~0 := ~a~0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~nondet1=1, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L632-L644]  COND FALSE  !(!(0 != #t~nondet1))
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0]
[L633-L639]  COND TRUE   0 != ~flag~0
[L634]       FCALL       call write~int(2, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L635]                   ~flag~0 := 0;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0]
[L640]       FCALL       call #t~malloc2 := #Ultimate.alloc(8);
[L640]                   ~t~0 := #t~malloc2;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L641]       COND FALSE  !(~t~0 == { base: 0, offset: 0 })
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L642]       FCALL       call write~$Pointer$(~t~0, { base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]       FCALL       call #t~mem3 := read~$Pointer$({ base: ~p~0!base, offset: 4 + ~p~0!offset }, 4);
[L643]                   ~p~0 := #t~mem3;
[L643]                   havoc #t~mem3;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632]                   assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~nondet1=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L632-L644]  COND TRUE   !(0 != #t~nondet1)
[L632]                   havoc #t~nondet1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=17, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L645]       FCALL       call write~int(3, { base: ~p~0!base, offset: ~p~0!offset }, 4);
[L646]                   ~p~0 := ~a~0;
[L647]                   ~flag~0 := 1;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648]       FCALL       call #t~mem4 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem4=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L648-L659]  COND FALSE  !(!(3 != #t~mem4))
[L648]                   havoc #t~mem4;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=1, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L649-L657]  COND TRUE   0 != ~flag~0
[L650]                   ~flag~0 := 0;
[L651]       FCALL       call #t~mem5 := read~int({ base: ~p~0!base, offset: ~p~0!offset }, 4);
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, #t~mem5=2, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L651]       COND TRUE   1 != #t~mem5
[L651]                   havoc #t~mem5;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]
[L668]                   assert false;
             VAL         [#NULL!base=0, #NULL!offset=0, #t~malloc0!base=14, #t~malloc0!offset=0, #t~malloc2!base=17, #t~malloc2!offset=0, ~a~0!base=14, ~a~0!offset=0, ~flag~0=0, ~p~0!base=14, ~p~0!offset=0, ~t~0!base=17, ~t~0!offset=0]


[L627]              int flag = 1;
[L628]              List a = (List) malloc(sizeof(struct node));
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}]
[L629]  COND FALSE  !(a == 0)
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}]
[L630]              List t;
[L631]              List p = a;
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, p={14:0}]
[L632]  COND TRUE   __VERIFIER_nondet_int()
[L633]  COND TRUE   \read(flag)
[L634]              p->h = 2
[L635]              flag = 0
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, p={14:0}]
[L640]              t = (List) malloc(sizeof(struct node))
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L641]  COND FALSE  !(t == 0)
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L642]              p->n = t
[L643]  EXPR        p->n
[L643]              p = p->n
[L632]  COND FALSE  !(__VERIFIER_nondet_int())
[L645]              p->h = 3
[L646]              p = a
[L647]              flag = 1
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L648]  EXPR        p->h
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, p->h=2, t={17:0}]
[L648]  COND TRUE   p->h != 3
[L649]  COND TRUE   \read(flag)
[L650]              flag = 0
[L651]  EXPR        p->h
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, p->h=2, t={17:0}]
[L651]  COND TRUE   p->h != 1
[L668]              __VERIFIER_error()
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]

-----
[2018-11-23 12:52:19,388 INFO  L145         WitnessManager]: Wrote witness to /storage/repos/svcomp/c/list-properties/alternating_list_false-unreach-call_false-valid-memcleanup.i-witness.graphml
[2018-11-23 12:52:19,388 INFO  L132        PluginConnector]: ------------------------ END Witness Printer----------------------------
[2018-11-23 12:52:19,392 INFO  L168              Benchmark]: Toolchain (without parser) took 4784.27 ms. Allocated memory was 1.5 GB in the beginning and 2.2 GB in the end (delta: 667.4 MB). Free memory was 1.4 GB in the beginning and 1.9 GB in the end (delta: -529.8 MB). Peak memory consumption was 137.6 MB. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,394 INFO  L168              Benchmark]: CDTParser took 0.22 ms. Allocated memory is still 1.5 GB. Free memory is still 1.4 GB. There was no memory consumed. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,394 INFO  L168              Benchmark]: CACSL2BoogieTranslator took 642.33 ms. Allocated memory is still 1.5 GB. Free memory was 1.4 GB in the beginning and 1.3 GB in the end (delta: 31.9 MB). Peak memory consumption was 31.9 MB. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,395 INFO  L168              Benchmark]: Boogie Procedure Inliner took 116.73 ms. Allocated memory was 1.5 GB in the beginning and 2.2 GB in the end (delta: 667.4 MB). Free memory was 1.3 GB in the beginning and 2.1 GB in the end (delta: -747.8 MB). Peak memory consumption was 15.7 MB. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,396 INFO  L168              Benchmark]: Boogie Preprocessor took 49.21 ms. Allocated memory is still 2.2 GB. Free memory is still 2.1 GB. There was no memory consumed. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,396 INFO  L168              Benchmark]: RCFGBuilder took 870.04 ms. Allocated memory is still 2.2 GB. Free memory was 2.1 GB in the beginning and 2.1 GB in the end (delta: 36.3 MB). Peak memory consumption was 36.3 MB. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,397 INFO  L168              Benchmark]: TraceAbstraction took 3003.94 ms. Allocated memory is still 2.2 GB. Free memory was 2.1 GB in the beginning and 1.9 GB in the end (delta: 149.8 MB). Peak memory consumption was 149.8 MB. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,397 INFO  L168              Benchmark]: Witness Printer took 93.91 ms. Allocated memory is still 2.2 GB. Free memory is still 1.9 GB. There was no memory consumed. Max. memory is 7.1 GB.
[2018-11-23 12:52:19,402 INFO  L336   ainManager$Toolchain]: #######################  End [Toolchain 1] #######################
 --- Results ---
 * Results from de.uni_freiburg.informatik.ultimate.core:
  - GenericResult: Assertions are enabled
    Assertions are enabled
  - StatisticsResult: Toolchain Benchmarks
    Benchmark results are:
 * CDTParser took 0.22 ms. Allocated memory is still 1.5 GB. Free memory is still 1.4 GB. There was no memory consumed. Max. memory is 7.1 GB.
 * CACSL2BoogieTranslator took 642.33 ms. Allocated memory is still 1.5 GB. Free memory was 1.4 GB in the beginning and 1.3 GB in the end (delta: 31.9 MB). Peak memory consumption was 31.9 MB. Max. memory is 7.1 GB.
 * Boogie Procedure Inliner took 116.73 ms. Allocated memory was 1.5 GB in the beginning and 2.2 GB in the end (delta: 667.4 MB). Free memory was 1.3 GB in the beginning and 2.1 GB in the end (delta: -747.8 MB). Peak memory consumption was 15.7 MB. Max. memory is 7.1 GB.
 * Boogie Preprocessor took 49.21 ms. Allocated memory is still 2.2 GB. Free memory is still 2.1 GB. There was no memory consumed. Max. memory is 7.1 GB.
 * RCFGBuilder took 870.04 ms. Allocated memory is still 2.2 GB. Free memory was 2.1 GB in the beginning and 2.1 GB in the end (delta: 36.3 MB). Peak memory consumption was 36.3 MB. Max. memory is 7.1 GB.
 * TraceAbstraction took 3003.94 ms. Allocated memory is still 2.2 GB. Free memory was 2.1 GB in the beginning and 1.9 GB in the end (delta: 149.8 MB). Peak memory consumption was 149.8 MB. Max. memory is 7.1 GB.
 * Witness Printer took 93.91 ms. Allocated memory is still 2.2 GB. Free memory is still 1.9 GB. There was no memory consumed. Max. memory is 7.1 GB.
 * Results from de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction:
  - CounterExampleResult [Line: 668]: a call of __VERIFIER_error() is reachable
    a call of __VERIFIER_error() is reachable
We found a FailurePath: 
[L627]              int flag = 1;
[L628]              List a = (List) malloc(sizeof(struct node));
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}]
[L629]  COND FALSE  !(a == 0)
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}]
[L630]              List t;
[L631]              List p = a;
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, p={14:0}]
[L632]  COND TRUE   __VERIFIER_nondet_int()
[L633]  COND TRUE   \read(flag)
[L634]              p->h = 2
[L635]              flag = 0
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, p={14:0}]
[L640]              t = (List) malloc(sizeof(struct node))
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L641]  COND FALSE  !(t == 0)
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L642]              p->n = t
[L643]  EXPR        p->n
[L643]              p = p->n
[L632]  COND FALSE  !(__VERIFIER_nondet_int())
[L645]              p->h = 3
[L646]              p = a
[L647]              flag = 1
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]
[L648]  EXPR        p->h
        VAL         [a={14:0}, flag=1, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, p->h=2, t={17:0}]
[L648]  COND TRUE   p->h != 3
[L649]  COND TRUE   \read(flag)
[L650]              flag = 0
[L651]  EXPR        p->h
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, p->h=2, t={17:0}]
[L651]  COND TRUE   p->h != 1
[L668]              __VERIFIER_error()
        VAL         [a={14:0}, flag=0, malloc(sizeof(struct node))={14:0}, malloc(sizeof(struct node))={17:0}, p={14:0}, t={17:0}]

  - StatisticsResult: Ultimate Automizer benchmark data
    CFG has 4 procedures, 37 locations, 1 error locations. UNSAFE Result, 2.9s OverallTime, 4 OverallIterations, 2 TraceHistogramMax, 1.8s AutomataDifference, 0.0s DeadEndRemovalTime, 0.0s HoareAnnotationTime, HoareTripleCheckerStatistics: 93 SDtfs, 24 SDslu, 71 SDs, 0 SdLazy, 35 SolverSat, 6 SolverUnsat, 0 SolverUnknown, 0 SolverNotchecked, 0.1s Time, PredicateUnifierStatistics: 0 DeclaredPredicates, 13 GetRequests, 6 SyntacticMatches, 1 SemanticMatches, 6 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.1s Time, 0.0s BasicInterpolantAutomatonTime, BiggestAbstraction: size=35occurred in iteration=0, traceCheckStatistics: No data available, InterpolantConsolidationStatistics: No data available, PathInvariantsStatistics: No data available, 0/0 InterpolantCoveringCapability, TotalInterpolationStatistics: No data available, 0.0s AbstIntTime, 0 AbstIntIterations, 0 AbstIntStrong, NaN AbsIntWeakeningRatio, NaN AbsIntAvgWeakeningVarsNumRemoved, NaN AbsIntAvgWeakenedConjuncts, 0.0s DumpTime, AutomataMinimizationStatistics: 0.1s AutomataMinimizationTime, 3 MinimizatonAttempts, 14 StatesRemovedByMinimization, 2 NontrivialMinimizations, HoareAnnotationStatistics: No data available, RefinementEngineStatistics: TraceCheckStatistics: 0.0s SsaConstructionTime, 0.0s SatisfiabilityAnalysisTime, 0.3s InterpolantComputationTime, 69 NumberOfCodeBlocks, 69 NumberOfCodeBlocksAsserted, 4 NumberOfCheckSat, 44 ConstructedInterpolants, 0 QuantifiedInterpolants, 1126 SizeOfPredicates, 0 NumberOfNonLiveVariables, 0 ConjunctsInSsa, 0 ConjunctsInUnsatCore, 3 InterpolantComputations, 3 PerfectInterpolantSequences, 0/0 InterpolantCoveringCapability, InvariantSynthesisStatistics: No data available, InterpolantConsolidationStatistics: No data available, ReuseStatistics: No data available
RESULT: Ultimate proved your program to be incorrect!
Received shutdown request...