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/reducercommutativity/rangesum_false-unreach-call_true-termination.i -------------------------------------------------------------------------------- This is Ultimate 0.1.23-61f4311 [2018-11-23 12:13:42,494 INFO L170 SettingsManager]: Resetting all preferences to default values... [2018-11-23 12:13:42,496 INFO L174 SettingsManager]: Resetting UltimateCore preferences to default values [2018-11-23 12:13:42,507 INFO L177 SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring... [2018-11-23 12:13:42,508 INFO L174 SettingsManager]: Resetting Boogie Preprocessor preferences to default values [2018-11-23 12:13:42,509 INFO L174 SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values [2018-11-23 12:13:42,510 INFO L174 SettingsManager]: Resetting Abstract Interpretation preferences to default values [2018-11-23 12:13:42,512 INFO L174 SettingsManager]: Resetting LassoRanker preferences to default values [2018-11-23 12:13:42,516 INFO L174 SettingsManager]: Resetting Reaching Definitions preferences to default values [2018-11-23 12:13:42,517 INFO L174 SettingsManager]: Resetting SyntaxChecker preferences to default values [2018-11-23 12:13:42,521 INFO L177 SettingsManager]: Büchi Program Product provides no preferences, ignoring... [2018-11-23 12:13:42,522 INFO L174 SettingsManager]: Resetting LTL2Aut preferences to default values [2018-11-23 12:13:42,526 INFO L174 SettingsManager]: Resetting PEA to Boogie preferences to default values [2018-11-23 12:13:42,527 INFO L174 SettingsManager]: Resetting BlockEncodingV2 preferences to default values [2018-11-23 12:13:42,529 INFO L174 SettingsManager]: Resetting ChcToBoogie preferences to default values [2018-11-23 12:13:42,533 INFO L174 SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values [2018-11-23 12:13:42,534 INFO L174 SettingsManager]: Resetting BuchiAutomizer preferences to default values [2018-11-23 12:13:42,537 INFO L174 SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values [2018-11-23 12:13:42,541 INFO L174 SettingsManager]: Resetting CodeCheck preferences to default values [2018-11-23 12:13:42,546 INFO L174 SettingsManager]: Resetting InvariantSynthesis preferences to default values [2018-11-23 12:13:42,548 INFO L174 SettingsManager]: Resetting RCFGBuilder preferences to default values [2018-11-23 12:13:42,552 INFO L174 SettingsManager]: Resetting TraceAbstraction preferences to default values [2018-11-23 12:13:42,554 INFO L177 SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring... [2018-11-23 12:13:42,557 INFO L177 SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring... [2018-11-23 12:13:42,557 INFO L174 SettingsManager]: Resetting TreeAutomizer preferences to default values [2018-11-23 12:13:42,558 INFO L174 SettingsManager]: Resetting IcfgTransformer preferences to default values [2018-11-23 12:13:42,559 INFO L174 SettingsManager]: Resetting Boogie Printer preferences to default values [2018-11-23 12:13:42,560 INFO L174 SettingsManager]: Resetting ReqPrinter preferences to default values [2018-11-23 12:13:42,563 INFO L174 SettingsManager]: Resetting Witness Printer preferences to default values [2018-11-23 12:13:42,565 INFO L177 SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring... [2018-11-23 12:13:42,565 INFO L174 SettingsManager]: Resetting CDTParser preferences to default values [2018-11-23 12:13:42,566 INFO L177 SettingsManager]: AutomataScriptParser provides no preferences, ignoring... [2018-11-23 12:13:42,567 INFO L177 SettingsManager]: ReqParser provides no preferences, ignoring... [2018-11-23 12:13:42,567 INFO L174 SettingsManager]: Resetting SmtParser preferences to default values [2018-11-23 12:13:42,568 INFO L174 SettingsManager]: Resetting Witness Parser preferences to default values [2018-11-23 12:13:42,569 INFO L181 SettingsManager]: Finished resetting all preferences to default values... [2018-11-23 12:13:42,569 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:13:42,588 INFO L110 SettingsManager]: Loading preferences was successful [2018-11-23 12:13:42,588 INFO L112 SettingsManager]: Preferences different from defaults after loading the file: [2018-11-23 12:13:42,589 INFO L131 SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults: [2018-11-23 12:13:42,589 INFO L133 SettingsManager]: * ... calls to implemented procedures=ONLY_FOR_CONCURRENT_PROGRAMS [2018-11-23 12:13:42,590 INFO L131 SettingsManager]: Preferences of BlockEncodingV2 differ from their defaults: [2018-11-23 12:13:42,590 INFO L133 SettingsManager]: * Create parallel compositions if possible=false [2018-11-23 12:13:42,590 INFO L133 SettingsManager]: * Use SBE=true [2018-11-23 12:13:42,591 INFO L131 SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults: [2018-11-23 12:13:42,591 INFO L133 SettingsManager]: * sizeof long=4 [2018-11-23 12:13:42,591 INFO L133 SettingsManager]: * Overapproximate operations on floating types=true [2018-11-23 12:13:42,591 INFO L133 SettingsManager]: * sizeof POINTER=4 [2018-11-23 12:13:42,591 INFO L133 SettingsManager]: * Check division by zero=IGNORE [2018-11-23 12:13:42,592 INFO L133 SettingsManager]: * Pointer to allocated memory at dereference=IGNORE [2018-11-23 12:13:42,592 INFO L133 SettingsManager]: * If two pointers are subtracted or compared they have the same base address=IGNORE [2018-11-23 12:13:42,592 INFO L133 SettingsManager]: * Check array bounds for arrays that are off heap=IGNORE [2018-11-23 12:13:42,592 INFO L133 SettingsManager]: * sizeof long double=12 [2018-11-23 12:13:42,592 INFO L133 SettingsManager]: * Check if freed pointer was valid=false [2018-11-23 12:13:42,593 INFO L133 SettingsManager]: * Use constant arrays=true [2018-11-23 12:13:42,593 INFO L133 SettingsManager]: * Pointer base address is valid at dereference=IGNORE [2018-11-23 12:13:42,593 INFO L131 SettingsManager]: Preferences of RCFGBuilder differ from their defaults: [2018-11-23 12:13:42,593 INFO L133 SettingsManager]: * Size of a code block=SequenceOfStatements [2018-11-23 12:13:42,594 INFO L133 SettingsManager]: * To the following directory=./dump/ [2018-11-23 12:13:42,594 INFO L133 SettingsManager]: * SMT solver=External_DefaultMode [2018-11-23 12:13:42,594 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-11-23 12:13:42,594 INFO L131 SettingsManager]: Preferences of TraceAbstraction differ from their defaults: [2018-11-23 12:13:42,595 INFO L133 SettingsManager]: * Compute Interpolants along a Counterexample=FPandBP [2018-11-23 12:13:42,595 INFO L133 SettingsManager]: * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles [2018-11-23 12:13:42,595 INFO L133 SettingsManager]: * Trace refinement strategy=CAMEL [2018-11-23 12:13:42,595 INFO L133 SettingsManager]: * SMT solver=External_ModelsAndUnsatCoreMode [2018-11-23 12:13:42,595 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in [2018-11-23 12:13:42,596 INFO L133 SettingsManager]: * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true [2018-11-23 12:13:42,643 INFO L81 nceAwareModelManager]: Repository-Root is: /tmp [2018-11-23 12:13:42,666 INFO L258 ainManager$Toolchain]: [Toolchain 1]: Applicable parser(s) successfully (re)initialized [2018-11-23 12:13:42,671 INFO L214 ainManager$Toolchain]: [Toolchain 1]: Toolchain selected. [2018-11-23 12:13:42,673 INFO L271 PluginConnector]: Initializing CDTParser... [2018-11-23 12:13:42,674 INFO L276 PluginConnector]: CDTParser initialized [2018-11-23 12:13:42,674 INFO L418 ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/reducercommutativity/rangesum_false-unreach-call_true-termination.i [2018-11-23 12:13:42,746 INFO L221 CDTParser]: Created temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/077a98bae/8487c9a4496147dfbaa415141da13cce/FLAGc858f8700 [2018-11-23 12:13:43,266 INFO L307 CDTParser]: Found 1 translation units. [2018-11-23 12:13:43,267 INFO L161 CDTParser]: Scanning /storage/repos/ultimate/trunk/examples/svcomp/reducercommutativity/rangesum_false-unreach-call_true-termination.i [2018-11-23 12:13:43,275 INFO L355 CDTParser]: About to delete temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/077a98bae/8487c9a4496147dfbaa415141da13cce/FLAGc858f8700 [2018-11-23 12:13:43,597 INFO L363 CDTParser]: Successfully deleted /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/077a98bae/8487c9a4496147dfbaa415141da13cce [2018-11-23 12:13:43,613 INFO L296 ainManager$Toolchain]: ####################### [Toolchain 1] ####################### [2018-11-23 12:13:43,614 INFO L131 ToolchainWalker]: Walking toolchain with 6 elements. [2018-11-23 12:13:43,615 INFO L113 PluginConnector]: ------------------------CACSL2BoogieTranslator---------------------------- [2018-11-23 12:13:43,615 INFO L271 PluginConnector]: Initializing CACSL2BoogieTranslator... [2018-11-23 12:13:43,620 INFO L276 PluginConnector]: CACSL2BoogieTranslator initialized [2018-11-23 12:13:43,621 INFO L185 PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:43,624 INFO L205 PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@1e06ed92 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43, skipping insertion in model container [2018-11-23 12:13:43,625 INFO L185 PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:43,634 INFO L145 MainTranslator]: Starting translation in SV-COMP mode [2018-11-23 12:13:43,662 INFO L176 MainTranslator]: Built tables and reachable declarations [2018-11-23 12:13:43,913 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:13:43,925 INFO L191 MainTranslator]: Completed pre-run [2018-11-23 12:13:43,957 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:13:43,979 INFO L195 MainTranslator]: Completed translation [2018-11-23 12:13:43,979 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43 WrapperNode [2018-11-23 12:13:43,980 INFO L132 PluginConnector]: ------------------------ END CACSL2BoogieTranslator---------------------------- [2018-11-23 12:13:43,981 INFO L113 PluginConnector]: ------------------------Boogie Procedure Inliner---------------------------- [2018-11-23 12:13:43,981 INFO L271 PluginConnector]: Initializing Boogie Procedure Inliner... [2018-11-23 12:13:43,981 INFO L276 PluginConnector]: Boogie Procedure Inliner initialized [2018-11-23 12:13:43,991 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:13:43" (1/1) ... [2018-11-23 12:13:44,005 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:13:43" (1/1) ... [2018-11-23 12:13:44,016 INFO L132 PluginConnector]: ------------------------ END Boogie Procedure Inliner---------------------------- [2018-11-23 12:13:44,016 INFO L113 PluginConnector]: ------------------------Boogie Preprocessor---------------------------- [2018-11-23 12:13:44,016 INFO L271 PluginConnector]: Initializing Boogie Preprocessor... [2018-11-23 12:13:44,017 INFO L276 PluginConnector]: Boogie Preprocessor initialized [2018-11-23 12:13:44,029 INFO L185 PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:44,029 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:44,040 INFO L185 PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:44,040 INFO L185 PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:44,072 INFO L185 PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:44,080 INFO L185 PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:44,082 INFO L185 PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (1/1) ... [2018-11-23 12:13:44,085 INFO L132 PluginConnector]: ------------------------ END Boogie Preprocessor---------------------------- [2018-11-23 12:13:44,086 INFO L113 PluginConnector]: ------------------------RCFGBuilder---------------------------- [2018-11-23 12:13:44,086 INFO L271 PluginConnector]: Initializing RCFGBuilder... [2018-11-23 12:13:44,086 INFO L276 PluginConnector]: RCFGBuilder initialized [2018-11-23 12:13:44,087 INFO L185 PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (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:13:44,219 INFO L130 BoogieDeclarations]: Found specification of procedure write~int [2018-11-23 12:13:44,219 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.init [2018-11-23 12:13:44,219 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.init [2018-11-23 12:13:44,220 INFO L130 BoogieDeclarations]: Found specification of procedure #Ultimate.alloc [2018-11-23 12:13:44,220 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.start [2018-11-23 12:13:44,220 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.start [2018-11-23 12:13:44,220 INFO L130 BoogieDeclarations]: Found specification of procedure read~int [2018-11-23 12:13:44,220 INFO L130 BoogieDeclarations]: Found specification of procedure main [2018-11-23 12:13:44,220 INFO L138 BoogieDeclarations]: Found implementation of procedure main [2018-11-23 12:13:44,220 INFO L130 BoogieDeclarations]: Found specification of procedure rangesum [2018-11-23 12:13:44,221 INFO L138 BoogieDeclarations]: Found implementation of procedure rangesum [2018-11-23 12:13:44,221 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.dealloc [2018-11-23 12:13:44,221 INFO L130 BoogieDeclarations]: Found specification of procedure init_nondet [2018-11-23 12:13:44,221 INFO L138 BoogieDeclarations]: Found implementation of procedure init_nondet [2018-11-23 12:13:45,255 INFO L275 CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start) [2018-11-23 12:13:45,256 INFO L280 CfgBuilder]: Removed 3 assue(true) statements. [2018-11-23 12:13:45,256 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:13:45 BoogieIcfgContainer [2018-11-23 12:13:45,257 INFO L132 PluginConnector]: ------------------------ END RCFGBuilder---------------------------- [2018-11-23 12:13:45,258 INFO L113 PluginConnector]: ------------------------TraceAbstraction---------------------------- [2018-11-23 12:13:45,258 INFO L271 PluginConnector]: Initializing TraceAbstraction... [2018-11-23 12:13:45,261 INFO L276 PluginConnector]: TraceAbstraction initialized [2018-11-23 12:13:45,262 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "CDTParser AST 23.11 12:13:43" (1/3) ... [2018-11-23 12:13:45,263 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3e39c65b and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:13:45, skipping insertion in model container [2018-11-23 12:13:45,263 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:13:43" (2/3) ... [2018-11-23 12:13:45,263 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3e39c65b and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:13:45, skipping insertion in model container [2018-11-23 12:13:45,263 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:13:45" (3/3) ... [2018-11-23 12:13:45,265 INFO L112 eAbstractionObserver]: Analyzing ICFG rangesum_false-unreach-call_true-termination.i [2018-11-23 12:13:45,277 INFO L156 ceAbstractionStarter]: Automizer settings: Hoare:true NWA Interpolation:FPandBP Determinization: PREDICATE_ABSTRACTION [2018-11-23 12:13:45,286 INFO L168 ceAbstractionStarter]: Appying trace abstraction to program that has 1 error locations. [2018-11-23 12:13:45,306 INFO L257 AbstractCegarLoop]: Starting to check reachability of 1 error locations. [2018-11-23 12:13:45,340 INFO L133 ementStrategyFactory]: Using default assertion order modulation [2018-11-23 12:13:45,341 INFO L382 AbstractCegarLoop]: Interprodecural is true [2018-11-23 12:13:45,341 INFO L383 AbstractCegarLoop]: Hoare is true [2018-11-23 12:13:45,342 INFO L384 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-11-23 12:13:45,342 INFO L385 AbstractCegarLoop]: Backedges is STRAIGHT_LINE [2018-11-23 12:13:45,342 INFO L386 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-11-23 12:13:45,342 INFO L387 AbstractCegarLoop]: Difference is false [2018-11-23 12:13:45,342 INFO L388 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-11-23 12:13:45,343 INFO L393 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == AllErrorsAtOnce======== [2018-11-23 12:13:45,363 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states. [2018-11-23 12:13:45,372 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 39 [2018-11-23 12:13:45,372 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:45,373 INFO L402 BasicCegarLoop]: trace histogram [3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:45,376 INFO L423 AbstractCegarLoop]: === Iteration 1 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:45,383 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:45,383 INFO L82 PathProgramCache]: Analyzing trace with hash -1377249276, now seen corresponding path program 1 times [2018-11-23 12:13:45,385 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:45,385 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:45,432 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:45,433 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:45,433 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:45,495 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:45,537 INFO L422 seRefinementStrategy]: Interpolation failed due to KNOWN_IGNORE: Unsupported non-linear arithmetic [2018-11-23 12:13:45,537 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:13:45,538 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 2 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 2 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:13:45,557 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:45,615 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:45,650 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:45,655 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:45,782 INFO L256 TraceCheckUtils]: 0: Hoare triple {42#true} call ULTIMATE.init(); {42#true} is VALID [2018-11-23 12:13:45,786 INFO L273 TraceCheckUtils]: 1: Hoare triple {42#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {42#true} is VALID [2018-11-23 12:13:45,787 INFO L273 TraceCheckUtils]: 2: Hoare triple {42#true} assume true; {42#true} is VALID [2018-11-23 12:13:45,787 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {42#true} {42#true} #85#return; {42#true} is VALID [2018-11-23 12:13:45,788 INFO L256 TraceCheckUtils]: 4: Hoare triple {42#true} call #t~ret13 := main(); {42#true} is VALID [2018-11-23 12:13:45,788 INFO L273 TraceCheckUtils]: 5: Hoare triple {42#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {42#true} is VALID [2018-11-23 12:13:45,788 INFO L273 TraceCheckUtils]: 6: Hoare triple {42#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {42#true} is VALID [2018-11-23 12:13:45,789 INFO L256 TraceCheckUtils]: 7: Hoare triple {42#true} call init_nondet(~#x~0.base, ~#x~0.offset); {42#true} is VALID [2018-11-23 12:13:45,789 INFO L273 TraceCheckUtils]: 8: Hoare triple {42#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {42#true} is VALID [2018-11-23 12:13:45,792 INFO L273 TraceCheckUtils]: 9: Hoare triple {42#true} assume !true; {43#false} is VALID [2018-11-23 12:13:45,792 INFO L273 TraceCheckUtils]: 10: Hoare triple {43#false} assume true; {43#false} is VALID [2018-11-23 12:13:45,793 INFO L268 TraceCheckUtils]: 11: Hoare quadruple {43#false} {42#true} #89#return; {43#false} is VALID [2018-11-23 12:13:45,793 INFO L273 TraceCheckUtils]: 12: Hoare triple {43#false} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {43#false} is VALID [2018-11-23 12:13:45,793 INFO L256 TraceCheckUtils]: 13: Hoare triple {43#false} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {43#false} is VALID [2018-11-23 12:13:45,794 INFO L273 TraceCheckUtils]: 14: Hoare triple {43#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {43#false} is VALID [2018-11-23 12:13:45,794 INFO L273 TraceCheckUtils]: 15: Hoare triple {43#false} assume !(~i~1 < ~N~0); {43#false} is VALID [2018-11-23 12:13:45,795 INFO L273 TraceCheckUtils]: 16: Hoare triple {43#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {43#false} is VALID [2018-11-23 12:13:45,795 INFO L273 TraceCheckUtils]: 17: Hoare triple {43#false} assume true; {43#false} is VALID [2018-11-23 12:13:45,795 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {43#false} {43#false} #91#return; {43#false} is VALID [2018-11-23 12:13:45,796 INFO L273 TraceCheckUtils]: 19: Hoare triple {43#false} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {43#false} is VALID [2018-11-23 12:13:45,796 INFO L256 TraceCheckUtils]: 20: Hoare triple {43#false} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {43#false} is VALID [2018-11-23 12:13:45,796 INFO L273 TraceCheckUtils]: 21: Hoare triple {43#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {43#false} is VALID [2018-11-23 12:13:45,797 INFO L273 TraceCheckUtils]: 22: Hoare triple {43#false} assume !(~i~1 < ~N~0); {43#false} is VALID [2018-11-23 12:13:45,797 INFO L273 TraceCheckUtils]: 23: Hoare triple {43#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {43#false} is VALID [2018-11-23 12:13:45,797 INFO L273 TraceCheckUtils]: 24: Hoare triple {43#false} assume true; {43#false} is VALID [2018-11-23 12:13:45,798 INFO L268 TraceCheckUtils]: 25: Hoare quadruple {43#false} {43#false} #93#return; {43#false} is VALID [2018-11-23 12:13:45,798 INFO L273 TraceCheckUtils]: 26: Hoare triple {43#false} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {43#false} is VALID [2018-11-23 12:13:45,798 INFO L273 TraceCheckUtils]: 27: Hoare triple {43#false} assume !(~i~2 < ~N~0 - 1); {43#false} is VALID [2018-11-23 12:13:45,799 INFO L273 TraceCheckUtils]: 28: Hoare triple {43#false} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {43#false} is VALID [2018-11-23 12:13:45,799 INFO L256 TraceCheckUtils]: 29: Hoare triple {43#false} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {43#false} is VALID [2018-11-23 12:13:45,800 INFO L273 TraceCheckUtils]: 30: Hoare triple {43#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {43#false} is VALID [2018-11-23 12:13:45,800 INFO L273 TraceCheckUtils]: 31: Hoare triple {43#false} assume !(~i~1 < ~N~0); {43#false} is VALID [2018-11-23 12:13:45,800 INFO L273 TraceCheckUtils]: 32: Hoare triple {43#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {43#false} is VALID [2018-11-23 12:13:45,801 INFO L273 TraceCheckUtils]: 33: Hoare triple {43#false} assume true; {43#false} is VALID [2018-11-23 12:13:45,801 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {43#false} {43#false} #95#return; {43#false} is VALID [2018-11-23 12:13:45,801 INFO L273 TraceCheckUtils]: 35: Hoare triple {43#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {43#false} is VALID [2018-11-23 12:13:45,802 INFO L273 TraceCheckUtils]: 36: Hoare triple {43#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {43#false} is VALID [2018-11-23 12:13:45,802 INFO L273 TraceCheckUtils]: 37: Hoare triple {43#false} assume !false; {43#false} is VALID [2018-11-23 12:13:45,810 INFO L134 CoverageAnalysis]: Checked inductivity of 15 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:13:45,841 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:13:45,842 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [2] imperfect sequences [] total 2 [2018-11-23 12:13:45,847 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 38 [2018-11-23 12:13:45,851 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:45,855 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states. [2018-11-23 12:13:46,048 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 30 edges. 30 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:46,048 INFO L459 AbstractCegarLoop]: Interpolant automaton has 2 states [2018-11-23 12:13:46,060 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 2 interpolants. [2018-11-23 12:13:46,061 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-11-23 12:13:46,064 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 2 states. [2018-11-23 12:13:46,282 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:46,282 INFO L93 Difference]: Finished difference Result 67 states and 89 transitions. [2018-11-23 12:13:46,282 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 2 states. [2018-11-23 12:13:46,282 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 38 [2018-11-23 12:13:46,283 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:46,284 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:13:46,296 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 89 transitions. [2018-11-23 12:13:46,296 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:13:46,303 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 89 transitions. [2018-11-23 12:13:46,304 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states and 89 transitions. [2018-11-23 12:13:46,927 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 89 edges. 89 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:46,942 INFO L225 Difference]: With dead ends: 67 [2018-11-23 12:13:46,942 INFO L226 Difference]: Without dead ends: 33 [2018-11-23 12:13:46,947 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 37 GetRequests, 37 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:13:46,967 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 33 states. [2018-11-23 12:13:47,003 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 33 to 33. [2018-11-23 12:13:47,003 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:47,004 INFO L82 GeneralOperation]: Start isEquivalent. First operand 33 states. Second operand 33 states. [2018-11-23 12:13:47,004 INFO L74 IsIncluded]: Start isIncluded. First operand 33 states. Second operand 33 states. [2018-11-23 12:13:47,004 INFO L87 Difference]: Start difference. First operand 33 states. Second operand 33 states. [2018-11-23 12:13:47,011 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:47,011 INFO L93 Difference]: Finished difference Result 33 states and 39 transitions. [2018-11-23 12:13:47,012 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 39 transitions. [2018-11-23 12:13:47,013 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:47,013 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:47,013 INFO L74 IsIncluded]: Start isIncluded. First operand 33 states. Second operand 33 states. [2018-11-23 12:13:47,013 INFO L87 Difference]: Start difference. First operand 33 states. Second operand 33 states. [2018-11-23 12:13:47,019 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:47,019 INFO L93 Difference]: Finished difference Result 33 states and 39 transitions. [2018-11-23 12:13:47,019 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 39 transitions. [2018-11-23 12:13:47,020 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:47,021 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:47,021 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:47,021 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:47,021 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 33 states. [2018-11-23 12:13:47,025 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 33 states to 33 states and 39 transitions. [2018-11-23 12:13:47,027 INFO L78 Accepts]: Start accepts. Automaton has 33 states and 39 transitions. Word has length 38 [2018-11-23 12:13:47,028 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:47,028 INFO L480 AbstractCegarLoop]: Abstraction has 33 states and 39 transitions. [2018-11-23 12:13:47,028 INFO L481 AbstractCegarLoop]: Interpolant automaton has 2 states. [2018-11-23 12:13:47,028 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 39 transitions. [2018-11-23 12:13:47,030 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 39 [2018-11-23 12:13:47,031 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:47,031 INFO L402 BasicCegarLoop]: trace histogram [3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:47,031 INFO L423 AbstractCegarLoop]: === Iteration 2 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:47,032 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:47,032 INFO L82 PathProgramCache]: Analyzing trace with hash -1240892162, now seen corresponding path program 1 times [2018-11-23 12:13:47,032 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:47,032 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:47,033 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:47,034 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:47,034 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:47,053 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:47,053 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:47,054 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 3 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 3 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:47,069 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:47,113 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:47,154 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:47,156 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:47,397 INFO L256 TraceCheckUtils]: 0: Hoare triple {355#true} call ULTIMATE.init(); {355#true} is VALID [2018-11-23 12:13:47,398 INFO L273 TraceCheckUtils]: 1: Hoare triple {355#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {355#true} is VALID [2018-11-23 12:13:47,398 INFO L273 TraceCheckUtils]: 2: Hoare triple {355#true} assume true; {355#true} is VALID [2018-11-23 12:13:47,399 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {355#true} {355#true} #85#return; {355#true} is VALID [2018-11-23 12:13:47,399 INFO L256 TraceCheckUtils]: 4: Hoare triple {355#true} call #t~ret13 := main(); {355#true} is VALID [2018-11-23 12:13:47,400 INFO L273 TraceCheckUtils]: 5: Hoare triple {355#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {355#true} is VALID [2018-11-23 12:13:47,400 INFO L273 TraceCheckUtils]: 6: Hoare triple {355#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {355#true} is VALID [2018-11-23 12:13:47,400 INFO L256 TraceCheckUtils]: 7: Hoare triple {355#true} call init_nondet(~#x~0.base, ~#x~0.offset); {355#true} is VALID [2018-11-23 12:13:47,401 INFO L273 TraceCheckUtils]: 8: Hoare triple {355#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {355#true} is VALID [2018-11-23 12:13:47,401 INFO L273 TraceCheckUtils]: 9: Hoare triple {355#true} assume !(~i~0 < ~N~0); {355#true} is VALID [2018-11-23 12:13:47,401 INFO L273 TraceCheckUtils]: 10: Hoare triple {355#true} assume true; {355#true} is VALID [2018-11-23 12:13:47,402 INFO L268 TraceCheckUtils]: 11: Hoare quadruple {355#true} {355#true} #89#return; {355#true} is VALID [2018-11-23 12:13:47,402 INFO L273 TraceCheckUtils]: 12: Hoare triple {355#true} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {355#true} is VALID [2018-11-23 12:13:47,402 INFO L256 TraceCheckUtils]: 13: Hoare triple {355#true} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {355#true} is VALID [2018-11-23 12:13:47,413 INFO L273 TraceCheckUtils]: 14: Hoare triple {355#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {402#(= 0 rangesum_~cnt~0)} is VALID [2018-11-23 12:13:47,416 INFO L273 TraceCheckUtils]: 15: Hoare triple {402#(= 0 rangesum_~cnt~0)} assume !(~i~1 < ~N~0); {402#(= 0 rangesum_~cnt~0)} is VALID [2018-11-23 12:13:47,417 INFO L273 TraceCheckUtils]: 16: Hoare triple {402#(= 0 rangesum_~cnt~0)} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {356#false} is VALID [2018-11-23 12:13:47,417 INFO L273 TraceCheckUtils]: 17: Hoare triple {356#false} assume true; {356#false} is VALID [2018-11-23 12:13:47,418 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {356#false} {355#true} #91#return; {356#false} is VALID [2018-11-23 12:13:47,418 INFO L273 TraceCheckUtils]: 19: Hoare triple {356#false} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {356#false} is VALID [2018-11-23 12:13:47,418 INFO L256 TraceCheckUtils]: 20: Hoare triple {356#false} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {356#false} is VALID [2018-11-23 12:13:47,418 INFO L273 TraceCheckUtils]: 21: Hoare triple {356#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {356#false} is VALID [2018-11-23 12:13:47,419 INFO L273 TraceCheckUtils]: 22: Hoare triple {356#false} assume !(~i~1 < ~N~0); {356#false} is VALID [2018-11-23 12:13:47,419 INFO L273 TraceCheckUtils]: 23: Hoare triple {356#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {356#false} is VALID [2018-11-23 12:13:47,419 INFO L273 TraceCheckUtils]: 24: Hoare triple {356#false} assume true; {356#false} is VALID [2018-11-23 12:13:47,420 INFO L268 TraceCheckUtils]: 25: Hoare quadruple {356#false} {356#false} #93#return; {356#false} is VALID [2018-11-23 12:13:47,420 INFO L273 TraceCheckUtils]: 26: Hoare triple {356#false} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {356#false} is VALID [2018-11-23 12:13:47,420 INFO L273 TraceCheckUtils]: 27: Hoare triple {356#false} assume !(~i~2 < ~N~0 - 1); {356#false} is VALID [2018-11-23 12:13:47,421 INFO L273 TraceCheckUtils]: 28: Hoare triple {356#false} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {356#false} is VALID [2018-11-23 12:13:47,421 INFO L256 TraceCheckUtils]: 29: Hoare triple {356#false} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {356#false} is VALID [2018-11-23 12:13:47,421 INFO L273 TraceCheckUtils]: 30: Hoare triple {356#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {356#false} is VALID [2018-11-23 12:13:47,422 INFO L273 TraceCheckUtils]: 31: Hoare triple {356#false} assume !(~i~1 < ~N~0); {356#false} is VALID [2018-11-23 12:13:47,422 INFO L273 TraceCheckUtils]: 32: Hoare triple {356#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {356#false} is VALID [2018-11-23 12:13:47,422 INFO L273 TraceCheckUtils]: 33: Hoare triple {356#false} assume true; {356#false} is VALID [2018-11-23 12:13:47,422 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {356#false} {356#false} #95#return; {356#false} is VALID [2018-11-23 12:13:47,423 INFO L273 TraceCheckUtils]: 35: Hoare triple {356#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {356#false} is VALID [2018-11-23 12:13:47,423 INFO L273 TraceCheckUtils]: 36: Hoare triple {356#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {356#false} is VALID [2018-11-23 12:13:47,423 INFO L273 TraceCheckUtils]: 37: Hoare triple {356#false} assume !false; {356#false} is VALID [2018-11-23 12:13:47,426 INFO L134 CoverageAnalysis]: Checked inductivity of 15 backedges. 6 proven. 0 refuted. 0 times theorem prover too weak. 9 trivial. 0 not checked. [2018-11-23 12:13:47,446 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:13:47,446 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [3] imperfect sequences [] total 3 [2018-11-23 12:13:47,447 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 38 [2018-11-23 12:13:47,448 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:47,449 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states. [2018-11-23 12:13:47,558 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 33 edges. 33 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:47,558 INFO L459 AbstractCegarLoop]: Interpolant automaton has 3 states [2018-11-23 12:13:47,559 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 3 interpolants. [2018-11-23 12:13:47,559 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:13:47,559 INFO L87 Difference]: Start difference. First operand 33 states and 39 transitions. Second operand 3 states. [2018-11-23 12:13:47,794 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:47,794 INFO L93 Difference]: Finished difference Result 57 states and 75 transitions. [2018-11-23 12:13:47,794 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 3 states. [2018-11-23 12:13:47,795 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 38 [2018-11-23 12:13:47,799 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:47,799 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:13:47,804 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 75 transitions. [2018-11-23 12:13:47,804 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:13:47,809 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 75 transitions. [2018-11-23 12:13:47,809 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states and 75 transitions. [2018-11-23 12:13:48,009 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 75 edges. 75 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:48,013 INFO L225 Difference]: With dead ends: 57 [2018-11-23 12:13:48,014 INFO L226 Difference]: Without dead ends: 39 [2018-11-23 12:13:48,015 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 37 GetRequests, 36 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:13:48,015 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 39 states. [2018-11-23 12:13:48,034 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 39 to 37. [2018-11-23 12:13:48,034 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:48,035 INFO L82 GeneralOperation]: Start isEquivalent. First operand 39 states. Second operand 37 states. [2018-11-23 12:13:48,035 INFO L74 IsIncluded]: Start isIncluded. First operand 39 states. Second operand 37 states. [2018-11-23 12:13:48,035 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 37 states. [2018-11-23 12:13:48,041 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:48,041 INFO L93 Difference]: Finished difference Result 39 states and 49 transitions. [2018-11-23 12:13:48,042 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 49 transitions. [2018-11-23 12:13:48,043 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:48,043 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:48,043 INFO L74 IsIncluded]: Start isIncluded. First operand 37 states. Second operand 39 states. [2018-11-23 12:13:48,043 INFO L87 Difference]: Start difference. First operand 37 states. Second operand 39 states. [2018-11-23 12:13:48,047 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:48,048 INFO L93 Difference]: Finished difference Result 39 states and 49 transitions. [2018-11-23 12:13:48,048 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 49 transitions. [2018-11-23 12:13:48,049 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:48,049 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:48,049 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:48,050 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:48,050 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 37 states. [2018-11-23 12:13:48,053 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 45 transitions. [2018-11-23 12:13:48,053 INFO L78 Accepts]: Start accepts. Automaton has 37 states and 45 transitions. Word has length 38 [2018-11-23 12:13:48,054 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:48,054 INFO L480 AbstractCegarLoop]: Abstraction has 37 states and 45 transitions. [2018-11-23 12:13:48,054 INFO L481 AbstractCegarLoop]: Interpolant automaton has 3 states. [2018-11-23 12:13:48,054 INFO L276 IsEmpty]: Start isEmpty. Operand 37 states and 45 transitions. [2018-11-23 12:13:48,056 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 39 [2018-11-23 12:13:48,056 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:48,056 INFO L402 BasicCegarLoop]: trace histogram [3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:48,057 INFO L423 AbstractCegarLoop]: === Iteration 3 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:48,057 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:48,057 INFO L82 PathProgramCache]: Analyzing trace with hash -1742767491, now seen corresponding path program 1 times [2018-11-23 12:13:48,057 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:48,057 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:48,058 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:48,059 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:48,059 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:48,093 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:48,385 INFO L256 TraceCheckUtils]: 0: Hoare triple {676#true} call ULTIMATE.init(); {676#true} is VALID [2018-11-23 12:13:48,386 INFO L273 TraceCheckUtils]: 1: Hoare triple {676#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {676#true} is VALID [2018-11-23 12:13:48,387 INFO L273 TraceCheckUtils]: 2: Hoare triple {676#true} assume true; {676#true} is VALID [2018-11-23 12:13:48,387 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {676#true} {676#true} #85#return; {676#true} is VALID [2018-11-23 12:13:48,387 INFO L256 TraceCheckUtils]: 4: Hoare triple {676#true} call #t~ret13 := main(); {676#true} is VALID [2018-11-23 12:13:48,387 INFO L273 TraceCheckUtils]: 5: Hoare triple {676#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {676#true} is VALID [2018-11-23 12:13:48,388 INFO L273 TraceCheckUtils]: 6: Hoare triple {676#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {676#true} is VALID [2018-11-23 12:13:48,388 INFO L256 TraceCheckUtils]: 7: Hoare triple {676#true} call init_nondet(~#x~0.base, ~#x~0.offset); {676#true} is VALID [2018-11-23 12:13:48,388 INFO L273 TraceCheckUtils]: 8: Hoare triple {676#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {676#true} is VALID [2018-11-23 12:13:48,388 INFO L273 TraceCheckUtils]: 9: Hoare triple {676#true} assume !(~i~0 < ~N~0); {676#true} is VALID [2018-11-23 12:13:48,389 INFO L273 TraceCheckUtils]: 10: Hoare triple {676#true} assume true; {676#true} is VALID [2018-11-23 12:13:48,389 INFO L268 TraceCheckUtils]: 11: Hoare quadruple {676#true} {676#true} #89#return; {676#true} is VALID [2018-11-23 12:13:48,389 INFO L273 TraceCheckUtils]: 12: Hoare triple {676#true} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {676#true} is VALID [2018-11-23 12:13:48,390 INFO L256 TraceCheckUtils]: 13: Hoare triple {676#true} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {676#true} is VALID [2018-11-23 12:13:48,390 INFO L273 TraceCheckUtils]: 14: Hoare triple {676#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {676#true} is VALID [2018-11-23 12:13:48,390 INFO L273 TraceCheckUtils]: 15: Hoare triple {676#true} assume !(~i~1 < ~N~0); {676#true} is VALID [2018-11-23 12:13:48,391 INFO L273 TraceCheckUtils]: 16: Hoare triple {676#true} assume !(0 != ~cnt~0);#res := 0; {678#(= |rangesum_#res| 0)} is VALID [2018-11-23 12:13:48,392 INFO L273 TraceCheckUtils]: 17: Hoare triple {678#(= |rangesum_#res| 0)} assume true; {678#(= |rangesum_#res| 0)} is VALID [2018-11-23 12:13:48,393 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {678#(= |rangesum_#res| 0)} {676#true} #91#return; {679#(= |main_#t~ret5| 0)} is VALID [2018-11-23 12:13:48,393 INFO L273 TraceCheckUtils]: 19: Hoare triple {679#(= |main_#t~ret5| 0)} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {680#(= main_~ret~1 0)} is VALID [2018-11-23 12:13:48,394 INFO L256 TraceCheckUtils]: 20: Hoare triple {680#(= main_~ret~1 0)} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {676#true} is VALID [2018-11-23 12:13:48,394 INFO L273 TraceCheckUtils]: 21: Hoare triple {676#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {676#true} is VALID [2018-11-23 12:13:48,394 INFO L273 TraceCheckUtils]: 22: Hoare triple {676#true} assume !(~i~1 < ~N~0); {676#true} is VALID [2018-11-23 12:13:48,395 INFO L273 TraceCheckUtils]: 23: Hoare triple {676#true} assume !(0 != ~cnt~0);#res := 0; {678#(= |rangesum_#res| 0)} is VALID [2018-11-23 12:13:48,396 INFO L273 TraceCheckUtils]: 24: Hoare triple {678#(= |rangesum_#res| 0)} assume true; {678#(= |rangesum_#res| 0)} is VALID [2018-11-23 12:13:48,397 INFO L268 TraceCheckUtils]: 25: Hoare quadruple {678#(= |rangesum_#res| 0)} {680#(= main_~ret~1 0)} #93#return; {681#(and (= main_~ret~1 0) (= main_~ret~1 |main_#t~ret8|))} is VALID [2018-11-23 12:13:48,399 INFO L273 TraceCheckUtils]: 26: Hoare triple {681#(and (= main_~ret~1 0) (= main_~ret~1 |main_#t~ret8|))} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {682#(and (= main_~ret~1 0) (= main_~ret2~0 main_~ret~1))} is VALID [2018-11-23 12:13:48,400 INFO L273 TraceCheckUtils]: 27: Hoare triple {682#(and (= main_~ret~1 0) (= main_~ret2~0 main_~ret~1))} assume !(~i~2 < ~N~0 - 1); {682#(and (= main_~ret~1 0) (= main_~ret2~0 main_~ret~1))} is VALID [2018-11-23 12:13:48,401 INFO L273 TraceCheckUtils]: 28: Hoare triple {682#(and (= main_~ret~1 0) (= main_~ret2~0 main_~ret~1))} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {682#(and (= main_~ret~1 0) (= main_~ret2~0 main_~ret~1))} is VALID [2018-11-23 12:13:48,402 INFO L256 TraceCheckUtils]: 29: Hoare triple {682#(and (= main_~ret~1 0) (= main_~ret2~0 main_~ret~1))} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {676#true} is VALID [2018-11-23 12:13:48,402 INFO L273 TraceCheckUtils]: 30: Hoare triple {676#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {676#true} is VALID [2018-11-23 12:13:48,402 INFO L273 TraceCheckUtils]: 31: Hoare triple {676#true} assume !(~i~1 < ~N~0); {676#true} is VALID [2018-11-23 12:13:48,403 INFO L273 TraceCheckUtils]: 32: Hoare triple {676#true} assume !(0 != ~cnt~0);#res := 0; {678#(= |rangesum_#res| 0)} is VALID [2018-11-23 12:13:48,403 INFO L273 TraceCheckUtils]: 33: Hoare triple {678#(= |rangesum_#res| 0)} assume true; {678#(= |rangesum_#res| 0)} is VALID [2018-11-23 12:13:48,407 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {678#(= |rangesum_#res| 0)} {682#(and (= main_~ret~1 0) (= main_~ret2~0 main_~ret~1))} #95#return; {683#(and (= main_~ret~1 |main_#t~ret12|) (= main_~ret2~0 main_~ret~1))} is VALID [2018-11-23 12:13:48,408 INFO L273 TraceCheckUtils]: 35: Hoare triple {683#(and (= main_~ret~1 |main_#t~ret12|) (= main_~ret2~0 main_~ret~1))} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {684#(and (= main_~ret5~0 main_~ret~1) (= main_~ret2~0 main_~ret~1))} is VALID [2018-11-23 12:13:48,408 INFO L273 TraceCheckUtils]: 36: Hoare triple {684#(and (= main_~ret5~0 main_~ret~1) (= main_~ret2~0 main_~ret~1))} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {677#false} is VALID [2018-11-23 12:13:48,409 INFO L273 TraceCheckUtils]: 37: Hoare triple {677#false} assume !false; {677#false} is VALID [2018-11-23 12:13:48,412 INFO L134 CoverageAnalysis]: Checked inductivity of 15 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:13:48,413 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:13:48,413 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [9] imperfect sequences [] total 9 [2018-11-23 12:13:48,414 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 38 [2018-11-23 12:13:48,414 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:48,414 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states. [2018-11-23 12:13:48,495 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 30 edges. 30 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:48,495 INFO L459 AbstractCegarLoop]: Interpolant automaton has 9 states [2018-11-23 12:13:48,496 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 9 interpolants. [2018-11-23 12:13:48,496 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=17, Invalid=55, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:13:48,496 INFO L87 Difference]: Start difference. First operand 37 states and 45 transitions. Second operand 9 states. [2018-11-23 12:13:49,211 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:49,212 INFO L93 Difference]: Finished difference Result 63 states and 78 transitions. [2018-11-23 12:13:49,212 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 9 states. [2018-11-23 12:13:49,212 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 38 [2018-11-23 12:13:49,213 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:49,213 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:13:49,217 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 72 transitions. [2018-11-23 12:13:49,217 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:13:49,221 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 72 transitions. [2018-11-23 12:13:49,221 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states and 72 transitions. [2018-11-23 12:13:49,446 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 72 edges. 72 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:49,449 INFO L225 Difference]: With dead ends: 63 [2018-11-23 12:13:49,449 INFO L226 Difference]: Without dead ends: 59 [2018-11-23 12:13:49,450 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 13 GetRequests, 2 SyntacticMatches, 2 SemanticMatches, 9 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 5 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=27, Invalid=83, Unknown=0, NotChecked=0, Total=110 [2018-11-23 12:13:49,450 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 59 states. [2018-11-23 12:13:49,492 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 59 to 46. [2018-11-23 12:13:49,493 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:49,493 INFO L82 GeneralOperation]: Start isEquivalent. First operand 59 states. Second operand 46 states. [2018-11-23 12:13:49,493 INFO L74 IsIncluded]: Start isIncluded. First operand 59 states. Second operand 46 states. [2018-11-23 12:13:49,493 INFO L87 Difference]: Start difference. First operand 59 states. Second operand 46 states. [2018-11-23 12:13:49,501 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:49,501 INFO L93 Difference]: Finished difference Result 59 states and 74 transitions. [2018-11-23 12:13:49,501 INFO L276 IsEmpty]: Start isEmpty. Operand 59 states and 74 transitions. [2018-11-23 12:13:49,504 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:49,504 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:49,504 INFO L74 IsIncluded]: Start isIncluded. First operand 46 states. Second operand 59 states. [2018-11-23 12:13:49,504 INFO L87 Difference]: Start difference. First operand 46 states. Second operand 59 states. [2018-11-23 12:13:49,509 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:49,510 INFO L93 Difference]: Finished difference Result 59 states and 74 transitions. [2018-11-23 12:13:49,510 INFO L276 IsEmpty]: Start isEmpty. Operand 59 states and 74 transitions. [2018-11-23 12:13:49,511 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:49,512 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:49,512 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:49,512 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:49,512 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 46 states. [2018-11-23 12:13:49,516 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 46 states to 46 states and 60 transitions. [2018-11-23 12:13:49,516 INFO L78 Accepts]: Start accepts. Automaton has 46 states and 60 transitions. Word has length 38 [2018-11-23 12:13:49,517 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:49,517 INFO L480 AbstractCegarLoop]: Abstraction has 46 states and 60 transitions. [2018-11-23 12:13:49,517 INFO L481 AbstractCegarLoop]: Interpolant automaton has 9 states. [2018-11-23 12:13:49,517 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 60 transitions. [2018-11-23 12:13:49,519 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 42 [2018-11-23 12:13:49,519 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:49,519 INFO L402 BasicCegarLoop]: trace histogram [3, 3, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:49,520 INFO L423 AbstractCegarLoop]: === Iteration 4 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:49,520 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:49,520 INFO L82 PathProgramCache]: Analyzing trace with hash 699235283, now seen corresponding path program 1 times [2018-11-23 12:13:49,520 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:49,521 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:49,522 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:49,522 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:49,522 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:49,552 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:49,552 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:49,552 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 4 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 4 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:49,576 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:49,609 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:49,636 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:49,638 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:49,814 INFO L256 TraceCheckUtils]: 0: Hoare triple {954#true} call ULTIMATE.init(); {954#true} is VALID [2018-11-23 12:13:49,815 INFO L273 TraceCheckUtils]: 1: Hoare triple {954#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {954#true} is VALID [2018-11-23 12:13:49,815 INFO L273 TraceCheckUtils]: 2: Hoare triple {954#true} assume true; {954#true} is VALID [2018-11-23 12:13:49,815 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {954#true} {954#true} #85#return; {954#true} is VALID [2018-11-23 12:13:49,816 INFO L256 TraceCheckUtils]: 4: Hoare triple {954#true} call #t~ret13 := main(); {954#true} is VALID [2018-11-23 12:13:49,816 INFO L273 TraceCheckUtils]: 5: Hoare triple {954#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {954#true} is VALID [2018-11-23 12:13:49,818 INFO L273 TraceCheckUtils]: 6: Hoare triple {954#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {977#(< 1 ~N~0)} is VALID [2018-11-23 12:13:49,834 INFO L256 TraceCheckUtils]: 7: Hoare triple {977#(< 1 ~N~0)} call init_nondet(~#x~0.base, ~#x~0.offset); {977#(< 1 ~N~0)} is VALID [2018-11-23 12:13:49,835 INFO L273 TraceCheckUtils]: 8: Hoare triple {977#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {984#(and (<= init_nondet_~i~0 0) (< 1 ~N~0))} is VALID [2018-11-23 12:13:49,836 INFO L273 TraceCheckUtils]: 9: Hoare triple {984#(and (<= init_nondet_~i~0 0) (< 1 ~N~0))} assume !(~i~0 < ~N~0); {955#false} is VALID [2018-11-23 12:13:49,836 INFO L273 TraceCheckUtils]: 10: Hoare triple {955#false} assume true; {955#false} is VALID [2018-11-23 12:13:49,836 INFO L268 TraceCheckUtils]: 11: Hoare quadruple {955#false} {977#(< 1 ~N~0)} #89#return; {955#false} is VALID [2018-11-23 12:13:49,837 INFO L273 TraceCheckUtils]: 12: Hoare triple {955#false} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {955#false} is VALID [2018-11-23 12:13:49,837 INFO L256 TraceCheckUtils]: 13: Hoare triple {955#false} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {955#false} is VALID [2018-11-23 12:13:49,837 INFO L273 TraceCheckUtils]: 14: Hoare triple {955#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {955#false} is VALID [2018-11-23 12:13:49,838 INFO L273 TraceCheckUtils]: 15: Hoare triple {955#false} assume !(~i~1 < ~N~0); {955#false} is VALID [2018-11-23 12:13:49,838 INFO L273 TraceCheckUtils]: 16: Hoare triple {955#false} assume !(0 != ~cnt~0);#res := 0; {955#false} is VALID [2018-11-23 12:13:49,838 INFO L273 TraceCheckUtils]: 17: Hoare triple {955#false} assume true; {955#false} is VALID [2018-11-23 12:13:49,838 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {955#false} {955#false} #91#return; {955#false} is VALID [2018-11-23 12:13:49,839 INFO L273 TraceCheckUtils]: 19: Hoare triple {955#false} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {955#false} is VALID [2018-11-23 12:13:49,839 INFO L256 TraceCheckUtils]: 20: Hoare triple {955#false} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {955#false} is VALID [2018-11-23 12:13:49,839 INFO L273 TraceCheckUtils]: 21: Hoare triple {955#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {955#false} is VALID [2018-11-23 12:13:49,840 INFO L273 TraceCheckUtils]: 22: Hoare triple {955#false} assume !(~i~1 < ~N~0); {955#false} is VALID [2018-11-23 12:13:49,840 INFO L273 TraceCheckUtils]: 23: Hoare triple {955#false} assume !(0 != ~cnt~0);#res := 0; {955#false} is VALID [2018-11-23 12:13:49,840 INFO L273 TraceCheckUtils]: 24: Hoare triple {955#false} assume true; {955#false} is VALID [2018-11-23 12:13:49,841 INFO L268 TraceCheckUtils]: 25: Hoare quadruple {955#false} {955#false} #93#return; {955#false} is VALID [2018-11-23 12:13:49,841 INFO L273 TraceCheckUtils]: 26: Hoare triple {955#false} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {955#false} is VALID [2018-11-23 12:13:49,841 INFO L273 TraceCheckUtils]: 27: Hoare triple {955#false} assume !(~i~2 < ~N~0 - 1); {955#false} is VALID [2018-11-23 12:13:49,841 INFO L273 TraceCheckUtils]: 28: Hoare triple {955#false} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {955#false} is VALID [2018-11-23 12:13:49,842 INFO L256 TraceCheckUtils]: 29: Hoare triple {955#false} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {955#false} is VALID [2018-11-23 12:13:49,842 INFO L273 TraceCheckUtils]: 30: Hoare triple {955#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {955#false} is VALID [2018-11-23 12:13:49,842 INFO L273 TraceCheckUtils]: 31: Hoare triple {955#false} assume !!(~i~1 < ~N~0); {955#false} is VALID [2018-11-23 12:13:49,843 INFO L273 TraceCheckUtils]: 32: Hoare triple {955#false} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {955#false} is VALID [2018-11-23 12:13:49,843 INFO L273 TraceCheckUtils]: 33: Hoare triple {955#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {955#false} is VALID [2018-11-23 12:13:49,843 INFO L273 TraceCheckUtils]: 34: Hoare triple {955#false} assume !(~i~1 < ~N~0); {955#false} is VALID [2018-11-23 12:13:49,843 INFO L273 TraceCheckUtils]: 35: Hoare triple {955#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {955#false} is VALID [2018-11-23 12:13:49,844 INFO L273 TraceCheckUtils]: 36: Hoare triple {955#false} assume true; {955#false} is VALID [2018-11-23 12:13:49,844 INFO L268 TraceCheckUtils]: 37: Hoare quadruple {955#false} {955#false} #95#return; {955#false} is VALID [2018-11-23 12:13:49,844 INFO L273 TraceCheckUtils]: 38: Hoare triple {955#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {955#false} is VALID [2018-11-23 12:13:49,845 INFO L273 TraceCheckUtils]: 39: Hoare triple {955#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {955#false} is VALID [2018-11-23 12:13:49,845 INFO L273 TraceCheckUtils]: 40: Hoare triple {955#false} assume !false; {955#false} is VALID [2018-11-23 12:13:49,850 INFO L134 CoverageAnalysis]: Checked inductivity of 18 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 18 trivial. 0 not checked. [2018-11-23 12:13:49,873 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:13:49,874 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [4] imperfect sequences [] total 4 [2018-11-23 12:13:49,874 INFO L78 Accepts]: Start accepts. Automaton has 4 states. Word has length 41 [2018-11-23 12:13:49,875 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:49,875 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 4 states. [2018-11-23 12:13:50,003 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 34 edges. 34 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:50,004 INFO L459 AbstractCegarLoop]: Interpolant automaton has 4 states [2018-11-23 12:13:50,004 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 4 interpolants. [2018-11-23 12:13:50,004 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=6, Invalid=6, Unknown=0, NotChecked=0, Total=12 [2018-11-23 12:13:50,004 INFO L87 Difference]: Start difference. First operand 46 states and 60 transitions. Second operand 4 states. [2018-11-23 12:13:50,268 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:50,269 INFO L93 Difference]: Finished difference Result 83 states and 111 transitions. [2018-11-23 12:13:50,269 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 4 states. [2018-11-23 12:13:50,269 INFO L78 Accepts]: Start accepts. Automaton has 4 states. Word has length 41 [2018-11-23 12:13:50,269 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:50,269 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 4 states. [2018-11-23 12:13:50,271 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 69 transitions. [2018-11-23 12:13:50,272 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 4 states. [2018-11-23 12:13:50,274 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 69 transitions. [2018-11-23 12:13:50,274 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 4 states and 69 transitions. [2018-11-23 12:13:50,446 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:13:50,449 INFO L225 Difference]: With dead ends: 83 [2018-11-23 12:13:50,450 INFO L226 Difference]: Without dead ends: 48 [2018-11-23 12:13:50,451 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 40 GetRequests, 37 SyntacticMatches, 1 SemanticMatches, 2 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=6, Invalid=6, Unknown=0, NotChecked=0, Total=12 [2018-11-23 12:13:50,451 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 48 states. [2018-11-23 12:13:50,508 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 48 to 47. [2018-11-23 12:13:50,508 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:50,508 INFO L82 GeneralOperation]: Start isEquivalent. First operand 48 states. Second operand 47 states. [2018-11-23 12:13:50,508 INFO L74 IsIncluded]: Start isIncluded. First operand 48 states. Second operand 47 states. [2018-11-23 12:13:50,509 INFO L87 Difference]: Start difference. First operand 48 states. Second operand 47 states. [2018-11-23 12:13:50,512 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:50,513 INFO L93 Difference]: Finished difference Result 48 states and 62 transitions. [2018-11-23 12:13:50,513 INFO L276 IsEmpty]: Start isEmpty. Operand 48 states and 62 transitions. [2018-11-23 12:13:50,514 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:50,514 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:50,515 INFO L74 IsIncluded]: Start isIncluded. First operand 47 states. Second operand 48 states. [2018-11-23 12:13:50,515 INFO L87 Difference]: Start difference. First operand 47 states. Second operand 48 states. [2018-11-23 12:13:50,518 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:50,519 INFO L93 Difference]: Finished difference Result 48 states and 62 transitions. [2018-11-23 12:13:50,519 INFO L276 IsEmpty]: Start isEmpty. Operand 48 states and 62 transitions. [2018-11-23 12:13:50,520 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:50,520 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:50,520 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:50,520 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:50,521 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 47 states. [2018-11-23 12:13:50,524 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 47 states to 47 states and 61 transitions. [2018-11-23 12:13:50,524 INFO L78 Accepts]: Start accepts. Automaton has 47 states and 61 transitions. Word has length 41 [2018-11-23 12:13:50,524 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:50,524 INFO L480 AbstractCegarLoop]: Abstraction has 47 states and 61 transitions. [2018-11-23 12:13:50,525 INFO L481 AbstractCegarLoop]: Interpolant automaton has 4 states. [2018-11-23 12:13:50,525 INFO L276 IsEmpty]: Start isEmpty. Operand 47 states and 61 transitions. [2018-11-23 12:13:50,526 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 44 [2018-11-23 12:13:50,526 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:50,526 INFO L402 BasicCegarLoop]: trace histogram [3, 3, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:50,527 INFO L423 AbstractCegarLoop]: === Iteration 5 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:50,527 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:50,527 INFO L82 PathProgramCache]: Analyzing trace with hash 1178839093, now seen corresponding path program 1 times [2018-11-23 12:13:50,527 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:50,528 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:50,529 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:50,529 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:50,529 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:50,560 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:50,560 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:50,561 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 5 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 5 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:50,574 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:50,612 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:50,647 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:50,651 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:51,174 INFO L256 TraceCheckUtils]: 0: Hoare triple {1352#true} call ULTIMATE.init(); {1352#true} is VALID [2018-11-23 12:13:51,174 INFO L273 TraceCheckUtils]: 1: Hoare triple {1352#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {1352#true} is VALID [2018-11-23 12:13:51,175 INFO L273 TraceCheckUtils]: 2: Hoare triple {1352#true} assume true; {1352#true} is VALID [2018-11-23 12:13:51,175 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1352#true} {1352#true} #85#return; {1352#true} is VALID [2018-11-23 12:13:51,175 INFO L256 TraceCheckUtils]: 4: Hoare triple {1352#true} call #t~ret13 := main(); {1352#true} is VALID [2018-11-23 12:13:51,176 INFO L273 TraceCheckUtils]: 5: Hoare triple {1352#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {1352#true} is VALID [2018-11-23 12:13:51,185 INFO L273 TraceCheckUtils]: 6: Hoare triple {1352#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {1375#(< 1 ~N~0)} is VALID [2018-11-23 12:13:51,187 INFO L256 TraceCheckUtils]: 7: Hoare triple {1375#(< 1 ~N~0)} call init_nondet(~#x~0.base, ~#x~0.offset); {1375#(< 1 ~N~0)} is VALID [2018-11-23 12:13:51,187 INFO L273 TraceCheckUtils]: 8: Hoare triple {1375#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {1382#(and (<= init_nondet_~i~0 0) (< 1 ~N~0))} is VALID [2018-11-23 12:13:51,188 INFO L273 TraceCheckUtils]: 9: Hoare triple {1382#(and (<= init_nondet_~i~0 0) (< 1 ~N~0))} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {1382#(and (<= init_nondet_~i~0 0) (< 1 ~N~0))} is VALID [2018-11-23 12:13:51,190 INFO L273 TraceCheckUtils]: 10: Hoare triple {1382#(and (<= init_nondet_~i~0 0) (< 1 ~N~0))} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {1389#(and (< 1 ~N~0) (<= init_nondet_~i~0 1))} is VALID [2018-11-23 12:13:51,191 INFO L273 TraceCheckUtils]: 11: Hoare triple {1389#(and (< 1 ~N~0) (<= init_nondet_~i~0 1))} assume !(~i~0 < ~N~0); {1353#false} is VALID [2018-11-23 12:13:51,191 INFO L273 TraceCheckUtils]: 12: Hoare triple {1353#false} assume true; {1353#false} is VALID [2018-11-23 12:13:51,192 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {1353#false} {1375#(< 1 ~N~0)} #89#return; {1353#false} is VALID [2018-11-23 12:13:51,192 INFO L273 TraceCheckUtils]: 14: Hoare triple {1353#false} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {1353#false} is VALID [2018-11-23 12:13:51,192 INFO L256 TraceCheckUtils]: 15: Hoare triple {1353#false} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {1353#false} is VALID [2018-11-23 12:13:51,192 INFO L273 TraceCheckUtils]: 16: Hoare triple {1353#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {1353#false} is VALID [2018-11-23 12:13:51,192 INFO L273 TraceCheckUtils]: 17: Hoare triple {1353#false} assume !(~i~1 < ~N~0); {1353#false} is VALID [2018-11-23 12:13:51,193 INFO L273 TraceCheckUtils]: 18: Hoare triple {1353#false} assume !(0 != ~cnt~0);#res := 0; {1353#false} is VALID [2018-11-23 12:13:51,193 INFO L273 TraceCheckUtils]: 19: Hoare triple {1353#false} assume true; {1353#false} is VALID [2018-11-23 12:13:51,193 INFO L268 TraceCheckUtils]: 20: Hoare quadruple {1353#false} {1353#false} #91#return; {1353#false} is VALID [2018-11-23 12:13:51,193 INFO L273 TraceCheckUtils]: 21: Hoare triple {1353#false} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {1353#false} is VALID [2018-11-23 12:13:51,194 INFO L256 TraceCheckUtils]: 22: Hoare triple {1353#false} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {1353#false} is VALID [2018-11-23 12:13:51,194 INFO L273 TraceCheckUtils]: 23: Hoare triple {1353#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {1353#false} is VALID [2018-11-23 12:13:51,194 INFO L273 TraceCheckUtils]: 24: Hoare triple {1353#false} assume !(~i~1 < ~N~0); {1353#false} is VALID [2018-11-23 12:13:51,194 INFO L273 TraceCheckUtils]: 25: Hoare triple {1353#false} assume !(0 != ~cnt~0);#res := 0; {1353#false} is VALID [2018-11-23 12:13:51,194 INFO L273 TraceCheckUtils]: 26: Hoare triple {1353#false} assume true; {1353#false} is VALID [2018-11-23 12:13:51,195 INFO L268 TraceCheckUtils]: 27: Hoare quadruple {1353#false} {1353#false} #93#return; {1353#false} is VALID [2018-11-23 12:13:51,195 INFO L273 TraceCheckUtils]: 28: Hoare triple {1353#false} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {1353#false} is VALID [2018-11-23 12:13:51,195 INFO L273 TraceCheckUtils]: 29: Hoare triple {1353#false} assume !(~i~2 < ~N~0 - 1); {1353#false} is VALID [2018-11-23 12:13:51,196 INFO L273 TraceCheckUtils]: 30: Hoare triple {1353#false} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {1353#false} is VALID [2018-11-23 12:13:51,196 INFO L256 TraceCheckUtils]: 31: Hoare triple {1353#false} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {1353#false} is VALID [2018-11-23 12:13:51,196 INFO L273 TraceCheckUtils]: 32: Hoare triple {1353#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {1353#false} is VALID [2018-11-23 12:13:51,196 INFO L273 TraceCheckUtils]: 33: Hoare triple {1353#false} assume !!(~i~1 < ~N~0); {1353#false} is VALID [2018-11-23 12:13:51,197 INFO L273 TraceCheckUtils]: 34: Hoare triple {1353#false} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {1353#false} is VALID [2018-11-23 12:13:51,197 INFO L273 TraceCheckUtils]: 35: Hoare triple {1353#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {1353#false} is VALID [2018-11-23 12:13:51,197 INFO L273 TraceCheckUtils]: 36: Hoare triple {1353#false} assume !(~i~1 < ~N~0); {1353#false} is VALID [2018-11-23 12:13:51,197 INFO L273 TraceCheckUtils]: 37: Hoare triple {1353#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {1353#false} is VALID [2018-11-23 12:13:51,198 INFO L273 TraceCheckUtils]: 38: Hoare triple {1353#false} assume true; {1353#false} is VALID [2018-11-23 12:13:51,198 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {1353#false} {1353#false} #95#return; {1353#false} is VALID [2018-11-23 12:13:51,198 INFO L273 TraceCheckUtils]: 40: Hoare triple {1353#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {1353#false} is VALID [2018-11-23 12:13:51,199 INFO L273 TraceCheckUtils]: 41: Hoare triple {1353#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {1353#false} is VALID [2018-11-23 12:13:51,199 INFO L273 TraceCheckUtils]: 42: Hoare triple {1353#false} assume !false; {1353#false} is VALID [2018-11-23 12:13:51,202 INFO L134 CoverageAnalysis]: Checked inductivity of 19 backedges. 0 proven. 1 refuted. 0 times theorem prover too weak. 18 trivial. 0 not checked. [2018-11-23 12:13:51,233 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 1 imperfect interpolant sequences. [2018-11-23 12:13:51,234 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [5] total 5 [2018-11-23 12:13:51,234 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 43 [2018-11-23 12:13:51,234 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:51,234 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 12:13:51,285 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 36 edges. 36 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:51,286 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 12:13:51,286 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 12:13:51,286 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:13:51,287 INFO L87 Difference]: Start difference. First operand 47 states and 61 transitions. Second operand 5 states. [2018-11-23 12:13:51,583 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:51,583 INFO L93 Difference]: Finished difference Result 85 states and 113 transitions. [2018-11-23 12:13:51,584 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 12:13:51,584 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 43 [2018-11-23 12:13:51,584 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:51,584 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:13:51,587 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 71 transitions. [2018-11-23 12:13:51,587 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:13:51,589 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 71 transitions. [2018-11-23 12:13:51,590 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 71 transitions. [2018-11-23 12:13:51,785 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 71 edges. 71 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:51,788 INFO L225 Difference]: With dead ends: 85 [2018-11-23 12:13:51,788 INFO L226 Difference]: Without dead ends: 50 [2018-11-23 12:13:51,789 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 42 GetRequests, 38 SyntacticMatches, 1 SemanticMatches, 3 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:13:51,790 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 50 states. [2018-11-23 12:13:51,838 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 50 to 49. [2018-11-23 12:13:51,838 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:51,838 INFO L82 GeneralOperation]: Start isEquivalent. First operand 50 states. Second operand 49 states. [2018-11-23 12:13:51,838 INFO L74 IsIncluded]: Start isIncluded. First operand 50 states. Second operand 49 states. [2018-11-23 12:13:51,838 INFO L87 Difference]: Start difference. First operand 50 states. Second operand 49 states. [2018-11-23 12:13:51,842 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:51,843 INFO L93 Difference]: Finished difference Result 50 states and 64 transitions. [2018-11-23 12:13:51,843 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 64 transitions. [2018-11-23 12:13:51,843 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:51,844 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:51,844 INFO L74 IsIncluded]: Start isIncluded. First operand 49 states. Second operand 50 states. [2018-11-23 12:13:51,844 INFO L87 Difference]: Start difference. First operand 49 states. Second operand 50 states. [2018-11-23 12:13:51,847 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:51,847 INFO L93 Difference]: Finished difference Result 50 states and 64 transitions. [2018-11-23 12:13:51,847 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 64 transitions. [2018-11-23 12:13:51,848 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:51,848 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:51,848 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:51,848 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:51,848 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 49 states. [2018-11-23 12:13:51,851 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 49 states to 49 states and 63 transitions. [2018-11-23 12:13:51,851 INFO L78 Accepts]: Start accepts. Automaton has 49 states and 63 transitions. Word has length 43 [2018-11-23 12:13:51,852 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:51,852 INFO L480 AbstractCegarLoop]: Abstraction has 49 states and 63 transitions. [2018-11-23 12:13:51,852 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 12:13:51,852 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 63 transitions. [2018-11-23 12:13:51,853 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 46 [2018-11-23 12:13:51,853 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:51,854 INFO L402 BasicCegarLoop]: trace histogram [3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:51,854 INFO L423 AbstractCegarLoop]: === Iteration 6 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:51,854 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:51,854 INFO L82 PathProgramCache]: Analyzing trace with hash -1778367465, now seen corresponding path program 2 times [2018-11-23 12:13:51,854 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:51,855 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:51,855 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:51,855 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:51,856 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:51,875 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:51,875 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:51,875 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 6 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 6 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:51,899 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:13:51,937 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:13:51,937 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:13:51,954 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:51,956 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:52,151 INFO L256 TraceCheckUtils]: 0: Hoare triple {1767#true} call ULTIMATE.init(); {1767#true} is VALID [2018-11-23 12:13:52,151 INFO L273 TraceCheckUtils]: 1: Hoare triple {1767#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {1767#true} is VALID [2018-11-23 12:13:52,151 INFO L273 TraceCheckUtils]: 2: Hoare triple {1767#true} assume true; {1767#true} is VALID [2018-11-23 12:13:52,152 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1767#true} {1767#true} #85#return; {1767#true} is VALID [2018-11-23 12:13:52,152 INFO L256 TraceCheckUtils]: 4: Hoare triple {1767#true} call #t~ret13 := main(); {1767#true} is VALID [2018-11-23 12:13:52,152 INFO L273 TraceCheckUtils]: 5: Hoare triple {1767#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {1767#true} is VALID [2018-11-23 12:13:52,153 INFO L273 TraceCheckUtils]: 6: Hoare triple {1767#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,154 INFO L256 TraceCheckUtils]: 7: Hoare triple {1790#(< 1 ~N~0)} call init_nondet(~#x~0.base, ~#x~0.offset); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,154 INFO L273 TraceCheckUtils]: 8: Hoare triple {1790#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,155 INFO L273 TraceCheckUtils]: 9: Hoare triple {1790#(< 1 ~N~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,155 INFO L273 TraceCheckUtils]: 10: Hoare triple {1790#(< 1 ~N~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,156 INFO L273 TraceCheckUtils]: 11: Hoare triple {1790#(< 1 ~N~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,157 INFO L273 TraceCheckUtils]: 12: Hoare triple {1790#(< 1 ~N~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,157 INFO L273 TraceCheckUtils]: 13: Hoare triple {1790#(< 1 ~N~0)} assume !(~i~0 < ~N~0); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,158 INFO L273 TraceCheckUtils]: 14: Hoare triple {1790#(< 1 ~N~0)} assume true; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,159 INFO L268 TraceCheckUtils]: 15: Hoare quadruple {1790#(< 1 ~N~0)} {1790#(< 1 ~N~0)} #89#return; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,160 INFO L273 TraceCheckUtils]: 16: Hoare triple {1790#(< 1 ~N~0)} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,162 INFO L256 TraceCheckUtils]: 17: Hoare triple {1790#(< 1 ~N~0)} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,163 INFO L273 TraceCheckUtils]: 18: Hoare triple {1790#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,163 INFO L273 TraceCheckUtils]: 19: Hoare triple {1790#(< 1 ~N~0)} assume !(~i~1 < ~N~0); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,164 INFO L273 TraceCheckUtils]: 20: Hoare triple {1790#(< 1 ~N~0)} assume !(0 != ~cnt~0);#res := 0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,165 INFO L273 TraceCheckUtils]: 21: Hoare triple {1790#(< 1 ~N~0)} assume true; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,166 INFO L268 TraceCheckUtils]: 22: Hoare quadruple {1790#(< 1 ~N~0)} {1790#(< 1 ~N~0)} #91#return; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,167 INFO L273 TraceCheckUtils]: 23: Hoare triple {1790#(< 1 ~N~0)} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,169 INFO L256 TraceCheckUtils]: 24: Hoare triple {1790#(< 1 ~N~0)} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,169 INFO L273 TraceCheckUtils]: 25: Hoare triple {1790#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,170 INFO L273 TraceCheckUtils]: 26: Hoare triple {1790#(< 1 ~N~0)} assume !(~i~1 < ~N~0); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,171 INFO L273 TraceCheckUtils]: 27: Hoare triple {1790#(< 1 ~N~0)} assume !(0 != ~cnt~0);#res := 0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,173 INFO L273 TraceCheckUtils]: 28: Hoare triple {1790#(< 1 ~N~0)} assume true; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,176 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {1790#(< 1 ~N~0)} {1790#(< 1 ~N~0)} #93#return; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,177 INFO L273 TraceCheckUtils]: 30: Hoare triple {1790#(< 1 ~N~0)} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,177 INFO L273 TraceCheckUtils]: 31: Hoare triple {1790#(< 1 ~N~0)} assume !(~i~2 < ~N~0 - 1); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,178 INFO L273 TraceCheckUtils]: 32: Hoare triple {1790#(< 1 ~N~0)} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,179 INFO L256 TraceCheckUtils]: 33: Hoare triple {1790#(< 1 ~N~0)} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {1790#(< 1 ~N~0)} is VALID [2018-11-23 12:13:52,181 INFO L273 TraceCheckUtils]: 34: Hoare triple {1790#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {1875#(and (<= rangesum_~i~1 0) (< 1 ~N~0))} is VALID [2018-11-23 12:13:52,182 INFO L273 TraceCheckUtils]: 35: Hoare triple {1875#(and (<= rangesum_~i~1 0) (< 1 ~N~0))} assume !!(~i~1 < ~N~0); {1875#(and (<= rangesum_~i~1 0) (< 1 ~N~0))} is VALID [2018-11-23 12:13:52,183 INFO L273 TraceCheckUtils]: 36: Hoare triple {1875#(and (<= rangesum_~i~1 0) (< 1 ~N~0))} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {1875#(and (<= rangesum_~i~1 0) (< 1 ~N~0))} is VALID [2018-11-23 12:13:52,184 INFO L273 TraceCheckUtils]: 37: Hoare triple {1875#(and (<= rangesum_~i~1 0) (< 1 ~N~0))} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {1885#(and (<= rangesum_~i~1 1) (< 1 ~N~0))} is VALID [2018-11-23 12:13:52,185 INFO L273 TraceCheckUtils]: 38: Hoare triple {1885#(and (<= rangesum_~i~1 1) (< 1 ~N~0))} assume !(~i~1 < ~N~0); {1768#false} is VALID [2018-11-23 12:13:52,186 INFO L273 TraceCheckUtils]: 39: Hoare triple {1768#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {1768#false} is VALID [2018-11-23 12:13:52,186 INFO L273 TraceCheckUtils]: 40: Hoare triple {1768#false} assume true; {1768#false} is VALID [2018-11-23 12:13:52,186 INFO L268 TraceCheckUtils]: 41: Hoare quadruple {1768#false} {1790#(< 1 ~N~0)} #95#return; {1768#false} is VALID [2018-11-23 12:13:52,187 INFO L273 TraceCheckUtils]: 42: Hoare triple {1768#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {1768#false} is VALID [2018-11-23 12:13:52,187 INFO L273 TraceCheckUtils]: 43: Hoare triple {1768#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {1768#false} is VALID [2018-11-23 12:13:52,187 INFO L273 TraceCheckUtils]: 44: Hoare triple {1768#false} assume !false; {1768#false} is VALID [2018-11-23 12:13:52,191 INFO L134 CoverageAnalysis]: Checked inductivity of 22 backedges. 10 proven. 1 refuted. 0 times theorem prover too weak. 11 trivial. 0 not checked. [2018-11-23 12:13:52,211 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 1 imperfect interpolant sequences. [2018-11-23 12:13:52,211 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [5] total 5 [2018-11-23 12:13:52,211 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 45 [2018-11-23 12:13:52,212 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:52,212 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 12:13:52,267 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 39 edges. 39 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:52,267 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 12:13:52,267 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 12:13:52,267 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:13:52,268 INFO L87 Difference]: Start difference. First operand 49 states and 63 transitions. Second operand 5 states. [2018-11-23 12:13:52,970 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:52,971 INFO L93 Difference]: Finished difference Result 86 states and 124 transitions. [2018-11-23 12:13:52,971 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 12:13:52,971 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 45 [2018-11-23 12:13:52,972 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:52,972 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:13:52,974 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 74 transitions. [2018-11-23 12:13:52,974 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:13:52,976 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 74 transitions. [2018-11-23 12:13:52,977 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 74 transitions. [2018-11-23 12:13:53,118 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 74 edges. 74 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:53,121 INFO L225 Difference]: With dead ends: 86 [2018-11-23 12:13:53,122 INFO L226 Difference]: Without dead ends: 55 [2018-11-23 12:13:53,123 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 44 GetRequests, 40 SyntacticMatches, 1 SemanticMatches, 3 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:13:53,123 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 55 states. [2018-11-23 12:13:53,170 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 55 to 54. [2018-11-23 12:13:53,171 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:53,171 INFO L82 GeneralOperation]: Start isEquivalent. First operand 55 states. Second operand 54 states. [2018-11-23 12:13:53,171 INFO L74 IsIncluded]: Start isIncluded. First operand 55 states. Second operand 54 states. [2018-11-23 12:13:53,171 INFO L87 Difference]: Start difference. First operand 55 states. Second operand 54 states. [2018-11-23 12:13:53,174 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:53,174 INFO L93 Difference]: Finished difference Result 55 states and 69 transitions. [2018-11-23 12:13:53,175 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 69 transitions. [2018-11-23 12:13:53,175 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:53,175 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:53,176 INFO L74 IsIncluded]: Start isIncluded. First operand 54 states. Second operand 55 states. [2018-11-23 12:13:53,176 INFO L87 Difference]: Start difference. First operand 54 states. Second operand 55 states. [2018-11-23 12:13:53,179 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:53,179 INFO L93 Difference]: Finished difference Result 55 states and 69 transitions. [2018-11-23 12:13:53,179 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 69 transitions. [2018-11-23 12:13:53,180 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:53,180 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:53,180 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:53,181 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:53,181 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 54 states. [2018-11-23 12:13:53,184 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 54 states to 54 states and 68 transitions. [2018-11-23 12:13:53,184 INFO L78 Accepts]: Start accepts. Automaton has 54 states and 68 transitions. Word has length 45 [2018-11-23 12:13:53,184 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:53,185 INFO L480 AbstractCegarLoop]: Abstraction has 54 states and 68 transitions. [2018-11-23 12:13:53,185 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 12:13:53,185 INFO L276 IsEmpty]: Start isEmpty. Operand 54 states and 68 transitions. [2018-11-23 12:13:53,186 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 64 [2018-11-23 12:13:53,186 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:53,186 INFO L402 BasicCegarLoop]: trace histogram [7, 7, 6, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:53,187 INFO L423 AbstractCegarLoop]: === Iteration 7 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:53,187 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:53,187 INFO L82 PathProgramCache]: Analyzing trace with hash 1346922871, now seen corresponding path program 1 times [2018-11-23 12:13:53,187 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:53,187 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:53,188 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:53,188 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:13:53,189 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:53,225 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:53,226 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:53,226 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 7 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 7 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:53,259 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:53,293 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:53,308 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:53,310 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:53,442 INFO L256 TraceCheckUtils]: 0: Hoare triple {2207#true} call ULTIMATE.init(); {2207#true} is VALID [2018-11-23 12:13:53,443 INFO L273 TraceCheckUtils]: 1: Hoare triple {2207#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {2207#true} is VALID [2018-11-23 12:13:53,443 INFO L273 TraceCheckUtils]: 2: Hoare triple {2207#true} assume true; {2207#true} is VALID [2018-11-23 12:13:53,443 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2207#true} {2207#true} #85#return; {2207#true} is VALID [2018-11-23 12:13:53,443 INFO L256 TraceCheckUtils]: 4: Hoare triple {2207#true} call #t~ret13 := main(); {2207#true} is VALID [2018-11-23 12:13:53,443 INFO L273 TraceCheckUtils]: 5: Hoare triple {2207#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {2207#true} is VALID [2018-11-23 12:13:53,446 INFO L273 TraceCheckUtils]: 6: Hoare triple {2207#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,447 INFO L256 TraceCheckUtils]: 7: Hoare triple {2230#(< 1 ~N~0)} call init_nondet(~#x~0.base, ~#x~0.offset); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,447 INFO L273 TraceCheckUtils]: 8: Hoare triple {2230#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,452 INFO L273 TraceCheckUtils]: 9: Hoare triple {2230#(< 1 ~N~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,454 INFO L273 TraceCheckUtils]: 10: Hoare triple {2230#(< 1 ~N~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,456 INFO L273 TraceCheckUtils]: 11: Hoare triple {2230#(< 1 ~N~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,460 INFO L273 TraceCheckUtils]: 12: Hoare triple {2230#(< 1 ~N~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,465 INFO L273 TraceCheckUtils]: 13: Hoare triple {2230#(< 1 ~N~0)} assume !(~i~0 < ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,465 INFO L273 TraceCheckUtils]: 14: Hoare triple {2230#(< 1 ~N~0)} assume true; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,466 INFO L268 TraceCheckUtils]: 15: Hoare quadruple {2230#(< 1 ~N~0)} {2230#(< 1 ~N~0)} #89#return; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,466 INFO L273 TraceCheckUtils]: 16: Hoare triple {2230#(< 1 ~N~0)} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,467 INFO L256 TraceCheckUtils]: 17: Hoare triple {2230#(< 1 ~N~0)} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,467 INFO L273 TraceCheckUtils]: 18: Hoare triple {2230#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,468 INFO L273 TraceCheckUtils]: 19: Hoare triple {2230#(< 1 ~N~0)} assume !!(~i~1 < ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,468 INFO L273 TraceCheckUtils]: 20: Hoare triple {2230#(< 1 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,469 INFO L273 TraceCheckUtils]: 21: Hoare triple {2230#(< 1 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,469 INFO L273 TraceCheckUtils]: 22: Hoare triple {2230#(< 1 ~N~0)} assume !!(~i~1 < ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,470 INFO L273 TraceCheckUtils]: 23: Hoare triple {2230#(< 1 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,471 INFO L273 TraceCheckUtils]: 24: Hoare triple {2230#(< 1 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,471 INFO L273 TraceCheckUtils]: 25: Hoare triple {2230#(< 1 ~N~0)} assume !(~i~1 < ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,472 INFO L273 TraceCheckUtils]: 26: Hoare triple {2230#(< 1 ~N~0)} assume !(0 != ~cnt~0);#res := 0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,472 INFO L273 TraceCheckUtils]: 27: Hoare triple {2230#(< 1 ~N~0)} assume true; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,474 INFO L268 TraceCheckUtils]: 28: Hoare quadruple {2230#(< 1 ~N~0)} {2230#(< 1 ~N~0)} #91#return; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,474 INFO L273 TraceCheckUtils]: 29: Hoare triple {2230#(< 1 ~N~0)} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,475 INFO L256 TraceCheckUtils]: 30: Hoare triple {2230#(< 1 ~N~0)} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,476 INFO L273 TraceCheckUtils]: 31: Hoare triple {2230#(< 1 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,476 INFO L273 TraceCheckUtils]: 32: Hoare triple {2230#(< 1 ~N~0)} assume !!(~i~1 < ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,477 INFO L273 TraceCheckUtils]: 33: Hoare triple {2230#(< 1 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,478 INFO L273 TraceCheckUtils]: 34: Hoare triple {2230#(< 1 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,478 INFO L273 TraceCheckUtils]: 35: Hoare triple {2230#(< 1 ~N~0)} assume !!(~i~1 < ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,479 INFO L273 TraceCheckUtils]: 36: Hoare triple {2230#(< 1 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,479 INFO L273 TraceCheckUtils]: 37: Hoare triple {2230#(< 1 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,480 INFO L273 TraceCheckUtils]: 38: Hoare triple {2230#(< 1 ~N~0)} assume !(~i~1 < ~N~0); {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,481 INFO L273 TraceCheckUtils]: 39: Hoare triple {2230#(< 1 ~N~0)} assume !(0 != ~cnt~0);#res := 0; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,481 INFO L273 TraceCheckUtils]: 40: Hoare triple {2230#(< 1 ~N~0)} assume true; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,483 INFO L268 TraceCheckUtils]: 41: Hoare quadruple {2230#(< 1 ~N~0)} {2230#(< 1 ~N~0)} #93#return; {2230#(< 1 ~N~0)} is VALID [2018-11-23 12:13:53,484 INFO L273 TraceCheckUtils]: 42: Hoare triple {2230#(< 1 ~N~0)} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {2339#(and (<= main_~i~2 0) (< 1 ~N~0))} is VALID [2018-11-23 12:13:53,485 INFO L273 TraceCheckUtils]: 43: Hoare triple {2339#(and (<= main_~i~2 0) (< 1 ~N~0))} assume !(~i~2 < ~N~0 - 1); {2208#false} is VALID [2018-11-23 12:13:53,485 INFO L273 TraceCheckUtils]: 44: Hoare triple {2208#false} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {2208#false} is VALID [2018-11-23 12:13:53,486 INFO L256 TraceCheckUtils]: 45: Hoare triple {2208#false} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {2208#false} is VALID [2018-11-23 12:13:53,486 INFO L273 TraceCheckUtils]: 46: Hoare triple {2208#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {2208#false} is VALID [2018-11-23 12:13:53,486 INFO L273 TraceCheckUtils]: 47: Hoare triple {2208#false} assume !!(~i~1 < ~N~0); {2208#false} is VALID [2018-11-23 12:13:53,487 INFO L273 TraceCheckUtils]: 48: Hoare triple {2208#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2208#false} is VALID [2018-11-23 12:13:53,487 INFO L273 TraceCheckUtils]: 49: Hoare triple {2208#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2208#false} is VALID [2018-11-23 12:13:53,487 INFO L273 TraceCheckUtils]: 50: Hoare triple {2208#false} assume !!(~i~1 < ~N~0); {2208#false} is VALID [2018-11-23 12:13:53,487 INFO L273 TraceCheckUtils]: 51: Hoare triple {2208#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2208#false} is VALID [2018-11-23 12:13:53,488 INFO L273 TraceCheckUtils]: 52: Hoare triple {2208#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2208#false} is VALID [2018-11-23 12:13:53,488 INFO L273 TraceCheckUtils]: 53: Hoare triple {2208#false} assume !!(~i~1 < ~N~0); {2208#false} is VALID [2018-11-23 12:13:53,488 INFO L273 TraceCheckUtils]: 54: Hoare triple {2208#false} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {2208#false} is VALID [2018-11-23 12:13:53,488 INFO L273 TraceCheckUtils]: 55: Hoare triple {2208#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2208#false} is VALID [2018-11-23 12:13:53,488 INFO L273 TraceCheckUtils]: 56: Hoare triple {2208#false} assume !(~i~1 < ~N~0); {2208#false} is VALID [2018-11-23 12:13:53,488 INFO L273 TraceCheckUtils]: 57: Hoare triple {2208#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {2208#false} is VALID [2018-11-23 12:13:53,489 INFO L273 TraceCheckUtils]: 58: Hoare triple {2208#false} assume true; {2208#false} is VALID [2018-11-23 12:13:53,489 INFO L268 TraceCheckUtils]: 59: Hoare quadruple {2208#false} {2208#false} #95#return; {2208#false} is VALID [2018-11-23 12:13:53,489 INFO L273 TraceCheckUtils]: 60: Hoare triple {2208#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {2208#false} is VALID [2018-11-23 12:13:53,489 INFO L273 TraceCheckUtils]: 61: Hoare triple {2208#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {2208#false} is VALID [2018-11-23 12:13:53,489 INFO L273 TraceCheckUtils]: 62: Hoare triple {2208#false} assume !false; {2208#false} is VALID [2018-11-23 12:13:53,492 INFO L134 CoverageAnalysis]: Checked inductivity of 103 backedges. 56 proven. 0 refuted. 0 times theorem prover too weak. 47 trivial. 0 not checked. [2018-11-23 12:13:53,512 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:13:53,512 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [4] imperfect sequences [] total 4 [2018-11-23 12:13:53,512 INFO L78 Accepts]: Start accepts. Automaton has 4 states. Word has length 63 [2018-11-23 12:13:53,513 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:53,513 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 4 states. [2018-11-23 12:13:53,587 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 43 edges. 43 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:53,587 INFO L459 AbstractCegarLoop]: Interpolant automaton has 4 states [2018-11-23 12:13:53,587 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 4 interpolants. [2018-11-23 12:13:53,588 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=6, Invalid=6, Unknown=0, NotChecked=0, Total=12 [2018-11-23 12:13:53,588 INFO L87 Difference]: Start difference. First operand 54 states and 68 transitions. Second operand 4 states. [2018-11-23 12:13:54,086 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:54,087 INFO L93 Difference]: Finished difference Result 84 states and 105 transitions. [2018-11-23 12:13:54,087 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 4 states. [2018-11-23 12:13:54,087 INFO L78 Accepts]: Start accepts. Automaton has 4 states. Word has length 63 [2018-11-23 12:13:54,087 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:54,087 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 4 states. [2018-11-23 12:13:54,089 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 57 transitions. [2018-11-23 12:13:54,089 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 4 states. [2018-11-23 12:13:54,090 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 57 transitions. [2018-11-23 12:13:54,090 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 4 states and 57 transitions. [2018-11-23 12:13:54,160 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 57 edges. 57 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:54,164 INFO L225 Difference]: With dead ends: 84 [2018-11-23 12:13:54,164 INFO L226 Difference]: Without dead ends: 58 [2018-11-23 12:13:54,165 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 62 GetRequests, 60 SyntacticMatches, 0 SemanticMatches, 2 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=6, Invalid=6, Unknown=0, NotChecked=0, Total=12 [2018-11-23 12:13:54,165 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 58 states. [2018-11-23 12:13:54,225 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 58 to 56. [2018-11-23 12:13:54,226 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:54,226 INFO L82 GeneralOperation]: Start isEquivalent. First operand 58 states. Second operand 56 states. [2018-11-23 12:13:54,226 INFO L74 IsIncluded]: Start isIncluded. First operand 58 states. Second operand 56 states. [2018-11-23 12:13:54,226 INFO L87 Difference]: Start difference. First operand 58 states. Second operand 56 states. [2018-11-23 12:13:54,228 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:54,229 INFO L93 Difference]: Finished difference Result 58 states and 72 transitions. [2018-11-23 12:13:54,229 INFO L276 IsEmpty]: Start isEmpty. Operand 58 states and 72 transitions. [2018-11-23 12:13:54,229 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:54,229 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:54,230 INFO L74 IsIncluded]: Start isIncluded. First operand 56 states. Second operand 58 states. [2018-11-23 12:13:54,230 INFO L87 Difference]: Start difference. First operand 56 states. Second operand 58 states. [2018-11-23 12:13:54,233 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:54,233 INFO L93 Difference]: Finished difference Result 58 states and 72 transitions. [2018-11-23 12:13:54,233 INFO L276 IsEmpty]: Start isEmpty. Operand 58 states and 72 transitions. [2018-11-23 12:13:54,234 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:54,234 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:54,234 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:54,234 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:54,234 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 56 states. [2018-11-23 12:13:54,237 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 56 states to 56 states and 70 transitions. [2018-11-23 12:13:54,237 INFO L78 Accepts]: Start accepts. Automaton has 56 states and 70 transitions. Word has length 63 [2018-11-23 12:13:54,238 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:54,238 INFO L480 AbstractCegarLoop]: Abstraction has 56 states and 70 transitions. [2018-11-23 12:13:54,238 INFO L481 AbstractCegarLoop]: Interpolant automaton has 4 states. [2018-11-23 12:13:54,238 INFO L276 IsEmpty]: Start isEmpty. Operand 56 states and 70 transitions. [2018-11-23 12:13:54,239 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 66 [2018-11-23 12:13:54,239 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:54,239 INFO L402 BasicCegarLoop]: trace histogram [7, 7, 6, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:54,240 INFO L423 AbstractCegarLoop]: === Iteration 8 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:54,240 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:54,240 INFO L82 PathProgramCache]: Analyzing trace with hash 1679269433, now seen corresponding path program 1 times [2018-11-23 12:13:54,240 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:54,240 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:54,241 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:54,242 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:54,242 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:54,265 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:54,266 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:54,266 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 8 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 8 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:54,293 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:54,328 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:54,358 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:54,360 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:54,782 INFO L256 TraceCheckUtils]: 0: Hoare triple {2708#true} call ULTIMATE.init(); {2708#true} is VALID [2018-11-23 12:13:54,783 INFO L273 TraceCheckUtils]: 1: Hoare triple {2708#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {2708#true} is VALID [2018-11-23 12:13:54,783 INFO L273 TraceCheckUtils]: 2: Hoare triple {2708#true} assume true; {2708#true} is VALID [2018-11-23 12:13:54,783 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2708#true} {2708#true} #85#return; {2708#true} is VALID [2018-11-23 12:13:54,784 INFO L256 TraceCheckUtils]: 4: Hoare triple {2708#true} call #t~ret13 := main(); {2708#true} is VALID [2018-11-23 12:13:54,784 INFO L273 TraceCheckUtils]: 5: Hoare triple {2708#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {2708#true} is VALID [2018-11-23 12:13:54,784 INFO L273 TraceCheckUtils]: 6: Hoare triple {2708#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {2708#true} is VALID [2018-11-23 12:13:54,784 INFO L256 TraceCheckUtils]: 7: Hoare triple {2708#true} call init_nondet(~#x~0.base, ~#x~0.offset); {2708#true} is VALID [2018-11-23 12:13:54,786 INFO L273 TraceCheckUtils]: 8: Hoare triple {2708#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {2737#(<= init_nondet_~i~0 0)} is VALID [2018-11-23 12:13:54,787 INFO L273 TraceCheckUtils]: 9: Hoare triple {2737#(<= init_nondet_~i~0 0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {2737#(<= init_nondet_~i~0 0)} is VALID [2018-11-23 12:13:54,787 INFO L273 TraceCheckUtils]: 10: Hoare triple {2737#(<= init_nondet_~i~0 0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {2744#(<= init_nondet_~i~0 1)} is VALID [2018-11-23 12:13:54,788 INFO L273 TraceCheckUtils]: 11: Hoare triple {2744#(<= init_nondet_~i~0 1)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {2744#(<= init_nondet_~i~0 1)} is VALID [2018-11-23 12:13:54,798 INFO L273 TraceCheckUtils]: 12: Hoare triple {2744#(<= init_nondet_~i~0 1)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {2751#(<= init_nondet_~i~0 2)} is VALID [2018-11-23 12:13:54,799 INFO L273 TraceCheckUtils]: 13: Hoare triple {2751#(<= init_nondet_~i~0 2)} assume !(~i~0 < ~N~0); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,800 INFO L273 TraceCheckUtils]: 14: Hoare triple {2755#(<= ~N~0 2)} assume true; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,801 INFO L268 TraceCheckUtils]: 15: Hoare quadruple {2755#(<= ~N~0 2)} {2708#true} #89#return; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,801 INFO L273 TraceCheckUtils]: 16: Hoare triple {2755#(<= ~N~0 2)} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,801 INFO L256 TraceCheckUtils]: 17: Hoare triple {2755#(<= ~N~0 2)} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,802 INFO L273 TraceCheckUtils]: 18: Hoare triple {2755#(<= ~N~0 2)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,802 INFO L273 TraceCheckUtils]: 19: Hoare triple {2755#(<= ~N~0 2)} assume !!(~i~1 < ~N~0); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,803 INFO L273 TraceCheckUtils]: 20: Hoare triple {2755#(<= ~N~0 2)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,803 INFO L273 TraceCheckUtils]: 21: Hoare triple {2755#(<= ~N~0 2)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,803 INFO L273 TraceCheckUtils]: 22: Hoare triple {2755#(<= ~N~0 2)} assume !!(~i~1 < ~N~0); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,804 INFO L273 TraceCheckUtils]: 23: Hoare triple {2755#(<= ~N~0 2)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,804 INFO L273 TraceCheckUtils]: 24: Hoare triple {2755#(<= ~N~0 2)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,805 INFO L273 TraceCheckUtils]: 25: Hoare triple {2755#(<= ~N~0 2)} assume !(~i~1 < ~N~0); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,806 INFO L273 TraceCheckUtils]: 26: Hoare triple {2755#(<= ~N~0 2)} assume !(0 != ~cnt~0);#res := 0; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,806 INFO L273 TraceCheckUtils]: 27: Hoare triple {2755#(<= ~N~0 2)} assume true; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,807 INFO L268 TraceCheckUtils]: 28: Hoare quadruple {2755#(<= ~N~0 2)} {2755#(<= ~N~0 2)} #91#return; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,808 INFO L273 TraceCheckUtils]: 29: Hoare triple {2755#(<= ~N~0 2)} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,809 INFO L256 TraceCheckUtils]: 30: Hoare triple {2755#(<= ~N~0 2)} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,810 INFO L273 TraceCheckUtils]: 31: Hoare triple {2755#(<= ~N~0 2)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,810 INFO L273 TraceCheckUtils]: 32: Hoare triple {2755#(<= ~N~0 2)} assume !!(~i~1 < ~N~0); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,811 INFO L273 TraceCheckUtils]: 33: Hoare triple {2755#(<= ~N~0 2)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,811 INFO L273 TraceCheckUtils]: 34: Hoare triple {2755#(<= ~N~0 2)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,814 INFO L273 TraceCheckUtils]: 35: Hoare triple {2755#(<= ~N~0 2)} assume !!(~i~1 < ~N~0); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,815 INFO L273 TraceCheckUtils]: 36: Hoare triple {2755#(<= ~N~0 2)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,815 INFO L273 TraceCheckUtils]: 37: Hoare triple {2755#(<= ~N~0 2)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,816 INFO L273 TraceCheckUtils]: 38: Hoare triple {2755#(<= ~N~0 2)} assume !(~i~1 < ~N~0); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,816 INFO L273 TraceCheckUtils]: 39: Hoare triple {2755#(<= ~N~0 2)} assume !(0 != ~cnt~0);#res := 0; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,817 INFO L273 TraceCheckUtils]: 40: Hoare triple {2755#(<= ~N~0 2)} assume true; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,824 INFO L268 TraceCheckUtils]: 41: Hoare quadruple {2755#(<= ~N~0 2)} {2755#(<= ~N~0 2)} #93#return; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,825 INFO L273 TraceCheckUtils]: 42: Hoare triple {2755#(<= ~N~0 2)} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,825 INFO L273 TraceCheckUtils]: 43: Hoare triple {2755#(<= ~N~0 2)} assume !!(~i~2 < ~N~0 - 1);call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4);call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4);havoc #t~mem11; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,825 INFO L273 TraceCheckUtils]: 44: Hoare triple {2755#(<= ~N~0 2)} #t~post10 := ~i~2;~i~2 := 1 + #t~post10;havoc #t~post10; {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,826 INFO L273 TraceCheckUtils]: 45: Hoare triple {2755#(<= ~N~0 2)} assume !(~i~2 < ~N~0 - 1); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,826 INFO L273 TraceCheckUtils]: 46: Hoare triple {2755#(<= ~N~0 2)} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,827 INFO L256 TraceCheckUtils]: 47: Hoare triple {2755#(<= ~N~0 2)} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {2755#(<= ~N~0 2)} is VALID [2018-11-23 12:13:54,827 INFO L273 TraceCheckUtils]: 48: Hoare triple {2755#(<= ~N~0 2)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {2861#(and (<= ~N~0 2) (<= 0 rangesum_~i~1))} is VALID [2018-11-23 12:13:54,828 INFO L273 TraceCheckUtils]: 49: Hoare triple {2861#(and (<= ~N~0 2) (<= 0 rangesum_~i~1))} assume !!(~i~1 < ~N~0); {2861#(and (<= ~N~0 2) (<= 0 rangesum_~i~1))} is VALID [2018-11-23 12:13:54,829 INFO L273 TraceCheckUtils]: 50: Hoare triple {2861#(and (<= ~N~0 2) (<= 0 rangesum_~i~1))} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2861#(and (<= ~N~0 2) (<= 0 rangesum_~i~1))} is VALID [2018-11-23 12:13:54,830 INFO L273 TraceCheckUtils]: 51: Hoare triple {2861#(and (<= ~N~0 2) (<= 0 rangesum_~i~1))} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2871#(and (<= 1 rangesum_~i~1) (<= ~N~0 2))} is VALID [2018-11-23 12:13:54,831 INFO L273 TraceCheckUtils]: 52: Hoare triple {2871#(and (<= 1 rangesum_~i~1) (<= ~N~0 2))} assume !!(~i~1 < ~N~0); {2871#(and (<= 1 rangesum_~i~1) (<= ~N~0 2))} is VALID [2018-11-23 12:13:54,832 INFO L273 TraceCheckUtils]: 53: Hoare triple {2871#(and (<= 1 rangesum_~i~1) (<= ~N~0 2))} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {2871#(and (<= 1 rangesum_~i~1) (<= ~N~0 2))} is VALID [2018-11-23 12:13:54,833 INFO L273 TraceCheckUtils]: 54: Hoare triple {2871#(and (<= 1 rangesum_~i~1) (<= ~N~0 2))} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2881#(and (<= ~N~0 2) (<= 2 rangesum_~i~1))} is VALID [2018-11-23 12:13:54,833 INFO L273 TraceCheckUtils]: 55: Hoare triple {2881#(and (<= ~N~0 2) (<= 2 rangesum_~i~1))} assume !!(~i~1 < ~N~0); {2709#false} is VALID [2018-11-23 12:13:54,834 INFO L273 TraceCheckUtils]: 56: Hoare triple {2709#false} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {2709#false} is VALID [2018-11-23 12:13:54,834 INFO L273 TraceCheckUtils]: 57: Hoare triple {2709#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {2709#false} is VALID [2018-11-23 12:13:54,834 INFO L273 TraceCheckUtils]: 58: Hoare triple {2709#false} assume !(~i~1 < ~N~0); {2709#false} is VALID [2018-11-23 12:13:54,834 INFO L273 TraceCheckUtils]: 59: Hoare triple {2709#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {2709#false} is VALID [2018-11-23 12:13:54,835 INFO L273 TraceCheckUtils]: 60: Hoare triple {2709#false} assume true; {2709#false} is VALID [2018-11-23 12:13:54,835 INFO L268 TraceCheckUtils]: 61: Hoare quadruple {2709#false} {2755#(<= ~N~0 2)} #95#return; {2709#false} is VALID [2018-11-23 12:13:54,835 INFO L273 TraceCheckUtils]: 62: Hoare triple {2709#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {2709#false} is VALID [2018-11-23 12:13:54,835 INFO L273 TraceCheckUtils]: 63: Hoare triple {2709#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {2709#false} is VALID [2018-11-23 12:13:54,836 INFO L273 TraceCheckUtils]: 64: Hoare triple {2709#false} assume !false; {2709#false} is VALID [2018-11-23 12:13:54,839 INFO L134 CoverageAnalysis]: Checked inductivity of 104 backedges. 66 proven. 4 refuted. 0 times theorem prover too weak. 34 trivial. 0 not checked. [2018-11-23 12:13:54,860 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 1 imperfect interpolant sequences. [2018-11-23 12:13:54,860 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [9] total 9 [2018-11-23 12:13:54,861 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 65 [2018-11-23 12:13:54,861 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:54,861 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states. [2018-11-23 12:13:54,914 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 52 edges. 52 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:54,915 INFO L459 AbstractCegarLoop]: Interpolant automaton has 9 states [2018-11-23 12:13:54,915 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 9 interpolants. [2018-11-23 12:13:54,915 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=24, Invalid=48, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:13:54,916 INFO L87 Difference]: Start difference. First operand 56 states and 70 transitions. Second operand 9 states. [2018-11-23 12:13:55,641 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:55,641 INFO L93 Difference]: Finished difference Result 120 states and 154 transitions. [2018-11-23 12:13:55,641 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 10 states. [2018-11-23 12:13:55,642 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 65 [2018-11-23 12:13:55,642 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:55,642 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:13:55,644 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 10 states to 10 states and 96 transitions. [2018-11-23 12:13:55,645 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:13:55,647 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 10 states to 10 states and 96 transitions. [2018-11-23 12:13:55,647 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 10 states and 96 transitions. [2018-11-23 12:13:55,764 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 96 edges. 96 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:55,766 INFO L225 Difference]: With dead ends: 120 [2018-11-23 12:13:55,767 INFO L226 Difference]: Without dead ends: 59 [2018-11-23 12:13:55,768 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 65 GetRequests, 56 SyntacticMatches, 1 SemanticMatches, 8 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 10 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=28, Invalid=62, Unknown=0, NotChecked=0, Total=90 [2018-11-23 12:13:55,768 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 59 states. [2018-11-23 12:13:55,809 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 59 to 58. [2018-11-23 12:13:55,809 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:55,810 INFO L82 GeneralOperation]: Start isEquivalent. First operand 59 states. Second operand 58 states. [2018-11-23 12:13:55,810 INFO L74 IsIncluded]: Start isIncluded. First operand 59 states. Second operand 58 states. [2018-11-23 12:13:55,810 INFO L87 Difference]: Start difference. First operand 59 states. Second operand 58 states. [2018-11-23 12:13:55,814 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:55,814 INFO L93 Difference]: Finished difference Result 59 states and 73 transitions. [2018-11-23 12:13:55,814 INFO L276 IsEmpty]: Start isEmpty. Operand 59 states and 73 transitions. [2018-11-23 12:13:55,815 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:55,815 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:55,815 INFO L74 IsIncluded]: Start isIncluded. First operand 58 states. Second operand 59 states. [2018-11-23 12:13:55,815 INFO L87 Difference]: Start difference. First operand 58 states. Second operand 59 states. [2018-11-23 12:13:55,818 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:55,818 INFO L93 Difference]: Finished difference Result 59 states and 73 transitions. [2018-11-23 12:13:55,818 INFO L276 IsEmpty]: Start isEmpty. Operand 59 states and 73 transitions. [2018-11-23 12:13:55,819 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:55,819 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:55,819 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:55,819 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:55,819 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 58 states. [2018-11-23 12:13:55,822 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 58 states to 58 states and 72 transitions. [2018-11-23 12:13:55,822 INFO L78 Accepts]: Start accepts. Automaton has 58 states and 72 transitions. Word has length 65 [2018-11-23 12:13:55,822 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:55,822 INFO L480 AbstractCegarLoop]: Abstraction has 58 states and 72 transitions. [2018-11-23 12:13:55,823 INFO L481 AbstractCegarLoop]: Interpolant automaton has 9 states. [2018-11-23 12:13:55,823 INFO L276 IsEmpty]: Start isEmpty. Operand 58 states and 72 transitions. [2018-11-23 12:13:55,823 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 68 [2018-11-23 12:13:55,823 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:55,824 INFO L402 BasicCegarLoop]: trace histogram [7, 7, 6, 3, 3, 3, 3, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:55,824 INFO L423 AbstractCegarLoop]: === Iteration 9 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:55,824 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:55,824 INFO L82 PathProgramCache]: Analyzing trace with hash -2040052581, now seen corresponding path program 2 times [2018-11-23 12:13:55,824 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:55,824 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:55,825 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:55,825 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:55,825 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:55,847 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:55,847 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:55,847 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 9 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 9 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:55,867 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:13:55,903 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:13:55,903 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:13:55,934 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:55,936 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:56,156 INFO L256 TraceCheckUtils]: 0: Hoare triple {3279#true} call ULTIMATE.init(); {3279#true} is VALID [2018-11-23 12:13:56,157 INFO L273 TraceCheckUtils]: 1: Hoare triple {3279#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {3279#true} is VALID [2018-11-23 12:13:56,157 INFO L273 TraceCheckUtils]: 2: Hoare triple {3279#true} assume true; {3279#true} is VALID [2018-11-23 12:13:56,158 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3279#true} {3279#true} #85#return; {3279#true} is VALID [2018-11-23 12:13:56,158 INFO L256 TraceCheckUtils]: 4: Hoare triple {3279#true} call #t~ret13 := main(); {3279#true} is VALID [2018-11-23 12:13:56,158 INFO L273 TraceCheckUtils]: 5: Hoare triple {3279#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {3279#true} is VALID [2018-11-23 12:13:56,158 INFO L273 TraceCheckUtils]: 6: Hoare triple {3279#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {3279#true} is VALID [2018-11-23 12:13:56,159 INFO L256 TraceCheckUtils]: 7: Hoare triple {3279#true} call init_nondet(~#x~0.base, ~#x~0.offset); {3279#true} is VALID [2018-11-23 12:13:56,174 INFO L273 TraceCheckUtils]: 8: Hoare triple {3279#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {3308#(<= 0 init_nondet_~i~0)} is VALID [2018-11-23 12:13:56,174 INFO L273 TraceCheckUtils]: 9: Hoare triple {3308#(<= 0 init_nondet_~i~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {3308#(<= 0 init_nondet_~i~0)} is VALID [2018-11-23 12:13:56,179 INFO L273 TraceCheckUtils]: 10: Hoare triple {3308#(<= 0 init_nondet_~i~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {3315#(<= 1 init_nondet_~i~0)} is VALID [2018-11-23 12:13:56,180 INFO L273 TraceCheckUtils]: 11: Hoare triple {3315#(<= 1 init_nondet_~i~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {3315#(<= 1 init_nondet_~i~0)} is VALID [2018-11-23 12:13:56,181 INFO L273 TraceCheckUtils]: 12: Hoare triple {3315#(<= 1 init_nondet_~i~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {3322#(<= 2 init_nondet_~i~0)} is VALID [2018-11-23 12:13:56,189 INFO L273 TraceCheckUtils]: 13: Hoare triple {3322#(<= 2 init_nondet_~i~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {3326#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:56,190 INFO L273 TraceCheckUtils]: 14: Hoare triple {3326#(<= 3 ~N~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {3326#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:56,190 INFO L273 TraceCheckUtils]: 15: Hoare triple {3326#(<= 3 ~N~0)} assume !(~i~0 < ~N~0); {3326#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:56,191 INFO L273 TraceCheckUtils]: 16: Hoare triple {3326#(<= 3 ~N~0)} assume true; {3326#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:56,191 INFO L268 TraceCheckUtils]: 17: Hoare quadruple {3326#(<= 3 ~N~0)} {3279#true} #89#return; {3326#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:56,191 INFO L273 TraceCheckUtils]: 18: Hoare triple {3326#(<= 3 ~N~0)} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {3326#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:56,192 INFO L256 TraceCheckUtils]: 19: Hoare triple {3326#(<= 3 ~N~0)} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {3326#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:56,193 INFO L273 TraceCheckUtils]: 20: Hoare triple {3326#(<= 3 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {3348#(and (<= 3 ~N~0) (<= rangesum_~i~1 0))} is VALID [2018-11-23 12:13:56,193 INFO L273 TraceCheckUtils]: 21: Hoare triple {3348#(and (<= 3 ~N~0) (<= rangesum_~i~1 0))} assume !!(~i~1 < ~N~0); {3348#(and (<= 3 ~N~0) (<= rangesum_~i~1 0))} is VALID [2018-11-23 12:13:56,194 INFO L273 TraceCheckUtils]: 22: Hoare triple {3348#(and (<= 3 ~N~0) (<= rangesum_~i~1 0))} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3348#(and (<= 3 ~N~0) (<= rangesum_~i~1 0))} is VALID [2018-11-23 12:13:56,195 INFO L273 TraceCheckUtils]: 23: Hoare triple {3348#(and (<= 3 ~N~0) (<= rangesum_~i~1 0))} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3358#(and (<= 3 ~N~0) (<= rangesum_~i~1 1))} is VALID [2018-11-23 12:13:56,196 INFO L273 TraceCheckUtils]: 24: Hoare triple {3358#(and (<= 3 ~N~0) (<= rangesum_~i~1 1))} assume !!(~i~1 < ~N~0); {3358#(and (<= 3 ~N~0) (<= rangesum_~i~1 1))} is VALID [2018-11-23 12:13:56,196 INFO L273 TraceCheckUtils]: 25: Hoare triple {3358#(and (<= 3 ~N~0) (<= rangesum_~i~1 1))} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3358#(and (<= 3 ~N~0) (<= rangesum_~i~1 1))} is VALID [2018-11-23 12:13:56,197 INFO L273 TraceCheckUtils]: 26: Hoare triple {3358#(and (<= 3 ~N~0) (<= rangesum_~i~1 1))} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3368#(and (<= rangesum_~i~1 2) (<= 3 ~N~0))} is VALID [2018-11-23 12:13:56,198 INFO L273 TraceCheckUtils]: 27: Hoare triple {3368#(and (<= rangesum_~i~1 2) (<= 3 ~N~0))} assume !(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,198 INFO L273 TraceCheckUtils]: 28: Hoare triple {3280#false} assume !(0 != ~cnt~0);#res := 0; {3280#false} is VALID [2018-11-23 12:13:56,199 INFO L273 TraceCheckUtils]: 29: Hoare triple {3280#false} assume true; {3280#false} is VALID [2018-11-23 12:13:56,199 INFO L268 TraceCheckUtils]: 30: Hoare quadruple {3280#false} {3326#(<= 3 ~N~0)} #91#return; {3280#false} is VALID [2018-11-23 12:13:56,199 INFO L273 TraceCheckUtils]: 31: Hoare triple {3280#false} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {3280#false} is VALID [2018-11-23 12:13:56,199 INFO L256 TraceCheckUtils]: 32: Hoare triple {3280#false} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {3280#false} is VALID [2018-11-23 12:13:56,200 INFO L273 TraceCheckUtils]: 33: Hoare triple {3280#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {3280#false} is VALID [2018-11-23 12:13:56,200 INFO L273 TraceCheckUtils]: 34: Hoare triple {3280#false} assume !!(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,200 INFO L273 TraceCheckUtils]: 35: Hoare triple {3280#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3280#false} is VALID [2018-11-23 12:13:56,200 INFO L273 TraceCheckUtils]: 36: Hoare triple {3280#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3280#false} is VALID [2018-11-23 12:13:56,201 INFO L273 TraceCheckUtils]: 37: Hoare triple {3280#false} assume !!(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,201 INFO L273 TraceCheckUtils]: 38: Hoare triple {3280#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3280#false} is VALID [2018-11-23 12:13:56,201 INFO L273 TraceCheckUtils]: 39: Hoare triple {3280#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3280#false} is VALID [2018-11-23 12:13:56,202 INFO L273 TraceCheckUtils]: 40: Hoare triple {3280#false} assume !(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,202 INFO L273 TraceCheckUtils]: 41: Hoare triple {3280#false} assume !(0 != ~cnt~0);#res := 0; {3280#false} is VALID [2018-11-23 12:13:56,202 INFO L273 TraceCheckUtils]: 42: Hoare triple {3280#false} assume true; {3280#false} is VALID [2018-11-23 12:13:56,202 INFO L268 TraceCheckUtils]: 43: Hoare quadruple {3280#false} {3280#false} #93#return; {3280#false} is VALID [2018-11-23 12:13:56,203 INFO L273 TraceCheckUtils]: 44: Hoare triple {3280#false} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {3280#false} is VALID [2018-11-23 12:13:56,203 INFO L273 TraceCheckUtils]: 45: Hoare triple {3280#false} assume !!(~i~2 < ~N~0 - 1);call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4);call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4);havoc #t~mem11; {3280#false} is VALID [2018-11-23 12:13:56,203 INFO L273 TraceCheckUtils]: 46: Hoare triple {3280#false} #t~post10 := ~i~2;~i~2 := 1 + #t~post10;havoc #t~post10; {3280#false} is VALID [2018-11-23 12:13:56,203 INFO L273 TraceCheckUtils]: 47: Hoare triple {3280#false} assume !(~i~2 < ~N~0 - 1); {3280#false} is VALID [2018-11-23 12:13:56,203 INFO L273 TraceCheckUtils]: 48: Hoare triple {3280#false} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {3280#false} is VALID [2018-11-23 12:13:56,203 INFO L256 TraceCheckUtils]: 49: Hoare triple {3280#false} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {3280#false} is VALID [2018-11-23 12:13:56,204 INFO L273 TraceCheckUtils]: 50: Hoare triple {3280#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {3280#false} is VALID [2018-11-23 12:13:56,204 INFO L273 TraceCheckUtils]: 51: Hoare triple {3280#false} assume !!(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,204 INFO L273 TraceCheckUtils]: 52: Hoare triple {3280#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3280#false} is VALID [2018-11-23 12:13:56,204 INFO L273 TraceCheckUtils]: 53: Hoare triple {3280#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3280#false} is VALID [2018-11-23 12:13:56,204 INFO L273 TraceCheckUtils]: 54: Hoare triple {3280#false} assume !!(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,205 INFO L273 TraceCheckUtils]: 55: Hoare triple {3280#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3280#false} is VALID [2018-11-23 12:13:56,205 INFO L273 TraceCheckUtils]: 56: Hoare triple {3280#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3280#false} is VALID [2018-11-23 12:13:56,205 INFO L273 TraceCheckUtils]: 57: Hoare triple {3280#false} assume !!(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,205 INFO L273 TraceCheckUtils]: 58: Hoare triple {3280#false} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {3280#false} is VALID [2018-11-23 12:13:56,205 INFO L273 TraceCheckUtils]: 59: Hoare triple {3280#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3280#false} is VALID [2018-11-23 12:13:56,206 INFO L273 TraceCheckUtils]: 60: Hoare triple {3280#false} assume !(~i~1 < ~N~0); {3280#false} is VALID [2018-11-23 12:13:56,206 INFO L273 TraceCheckUtils]: 61: Hoare triple {3280#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {3280#false} is VALID [2018-11-23 12:13:56,206 INFO L273 TraceCheckUtils]: 62: Hoare triple {3280#false} assume true; {3280#false} is VALID [2018-11-23 12:13:56,206 INFO L268 TraceCheckUtils]: 63: Hoare quadruple {3280#false} {3280#false} #95#return; {3280#false} is VALID [2018-11-23 12:13:56,206 INFO L273 TraceCheckUtils]: 64: Hoare triple {3280#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {3280#false} is VALID [2018-11-23 12:13:56,206 INFO L273 TraceCheckUtils]: 65: Hoare triple {3280#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {3280#false} is VALID [2018-11-23 12:13:56,207 INFO L273 TraceCheckUtils]: 66: Hoare triple {3280#false} assume !false; {3280#false} is VALID [2018-11-23 12:13:56,210 INFO L134 CoverageAnalysis]: Checked inductivity of 109 backedges. 47 proven. 10 refuted. 0 times theorem prover too weak. 52 trivial. 0 not checked. [2018-11-23 12:13:56,231 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 1 imperfect interpolant sequences. [2018-11-23 12:13:56,231 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [9] total 9 [2018-11-23 12:13:56,231 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 67 [2018-11-23 12:13:56,232 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:56,232 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states. [2018-11-23 12:13:56,292 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 51 edges. 51 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:56,292 INFO L459 AbstractCegarLoop]: Interpolant automaton has 9 states [2018-11-23 12:13:56,292 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 9 interpolants. [2018-11-23 12:13:56,292 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=24, Invalid=48, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:13:56,292 INFO L87 Difference]: Start difference. First operand 58 states and 72 transitions. Second operand 9 states. [2018-11-23 12:13:56,921 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:56,922 INFO L93 Difference]: Finished difference Result 99 states and 128 transitions. [2018-11-23 12:13:56,922 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 10 states. [2018-11-23 12:13:56,922 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 67 [2018-11-23 12:13:56,922 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:56,922 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:13:56,924 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 10 states to 10 states and 80 transitions. [2018-11-23 12:13:56,924 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:13:56,926 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 10 states to 10 states and 80 transitions. [2018-11-23 12:13:56,926 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 10 states and 80 transitions. [2018-11-23 12:13:57,018 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 80 edges. 80 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:57,021 INFO L225 Difference]: With dead ends: 99 [2018-11-23 12:13:57,021 INFO L226 Difference]: Without dead ends: 63 [2018-11-23 12:13:57,022 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 67 GetRequests, 58 SyntacticMatches, 1 SemanticMatches, 8 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 8 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=30, Invalid=60, Unknown=0, NotChecked=0, Total=90 [2018-11-23 12:13:57,022 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 63 states. [2018-11-23 12:13:57,095 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 63 to 60. [2018-11-23 12:13:57,096 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:57,096 INFO L82 GeneralOperation]: Start isEquivalent. First operand 63 states. Second operand 60 states. [2018-11-23 12:13:57,096 INFO L74 IsIncluded]: Start isIncluded. First operand 63 states. Second operand 60 states. [2018-11-23 12:13:57,096 INFO L87 Difference]: Start difference. First operand 63 states. Second operand 60 states. [2018-11-23 12:13:57,100 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:57,100 INFO L93 Difference]: Finished difference Result 63 states and 78 transitions. [2018-11-23 12:13:57,100 INFO L276 IsEmpty]: Start isEmpty. Operand 63 states and 78 transitions. [2018-11-23 12:13:57,101 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:57,101 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:57,101 INFO L74 IsIncluded]: Start isIncluded. First operand 60 states. Second operand 63 states. [2018-11-23 12:13:57,101 INFO L87 Difference]: Start difference. First operand 60 states. Second operand 63 states. [2018-11-23 12:13:57,104 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:57,105 INFO L93 Difference]: Finished difference Result 63 states and 78 transitions. [2018-11-23 12:13:57,105 INFO L276 IsEmpty]: Start isEmpty. Operand 63 states and 78 transitions. [2018-11-23 12:13:57,105 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:57,105 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:57,106 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:57,106 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:57,106 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 60 states. [2018-11-23 12:13:57,108 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 60 states to 60 states and 74 transitions. [2018-11-23 12:13:57,109 INFO L78 Accepts]: Start accepts. Automaton has 60 states and 74 transitions. Word has length 67 [2018-11-23 12:13:57,109 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:57,109 INFO L480 AbstractCegarLoop]: Abstraction has 60 states and 74 transitions. [2018-11-23 12:13:57,109 INFO L481 AbstractCegarLoop]: Interpolant automaton has 9 states. [2018-11-23 12:13:57,109 INFO L276 IsEmpty]: Start isEmpty. Operand 60 states and 74 transitions. [2018-11-23 12:13:57,110 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 74 [2018-11-23 12:13:57,110 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:57,111 INFO L402 BasicCegarLoop]: trace histogram [9, 9, 6, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:57,111 INFO L423 AbstractCegarLoop]: === Iteration 10 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:57,111 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:57,111 INFO L82 PathProgramCache]: Analyzing trace with hash -737365673, now seen corresponding path program 1 times [2018-11-23 12:13:57,111 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:57,112 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:57,112 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:57,112 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:13:57,113 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:57,125 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:57,125 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:57,126 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 10 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 10 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:57,157 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:57,193 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:57,223 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:57,225 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:57,593 INFO L256 TraceCheckUtils]: 0: Hoare triple {3837#true} call ULTIMATE.init(); {3837#true} is VALID [2018-11-23 12:13:57,593 INFO L273 TraceCheckUtils]: 1: Hoare triple {3837#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; {3837#true} is VALID [2018-11-23 12:13:57,594 INFO L273 TraceCheckUtils]: 2: Hoare triple {3837#true} assume true; {3837#true} is VALID [2018-11-23 12:13:57,594 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3837#true} {3837#true} #85#return; {3837#true} is VALID [2018-11-23 12:13:57,594 INFO L256 TraceCheckUtils]: 4: Hoare triple {3837#true} call #t~ret13 := main(); {3837#true} is VALID [2018-11-23 12:13:57,594 INFO L273 TraceCheckUtils]: 5: Hoare triple {3837#true} assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; {3837#true} is VALID [2018-11-23 12:13:57,595 INFO L273 TraceCheckUtils]: 6: Hoare triple {3837#true} assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); {3837#true} is VALID [2018-11-23 12:13:57,595 INFO L256 TraceCheckUtils]: 7: Hoare triple {3837#true} call init_nondet(~#x~0.base, ~#x~0.offset); {3837#true} is VALID [2018-11-23 12:13:57,596 INFO L273 TraceCheckUtils]: 8: Hoare triple {3837#true} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; {3866#(<= 0 init_nondet_~i~0)} is VALID [2018-11-23 12:13:57,596 INFO L273 TraceCheckUtils]: 9: Hoare triple {3866#(<= 0 init_nondet_~i~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {3866#(<= 0 init_nondet_~i~0)} is VALID [2018-11-23 12:13:57,597 INFO L273 TraceCheckUtils]: 10: Hoare triple {3866#(<= 0 init_nondet_~i~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {3873#(<= 1 init_nondet_~i~0)} is VALID [2018-11-23 12:13:57,597 INFO L273 TraceCheckUtils]: 11: Hoare triple {3873#(<= 1 init_nondet_~i~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {3873#(<= 1 init_nondet_~i~0)} is VALID [2018-11-23 12:13:57,598 INFO L273 TraceCheckUtils]: 12: Hoare triple {3873#(<= 1 init_nondet_~i~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {3880#(<= 2 init_nondet_~i~0)} is VALID [2018-11-23 12:13:57,599 INFO L273 TraceCheckUtils]: 13: Hoare triple {3880#(<= 2 init_nondet_~i~0)} assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,599 INFO L273 TraceCheckUtils]: 14: Hoare triple {3884#(<= 3 ~N~0)} #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,605 INFO L273 TraceCheckUtils]: 15: Hoare triple {3884#(<= 3 ~N~0)} assume !(~i~0 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,606 INFO L273 TraceCheckUtils]: 16: Hoare triple {3884#(<= 3 ~N~0)} assume true; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,606 INFO L268 TraceCheckUtils]: 17: Hoare quadruple {3884#(<= 3 ~N~0)} {3837#true} #89#return; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,607 INFO L273 TraceCheckUtils]: 18: Hoare triple {3884#(<= 3 ~N~0)} havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,608 INFO L256 TraceCheckUtils]: 19: Hoare triple {3884#(<= 3 ~N~0)} call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,608 INFO L273 TraceCheckUtils]: 20: Hoare triple {3884#(<= 3 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,609 INFO L273 TraceCheckUtils]: 21: Hoare triple {3884#(<= 3 ~N~0)} assume !!(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,609 INFO L273 TraceCheckUtils]: 22: Hoare triple {3884#(<= 3 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,610 INFO L273 TraceCheckUtils]: 23: Hoare triple {3884#(<= 3 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,610 INFO L273 TraceCheckUtils]: 24: Hoare triple {3884#(<= 3 ~N~0)} assume !!(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,611 INFO L273 TraceCheckUtils]: 25: Hoare triple {3884#(<= 3 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,612 INFO L273 TraceCheckUtils]: 26: Hoare triple {3884#(<= 3 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,612 INFO L273 TraceCheckUtils]: 27: Hoare triple {3884#(<= 3 ~N~0)} assume !!(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,613 INFO L273 TraceCheckUtils]: 28: Hoare triple {3884#(<= 3 ~N~0)} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,613 INFO L273 TraceCheckUtils]: 29: Hoare triple {3884#(<= 3 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,614 INFO L273 TraceCheckUtils]: 30: Hoare triple {3884#(<= 3 ~N~0)} assume !(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,614 INFO L273 TraceCheckUtils]: 31: Hoare triple {3884#(<= 3 ~N~0)} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,615 INFO L273 TraceCheckUtils]: 32: Hoare triple {3884#(<= 3 ~N~0)} assume true; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,616 INFO L268 TraceCheckUtils]: 33: Hoare quadruple {3884#(<= 3 ~N~0)} {3884#(<= 3 ~N~0)} #91#return; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,617 INFO L273 TraceCheckUtils]: 34: Hoare triple {3884#(<= 3 ~N~0)} assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,618 INFO L256 TraceCheckUtils]: 35: Hoare triple {3884#(<= 3 ~N~0)} call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,618 INFO L273 TraceCheckUtils]: 36: Hoare triple {3884#(<= 3 ~N~0)} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,619 INFO L273 TraceCheckUtils]: 37: Hoare triple {3884#(<= 3 ~N~0)} assume !!(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,620 INFO L273 TraceCheckUtils]: 38: Hoare triple {3884#(<= 3 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,620 INFO L273 TraceCheckUtils]: 39: Hoare triple {3884#(<= 3 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,621 INFO L273 TraceCheckUtils]: 40: Hoare triple {3884#(<= 3 ~N~0)} assume !!(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,621 INFO L273 TraceCheckUtils]: 41: Hoare triple {3884#(<= 3 ~N~0)} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,622 INFO L273 TraceCheckUtils]: 42: Hoare triple {3884#(<= 3 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,622 INFO L273 TraceCheckUtils]: 43: Hoare triple {3884#(<= 3 ~N~0)} assume !!(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,623 INFO L273 TraceCheckUtils]: 44: Hoare triple {3884#(<= 3 ~N~0)} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,623 INFO L273 TraceCheckUtils]: 45: Hoare triple {3884#(<= 3 ~N~0)} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,624 INFO L273 TraceCheckUtils]: 46: Hoare triple {3884#(<= 3 ~N~0)} assume !(~i~1 < ~N~0); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,625 INFO L273 TraceCheckUtils]: 47: Hoare triple {3884#(<= 3 ~N~0)} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,625 INFO L273 TraceCheckUtils]: 48: Hoare triple {3884#(<= 3 ~N~0)} assume true; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,626 INFO L268 TraceCheckUtils]: 49: Hoare quadruple {3884#(<= 3 ~N~0)} {3884#(<= 3 ~N~0)} #93#return; {3884#(<= 3 ~N~0)} is VALID [2018-11-23 12:13:57,627 INFO L273 TraceCheckUtils]: 50: Hoare triple {3884#(<= 3 ~N~0)} assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; {3996#(and (<= 3 ~N~0) (<= main_~i~2 0))} is VALID [2018-11-23 12:13:57,628 INFO L273 TraceCheckUtils]: 51: Hoare triple {3996#(and (<= 3 ~N~0) (<= main_~i~2 0))} assume !!(~i~2 < ~N~0 - 1);call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4);call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4);havoc #t~mem11; {3996#(and (<= 3 ~N~0) (<= main_~i~2 0))} is VALID [2018-11-23 12:13:57,629 INFO L273 TraceCheckUtils]: 52: Hoare triple {3996#(and (<= 3 ~N~0) (<= main_~i~2 0))} #t~post10 := ~i~2;~i~2 := 1 + #t~post10;havoc #t~post10; {4003#(and (<= 3 ~N~0) (<= main_~i~2 1))} is VALID [2018-11-23 12:13:57,630 INFO L273 TraceCheckUtils]: 53: Hoare triple {4003#(and (<= 3 ~N~0) (<= main_~i~2 1))} assume !(~i~2 < ~N~0 - 1); {3838#false} is VALID [2018-11-23 12:13:57,630 INFO L273 TraceCheckUtils]: 54: Hoare triple {3838#false} call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); {3838#false} is VALID [2018-11-23 12:13:57,631 INFO L256 TraceCheckUtils]: 55: Hoare triple {3838#false} call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); {3838#false} is VALID [2018-11-23 12:13:57,631 INFO L273 TraceCheckUtils]: 56: Hoare triple {3838#false} ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; {3838#false} is VALID [2018-11-23 12:13:57,631 INFO L273 TraceCheckUtils]: 57: Hoare triple {3838#false} assume !!(~i~1 < ~N~0); {3838#false} is VALID [2018-11-23 12:13:57,631 INFO L273 TraceCheckUtils]: 58: Hoare triple {3838#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3838#false} is VALID [2018-11-23 12:13:57,632 INFO L273 TraceCheckUtils]: 59: Hoare triple {3838#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3838#false} is VALID [2018-11-23 12:13:57,632 INFO L273 TraceCheckUtils]: 60: Hoare triple {3838#false} assume !!(~i~1 < ~N~0); {3838#false} is VALID [2018-11-23 12:13:57,632 INFO L273 TraceCheckUtils]: 61: Hoare triple {3838#false} assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); {3838#false} is VALID [2018-11-23 12:13:57,632 INFO L273 TraceCheckUtils]: 62: Hoare triple {3838#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3838#false} is VALID [2018-11-23 12:13:57,633 INFO L273 TraceCheckUtils]: 63: Hoare triple {3838#false} assume !!(~i~1 < ~N~0); {3838#false} is VALID [2018-11-23 12:13:57,633 INFO L273 TraceCheckUtils]: 64: Hoare triple {3838#false} assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; {3838#false} is VALID [2018-11-23 12:13:57,633 INFO L273 TraceCheckUtils]: 65: Hoare triple {3838#false} #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; {3838#false} is VALID [2018-11-23 12:13:57,633 INFO L273 TraceCheckUtils]: 66: Hoare triple {3838#false} assume !(~i~1 < ~N~0); {3838#false} is VALID [2018-11-23 12:13:57,633 INFO L273 TraceCheckUtils]: 67: Hoare triple {3838#false} assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); {3838#false} is VALID [2018-11-23 12:13:57,634 INFO L273 TraceCheckUtils]: 68: Hoare triple {3838#false} assume true; {3838#false} is VALID [2018-11-23 12:13:57,634 INFO L268 TraceCheckUtils]: 69: Hoare quadruple {3838#false} {3838#false} #95#return; {3838#false} is VALID [2018-11-23 12:13:57,634 INFO L273 TraceCheckUtils]: 70: Hoare triple {3838#false} assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; {3838#false} is VALID [2018-11-23 12:13:57,634 INFO L273 TraceCheckUtils]: 71: Hoare triple {3838#false} assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; {3838#false} is VALID [2018-11-23 12:13:57,634 INFO L273 TraceCheckUtils]: 72: Hoare triple {3838#false} assume !false; {3838#false} is VALID [2018-11-23 12:13:57,642 INFO L134 CoverageAnalysis]: Checked inductivity of 160 backedges. 80 proven. 6 refuted. 0 times theorem prover too weak. 74 trivial. 0 not checked. [2018-11-23 12:13:57,673 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 1 imperfect interpolant sequences. [2018-11-23 12:13:57,673 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [8] total 8 [2018-11-23 12:13:57,674 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 73 [2018-11-23 12:13:57,674 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:57,674 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states. [2018-11-23 12:13:57,735 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 50 edges. 50 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:57,735 INFO L459 AbstractCegarLoop]: Interpolant automaton has 8 states [2018-11-23 12:13:57,736 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 8 interpolants. [2018-11-23 12:13:57,736 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=19, Invalid=37, Unknown=0, NotChecked=0, Total=56 [2018-11-23 12:13:57,736 INFO L87 Difference]: Start difference. First operand 60 states and 74 transitions. Second operand 8 states. [2018-11-23 12:13:58,241 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:58,241 INFO L93 Difference]: Finished difference Result 94 states and 115 transitions. [2018-11-23 12:13:58,241 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 9 states. [2018-11-23 12:13:58,241 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 73 [2018-11-23 12:13:58,242 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:58,242 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 12:13:58,243 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 64 transitions. [2018-11-23 12:13:58,243 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 12:13:58,244 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 64 transitions. [2018-11-23 12:13:58,245 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states and 64 transitions. [2018-11-23 12:13:58,367 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 64 edges. 64 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:58,369 INFO L225 Difference]: With dead ends: 94 [2018-11-23 12:13:58,369 INFO L226 Difference]: Without dead ends: 66 [2018-11-23 12:13:58,373 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 73 GetRequests, 66 SyntacticMatches, 0 SemanticMatches, 7 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 6 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=25, Invalid=47, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:13:58,373 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 66 states. [2018-11-23 12:13:58,433 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 66 to 64. [2018-11-23 12:13:58,433 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:58,433 INFO L82 GeneralOperation]: Start isEquivalent. First operand 66 states. Second operand 64 states. [2018-11-23 12:13:58,434 INFO L74 IsIncluded]: Start isIncluded. First operand 66 states. Second operand 64 states. [2018-11-23 12:13:58,434 INFO L87 Difference]: Start difference. First operand 66 states. Second operand 64 states. [2018-11-23 12:13:58,436 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:58,437 INFO L93 Difference]: Finished difference Result 66 states and 80 transitions. [2018-11-23 12:13:58,437 INFO L276 IsEmpty]: Start isEmpty. Operand 66 states and 80 transitions. [2018-11-23 12:13:58,438 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:58,438 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:58,438 INFO L74 IsIncluded]: Start isIncluded. First operand 64 states. Second operand 66 states. [2018-11-23 12:13:58,438 INFO L87 Difference]: Start difference. First operand 64 states. Second operand 66 states. [2018-11-23 12:13:58,440 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:58,441 INFO L93 Difference]: Finished difference Result 66 states and 80 transitions. [2018-11-23 12:13:58,441 INFO L276 IsEmpty]: Start isEmpty. Operand 66 states and 80 transitions. [2018-11-23 12:13:58,441 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:58,441 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:58,442 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:58,442 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:58,442 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 64 states. [2018-11-23 12:13:58,444 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 64 states to 64 states and 78 transitions. [2018-11-23 12:13:58,444 INFO L78 Accepts]: Start accepts. Automaton has 64 states and 78 transitions. Word has length 73 [2018-11-23 12:13:58,444 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:58,444 INFO L480 AbstractCegarLoop]: Abstraction has 64 states and 78 transitions. [2018-11-23 12:13:58,444 INFO L481 AbstractCegarLoop]: Interpolant automaton has 8 states. [2018-11-23 12:13:58,445 INFO L276 IsEmpty]: Start isEmpty. Operand 64 states and 78 transitions. [2018-11-23 12:13:58,445 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 76 [2018-11-23 12:13:58,446 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:58,446 INFO L402 BasicCegarLoop]: trace histogram [9, 9, 6, 3, 3, 3, 3, 3, 3, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:58,446 INFO L423 AbstractCegarLoop]: === Iteration 11 === [mainErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:58,446 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:58,446 INFO L82 PathProgramCache]: Analyzing trace with hash 132738585, now seen corresponding path program 2 times [2018-11-23 12:13:58,447 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:58,447 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:58,448 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:58,448 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:13:58,448 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:58,460 ERROR L235 seRefinementStrategy]: Caught known exception: Unsupported non-linear arithmetic [2018-11-23 12:13:58,460 INFO L258 seRefinementStrategy]: Advancing trace checker [2018-11-23 12:13:58,460 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 11 with z3 -smt2 -in SMTLIB2_COMPLIANT=true (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 11 with z3 -smt2 -in SMTLIB2_COMPLIANT=true [2018-11-23 12:13:58,474 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:13:58,547 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:13:58,548 INFO L250 tOrderPrioritization]: Conjunction of SSA is sat [2018-11-23 12:13:58,601 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is sat [2018-11-23 12:13:58,688 INFO L469 BasicCegarLoop]: Counterexample might be feasible ----- class de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder.RCFGBacktranslator [?] CALL call ULTIMATE.init(); VAL [|#NULL.base|=5, |#NULL.offset|=6, |old(#NULL.base)|=5, |old(#NULL.offset)|=6, |old(~N~0)|=7, ~N~0=7] [?] #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=5, |old(#NULL.offset)|=6, |old(~N~0)|=7, ~N~0=0] [?] assume true; VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=5, |old(#NULL.offset)|=6, |old(~N~0)|=7, ~N~0=0] [?] RET #85#return; VAL [|#NULL.base|=0, |#NULL.offset|=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, ~N~0=0] [?] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call init_nondet(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; VAL [init_nondet_~i~0=0, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; VAL [init_nondet_~i~0=0, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; VAL [init_nondet_~i~0=1, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; VAL [init_nondet_~i~0=1, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; VAL [init_nondet_~i~0=2, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; VAL [init_nondet_~i~0=2, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; VAL [init_nondet_~i~0=3, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !(~i~0 < ~N~0); VAL [init_nondet_~i~0=3, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume true; VAL [init_nondet_~i~0=3, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] RET #89#return; VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; VAL [rangesum_~cnt~0=1, rangesum_~i~1=2, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 < ~N~0); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] assume true; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] RET #91#return; VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_#t~ret5|=(- 2147483647), |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); VAL [main_~ret~1=(- 2147483647), main_~temp~0=(- 2147483647), |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; VAL [rangesum_~cnt~0=1, rangesum_~i~1=2, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 < ~N~0); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] assume true; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] RET #93#return; VAL [main_~ret~1=(- 2147483647), main_~temp~0=(- 2147483647), |#NULL.base|=0, |#NULL.offset|=0, |main_#t~ret8|=(- 2147483647), |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; VAL [main_~i~2=0, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~2 < ~N~0 - 1);call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4);call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4);havoc #t~mem11; VAL [main_~i~2=0, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post10 := ~i~2;~i~2 := 1 + #t~post10;havoc #t~post10; VAL [main_~i~2=1, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~2 < ~N~0 - 1);call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4);call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4);havoc #t~mem11; VAL [main_~i~2=1, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post10 := ~i~2;~i~2 := 1 + #t~post10;havoc #t~post10; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !(~i~2 < ~N~0 - 1); VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; VAL [rangesum_~cnt~0=1, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 < ~N~0); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=0, ~N~0=3] [?] assume true; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=0, ~N~0=3] [?] RET #95#return; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~ret12|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret5~0=0, main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret5~0=0, main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !false; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret5~0=0, main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call ULTIMATE.init(); VAL [#NULL.base=5, #NULL.offset=6, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL.base, #NULL.offset := 0, 0; [?] #valid := #valid[0 := 0]; [L4] ~N~0 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] ensures true; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL.base=0, #NULL.offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L33-L55] assume ~N~0 > 1; [L34] call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !(~i~0 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L5-L10] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L35] RET call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4); [L43] call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4); [L43] havoc #t~mem7; [L43] call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !(~i~2 < ~N~0 - 1); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52-L54] assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] ----- ----- class de.uni_freiburg.informatik.ultimate.boogie.preprocessor.BoogiePreprocessorBacktranslator [?] CALL call ULTIMATE.init(); VAL [#NULL.base=5, #NULL.offset=6, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL.base, #NULL.offset := 0, 0; [?] #valid := #valid[0 := 0]; [L4] ~N~0 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] ensures true; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL.base=0, #NULL.offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L33-L55] assume ~N~0 > 1; [L34] call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !(~i~0 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L5-L10] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L35] RET call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4); [L43] call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4); [L43] havoc #t~mem7; [L43] call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !(~i~2 < ~N~0 - 1); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52-L54] assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] ----- ----- class de.uni_freiburg.informatik.ultimate.boogie.procedureinliner.backtranslation.InlinerBacktranslator [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] ----- ----- class de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.CACSL2BoogieBacktranslator [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L4] int N; VAL [\old(N)=7, N=0] [L32] N = __VERIFIER_nondet_int() [L33] COND TRUE N > 1 [L34] int x[N]; VAL [\old(N)=0, N=3, x={9:0}] [L35] CALL init_nondet(x) VAL [\old(N)=0, N=3, x={9:0}] [L6] int i; [L7] i = 0 VAL [\old(N)=0, i=0, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=1, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=2, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=3, N=3, x={9:0}, x={9:0}] [L7] COND FALSE !(i < N) VAL [\old(N)=0, i=3, N=3, x={9:0}, x={9:0}] [L35] RET init_nondet(x) VAL [\old(N)=0, N=3, x={9:0}] [L36] int temp; [L37] int ret; [L38] int ret2; [L39] int ret5; VAL [\old(N)=0, N=3, x={9:0}] [L41] CALL, EXPR rangesum(x) VAL [\old(N)=0, N=3, x={9:0}] [L14] int i; [L15] long long ret; [L16] ret = 0 [L17] int cnt = 0; [L18] i = 0 VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=-2147483647, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L41] RET, EXPR rangesum(x) VAL [\old(N)=0, N=3, rangesum(x)=-2147483647, x={9:0}] [L41] ret = rangesum(x) [L43] EXPR x[0] [L43] temp=x[0] [L43] EXPR x[1] [L43] x[0] = x[1] [L43] x[1] = temp VAL [\old(N)=0, N=3, ret=-2147483647, temp=-2147483647, x={9:0}] [L44] CALL, EXPR rangesum(x) VAL [\old(N)=0, N=3, x={9:0}] [L14] int i; [L15] long long ret; [L16] ret = 0 [L17] int cnt = 0; [L18] i = 0 VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=-2147483647, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L44] RET, EXPR rangesum(x) VAL [\old(N)=0, N=3, rangesum(x)=-2147483647, ret=-2147483647, temp=-2147483647, x={9:0}] [L44] ret2 = rangesum(x) [L45] EXPR x[0] [L45] temp=x[0] [L46] int i =0 ; VAL [\old(N)=0, i=0, N=3, ret=-2147483647, ret2=-2147483647, temp=0, x={9:0}] [L46] COND TRUE i N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L50] RET, EXPR rangesum(x) VAL [\old(N)=0, i=2, N=3, rangesum(x)=0, ret=-2147483647, ret2=-2147483647, temp=0, x={9:0}] [L50] ret5 = rangesum(x) [L52] COND TRUE ret != ret2 || ret !=ret5 VAL [\old(N)=0, i=2, N=3, ret=-2147483647, ret2=-2147483647, ret5=0, temp=0, x={9:0}] [L53] __VERIFIER_error() VAL [\old(N)=0, i=2, N=3, ret=-2147483647, ret2=-2147483647, ret5=0, temp=0, x={9:0}] ----- [2018-11-23 12:13:58,977 WARN L170 areAnnotationChecker]: ULTIMATE.initENTRY has no Hoare annotation [2018-11-23 12:13:58,977 WARN L170 areAnnotationChecker]: ULTIMATE.startENTRY has no Hoare annotation [2018-11-23 12:13:58,977 WARN L170 areAnnotationChecker]: ULTIMATE.startENTRY has no Hoare annotation [2018-11-23 12:13:58,977 WARN L170 areAnnotationChecker]: mainENTRY has no Hoare annotation [2018-11-23 12:13:58,977 WARN L170 areAnnotationChecker]: rangesumENTRY has no Hoare annotation [2018-11-23 12:13:58,977 WARN L170 areAnnotationChecker]: init_nondetENTRY has no Hoare annotation [2018-11-23 12:13:58,978 WARN L170 areAnnotationChecker]: ULTIMATE.initFINAL has no Hoare annotation [2018-11-23 12:13:58,978 WARN L170 areAnnotationChecker]: L-1 has no Hoare annotation [2018-11-23 12:13:58,978 WARN L170 areAnnotationChecker]: L-1 has no Hoare annotation [2018-11-23 12:13:58,978 WARN L170 areAnnotationChecker]: L33 has no Hoare annotation [2018-11-23 12:13:58,978 WARN L170 areAnnotationChecker]: L33 has no Hoare annotation [2018-11-23 12:13:58,978 WARN L170 areAnnotationChecker]: L18-3 has no Hoare annotation [2018-11-23 12:13:58,978 WARN L170 areAnnotationChecker]: L18-3 has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: L18-3 has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: L7-3 has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: L7-3 has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: L7-3 has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: ULTIMATE.initEXIT has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: ULTIMATE.startFINAL has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: L35 has no Hoare annotation [2018-11-23 12:13:58,979 WARN L170 areAnnotationChecker]: L35 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L33-2 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L18-4 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L18-4 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L19 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L19 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L7-4 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L7-2 has no Hoare annotation [2018-11-23 12:13:58,980 WARN L170 areAnnotationChecker]: L35-1 has no Hoare annotation [2018-11-23 12:13:58,981 WARN L170 areAnnotationChecker]: mainFINAL has no Hoare annotation [2018-11-23 12:13:58,981 WARN L170 areAnnotationChecker]: rangesumFINAL has no Hoare annotation [2018-11-23 12:13:58,981 WARN L170 areAnnotationChecker]: L18-2 has no Hoare annotation [2018-11-23 12:13:58,981 WARN L170 areAnnotationChecker]: init_nondetEXIT has no Hoare annotation [2018-11-23 12:13:58,981 WARN L170 areAnnotationChecker]: L41 has no Hoare annotation [2018-11-23 12:13:58,981 WARN L170 areAnnotationChecker]: L41 has no Hoare annotation [2018-11-23 12:13:58,981 WARN L170 areAnnotationChecker]: mainEXIT has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: rangesumEXIT has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: rangesumEXIT has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: rangesumEXIT has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: L41-1 has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: L44-1 has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: L50-1 has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: L44 has no Hoare annotation [2018-11-23 12:13:58,982 WARN L170 areAnnotationChecker]: L44 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L46-3 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L46-3 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L46-3 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L52 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L52 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L46-4 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L46-2 has no Hoare annotation [2018-11-23 12:13:58,983 WARN L170 areAnnotationChecker]: L53 has no Hoare annotation [2018-11-23 12:13:58,985 WARN L170 areAnnotationChecker]: L53 has no Hoare annotation [2018-11-23 12:13:58,985 WARN L170 areAnnotationChecker]: L52-2 has no Hoare annotation [2018-11-23 12:13:58,985 WARN L170 areAnnotationChecker]: L50 has no Hoare annotation [2018-11-23 12:13:58,985 WARN L170 areAnnotationChecker]: L50 has no Hoare annotation [2018-11-23 12:13:58,986 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:13:58,988 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction CFG 23.11 12:13:58 BoogieIcfgContainer [2018-11-23 12:13:58,988 INFO L132 PluginConnector]: ------------------------ END TraceAbstraction---------------------------- [2018-11-23 12:13:58,989 INFO L113 PluginConnector]: ------------------------Witness Printer---------------------------- [2018-11-23 12:13:58,989 INFO L271 PluginConnector]: Initializing Witness Printer... [2018-11-23 12:13:58,989 INFO L276 PluginConnector]: Witness Printer initialized [2018-11-23 12:13:58,990 INFO L185 PluginConnector]: Executing the observer RCFGCatcher from plugin Witness Printer for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:13:45" (3/4) ... [2018-11-23 12:13:58,993 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|=5, |#NULL.offset|=6, |old(#NULL.base)|=5, |old(#NULL.offset)|=6, |old(~N~0)|=7, ~N~0=7] [?] #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0];~N~0 := 0; VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=5, |old(#NULL.offset)|=6, |old(~N~0)|=7, ~N~0=0] [?] assume true; VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(#NULL.base)|=5, |old(#NULL.offset)|=6, |old(~N~0)|=7, ~N~0=0] [?] RET #85#return; VAL [|#NULL.base|=0, |#NULL.offset|=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, ~N~0=0] [?] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647;~N~0 := #t~nondet4;havoc #t~nondet4; VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume ~N~0 > 1;call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call init_nondet(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~0;~i~0 := 0; VAL [init_nondet_~i~0=0, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; VAL [init_nondet_~i~0=0, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; VAL [init_nondet_~i~0=1, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; VAL [init_nondet_~i~0=1, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; VAL [init_nondet_~i~0=2, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~0 < ~N~0);assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647;call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4);havoc #t~nondet1; VAL [init_nondet_~i~0=2, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post0 := ~i~0;~i~0 := 1 + #t~post0;havoc #t~post0; VAL [init_nondet_~i~0=3, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !(~i~0 < ~N~0); VAL [init_nondet_~i~0=3, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume true; VAL [init_nondet_~i~0=3, init_nondet_~x.base=9, init_nondet_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |init_nondet_#in~x.base|=9, |init_nondet_#in~x.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] RET #89#return; VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] havoc ~temp~0;havoc ~ret~1;havoc ~ret2~0;havoc ~ret5~0; VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; VAL [rangesum_~cnt~0=1, rangesum_~i~1=2, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 < ~N~0); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] assume true; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] RET #91#return; VAL [|#NULL.base|=0, |#NULL.offset|=0, |main_#t~ret5|=(- 2147483647), |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647;~ret~1 := #t~ret5;havoc #t~ret5;call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem6;havoc #t~mem6;call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4);call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4);havoc #t~mem7;call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); VAL [main_~ret~1=(- 2147483647), main_~temp~0=(- 2147483647), |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; VAL [rangesum_~cnt~0=1, rangesum_~i~1=2, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 < ~N~0); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] assume true; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=(- 2147483647), rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=(- 2147483647), ~N~0=3] [?] RET #93#return; VAL [main_~ret~1=(- 2147483647), main_~temp~0=(- 2147483647), |#NULL.base|=0, |#NULL.offset|=0, |main_#t~ret8|=(- 2147483647), |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647;~ret2~0 := #t~ret8;havoc #t~ret8;call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4);~temp~0 := #t~mem9;havoc #t~mem9;~i~2 := 0; VAL [main_~i~2=0, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~2 < ~N~0 - 1);call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4);call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4);havoc #t~mem11; VAL [main_~i~2=0, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post10 := ~i~2;~i~2 := 1 + #t~post10;havoc #t~post10; VAL [main_~i~2=1, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !!(~i~2 < ~N~0 - 1);call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4);call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4);havoc #t~mem11; VAL [main_~i~2=1, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] #t~post10 := ~i~2;~i~2 := 1 + #t~post10;havoc #t~post10; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !(~i~2 < ~N~0 - 1); VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [|#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] ~x.base, ~x.offset := #in~x.base, #in~x.offset;havoc ~i~1;havoc ~ret~0;~ret~0 := 0;~cnt~0 := 0;~i~1 := 0; VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=0, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [rangesum_~cnt~0=0, rangesum_~i~1=1, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !!(~i~1 < ~N~0); VAL [rangesum_~cnt~0=0, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2);call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4);~ret~0 := ~ret~0 + #t~mem3;havoc #t~mem3;~cnt~0 := 1 + ~cnt~0; VAL [rangesum_~cnt~0=1, rangesum_~i~1=2, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] #t~post2 := ~i~1;~i~1 := 1 + #t~post2;havoc #t~post2; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume !(~i~1 < ~N~0); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, ~N~0=3] [?] assume 0 != ~cnt~0;#res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=0, ~N~0=3] [?] assume true; VAL [rangesum_~cnt~0=1, rangesum_~i~1=3, rangesum_~ret~0=0, rangesum_~x.base=9, rangesum_~x.offset=0, |#NULL.base|=0, |#NULL.offset|=0, |old(~N~0)|=0, |rangesum_#in~x.base|=9, |rangesum_#in~x.offset|=0, |rangesum_#res|=0, ~N~0=3] [?] RET #95#return; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_#t~ret12|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647;~ret5~0 := #t~ret12;havoc #t~ret12; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret5~0=0, main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret5~0=0, main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] assume !false; VAL [main_~i~2=2, main_~ret2~0=(- 2147483647), main_~ret5~0=0, main_~ret~1=(- 2147483647), main_~temp~0=0, |#NULL.base|=0, |#NULL.offset|=0, |main_~#x~0.base|=9, |main_~#x~0.offset|=0, |old(~N~0)|=0, ~N~0=3] [?] CALL call ULTIMATE.init(); VAL [#NULL.base=5, #NULL.offset=6, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL.base, #NULL.offset := 0, 0; [?] #valid := #valid[0 := 0]; [L4] ~N~0 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] ensures true; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL.base=0, #NULL.offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L33-L55] assume ~N~0 > 1; [L34] call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !(~i~0 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L5-L10] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L35] RET call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4); [L43] call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4); [L43] havoc #t~mem7; [L43] call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !(~i~2 < ~N~0 - 1); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52-L54] assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] ----- ----- class de.uni_freiburg.informatik.ultimate.boogie.preprocessor.BoogiePreprocessorBacktranslator [?] CALL call ULTIMATE.init(); VAL [#NULL.base=5, #NULL.offset=6, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL.base, #NULL.offset := 0, 0; [?] #valid := #valid[0 := 0]; [L4] ~N~0 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] ensures true; VAL [#NULL.base=0, #NULL.offset=0, old(#NULL.base)=5, old(#NULL.offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL.base=0, #NULL.offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L33-L55] assume ~N~0 > 1; [L34] call ~#x~0.base, ~#x~0.offset := #Ultimate.alloc(4 * ~N~0); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !!(~i~0 < ~N~0); [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] call write~int(#t~nondet1, ~x.base, ~x.offset + 4 * ~i~0, 4); [L8] havoc #t~nondet1; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x.base=9, ~x.offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L7-L9] assume !(~i~0 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L5-L10] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x.base=9, ~x.offset=0] [L35] RET call init_nondet(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] call #t~mem6 := read~int(~#x~0.base, ~#x~0.offset, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] call #t~mem7 := read~int(~#x~0.base, 4 + ~#x~0.offset, 4); [L43] call write~int(#t~mem7, ~#x~0.base, ~#x~0.offset, 4); [L43] havoc #t~mem7; [L43] call write~int(~temp~0, ~#x~0.base, 4 + ~#x~0.offset, 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x.base=9, ~x.offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] call #t~mem9 := read~int(~#x~0.base, ~#x~0.offset, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !!(~i~2 < ~N~0 - 1); [L47] call #t~mem11 := read~int(~#x~0.base, ~#x~0.offset + 4 * (1 + ~i~2), 4); [L47] call write~int(#t~mem11, ~#x~0.base, ~#x~0.offset + 4 * ~i~2, 4); [L47] havoc #t~mem11; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] assume !(~i~2 < ~N~0 - 1); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] call write~int(~temp~0, ~#x~0.base, ~#x~0.offset + 4 * (~N~0 - 1), 4); VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x.base, ~x.offset := #in~x.base, #in~x.offset; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !!(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L19-L22] assume ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2); [L20] call #t~mem3 := read~int(~x.base, ~x.offset + 4 * ~i~1, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L18-L23] assume !(~i~1 < ~N~0); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L24-L27] assume 0 != ~cnt~0; [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L12-L28] ensures true; VAL [#in~x.base=9, #in~x.offset=0, #NULL.base=0, #NULL.offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x.base=9, ~x.offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0.base, ~#x~0.offset); VAL [#NULL.base=0, #NULL.offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52-L54] assume ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL.base=0, #NULL.offset=0, old(~N~0)=0, ~#x~0.base=9, ~#x~0.offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] ----- ----- class de.uni_freiburg.informatik.ultimate.boogie.procedureinliner.backtranslation.InlinerBacktranslator [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] ----- ----- class de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.CACSL2BoogieBacktranslator [?] CALL call ULTIMATE.init(); VAL [#NULL!base=5, #NULL!offset=6, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=7] [?] #NULL := { base: 0, offset: 0 }; [?] #valid[0] := 0; [L4] ~N~0 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(#NULL!base)=5, old(#NULL!offset)=6, old(~N~0)=7, ~N~0=0] [?] RET call ULTIMATE.init(); VAL [#NULL!base=0, #NULL!offset=0, ~N~0=0] [?] CALL call #t~ret13 := main(); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=0] [L32] assume -2147483648 <= #t~nondet4 && #t~nondet4 <= 2147483647; [L32] ~N~0 := #t~nondet4; [L32] havoc #t~nondet4; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L33] COND TRUE ~N~0 > 1 [L34] FCALL call ~#x~0 := #Ultimate.alloc(4 * ~N~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L35] CALL call init_nondet(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L5-L10] ~x := #in~x; [L6] havoc ~i~0; [L7] ~i~0 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=0, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=1, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND FALSE !(!(~i~0 < ~N~0)) [L8] assume -2147483648 <= #t~nondet1 && #t~nondet1 <= 2147483647; [L8] FCALL call write~int(#t~nondet1, { base: ~x!base, offset: ~x!offset + 4 * ~i~0 }, 4); [L8] havoc #t~nondet1; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=2, ~N~0=3, ~x!base=9, ~x!offset=0] [L7] #t~post0 := ~i~0; [L7] ~i~0 := 1 + #t~post0; [L7] havoc #t~post0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L7-L9] COND TRUE !(~i~0 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~i~0=3, ~N~0=3, ~x!base=9, ~x!offset=0] [L35] RET call init_nondet(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L36] havoc ~temp~0; [L37] havoc ~ret~1; [L38] havoc ~ret2~0; [L39] havoc ~ret5~0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] CALL call #t~ret5 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L41] RET call #t~ret5 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret5=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3] [L41] assume -2147483648 <= #t~ret5 && #t~ret5 <= 2147483647; [L41] ~ret~1 := #t~ret5; [L41] havoc #t~ret5; [L43] FCALL call #t~mem6 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] ~temp~0 := #t~mem6; [L43] havoc #t~mem6; [L43] FCALL call #t~mem7 := read~int({ base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); [L43] FCALL call write~int(#t~mem7, { base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L43] havoc #t~mem7; [L43] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: 4 + ~#x~0!offset }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] CALL call #t~ret8 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=-2147483647, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=-2147483647, ~x!base=9, ~x!offset=0] [L44] RET call #t~ret8 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret8=-2147483647, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~N~0=3, ~ret~1=-2147483647, ~temp~0=-2147483647] [L44] assume -2147483648 <= #t~ret8 && #t~ret8 <= 2147483647; [L44] ~ret2~0 := #t~ret8; [L44] havoc #t~ret8; [L45] FCALL call #t~mem9 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset }, 4); [L45] ~temp~0 := #t~mem9; [L45] havoc #t~mem9; [L46] ~i~2 := 0; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=0, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND FALSE !(!(~i~2 < ~N~0 - 1)) [L47] FCALL call #t~mem11 := read~int({ base: ~#x~0!base, offset: ~#x~0!offset + 4 * (1 + ~i~2) }, 4); [L47] FCALL call write~int(#t~mem11, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * ~i~2 }, 4); [L47] havoc #t~mem11; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=1, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46] #t~post10 := ~i~2; [L46] ~i~2 := 1 + #t~post10; [L46] havoc #t~post10; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L46-L48] COND TRUE !(~i~2 < ~N~0 - 1) VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L49] FCALL call write~int(~temp~0, { base: ~#x~0!base, offset: ~#x~0!offset + 4 * (~N~0 - 1) }, 4); VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] CALL call #t~ret12 := rangesum(~#x~0); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~N~0=3] [L12-L28] ~x := #in~x; [L14] havoc ~i~1; [L15] havoc ~ret~0; [L16] ~ret~0 := 0; [L17] ~cnt~0 := 0; [L18] ~i~1 := 0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=0, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND FALSE !(~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=1, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND FALSE !(!(~i~1 < ~N~0)) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=0, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L19] COND TRUE ~i~1 > (if ~N~0 < 0 && 0 != ~N~0 % 2 then 1 + ~N~0 / 2 else ~N~0 / 2) [L20] FCALL call #t~mem3 := read~int({ base: ~x!base, offset: ~x!offset + 4 * ~i~1 }, 4); [L20] ~ret~0 := ~ret~0 + #t~mem3; [L20] havoc #t~mem3; [L21] ~cnt~0 := 1 + ~cnt~0; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=2, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18] #t~post2 := ~i~1; [L18] ~i~1 := 1 + #t~post2; [L18] havoc #t~post2; VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L18-L23] COND TRUE !(~i~1 < ~N~0) VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L24] COND TRUE 0 != ~cnt~0 [L25] #res := (if (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 <= 2147483647 then (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 else (if ~ret~0 < 0 && 0 != ~ret~0 % ~cnt~0 then (if ~cnt~0 < 0 then ~ret~0 / ~cnt~0 - 1 else 1 + ~ret~0 / ~cnt~0) else ~ret~0 / ~cnt~0) % 4294967296 - 4294967296); VAL [#in~x!base=9, #in~x!offset=0, #NULL!base=0, #NULL!offset=0, #res=0, old(~N~0)=0, ~cnt~0=1, ~i~1=3, ~N~0=3, ~ret~0=0, ~x!base=9, ~x!offset=0] [L50] RET call #t~ret12 := rangesum(~#x~0); VAL [#NULL!base=0, #NULL!offset=0, #t~ret12=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret~1=-2147483647, ~temp~0=0] [L50] assume -2147483648 <= #t~ret12 && #t~ret12 <= 2147483647; [L50] ~ret5~0 := #t~ret12; [L50] havoc #t~ret12; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L52] COND TRUE ~ret~1 != ~ret2~0 || ~ret~1 != ~ret5~0 VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L53] assert false; VAL [#NULL!base=0, #NULL!offset=0, old(~N~0)=0, ~#x~0!base=9, ~#x~0!offset=0, ~i~2=2, ~N~0=3, ~ret2~0=-2147483647, ~ret5~0=0, ~ret~1=-2147483647, ~temp~0=0] [L4] int N; VAL [\old(N)=7, N=0] [L32] N = __VERIFIER_nondet_int() [L33] COND TRUE N > 1 [L34] int x[N]; VAL [\old(N)=0, N=3, x={9:0}] [L35] CALL init_nondet(x) VAL [\old(N)=0, N=3, x={9:0}] [L6] int i; [L7] i = 0 VAL [\old(N)=0, i=0, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=1, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=2, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=3, N=3, x={9:0}, x={9:0}] [L7] COND FALSE !(i < N) VAL [\old(N)=0, i=3, N=3, x={9:0}, x={9:0}] [L35] RET init_nondet(x) VAL [\old(N)=0, N=3, x={9:0}] [L36] int temp; [L37] int ret; [L38] int ret2; [L39] int ret5; VAL [\old(N)=0, N=3, x={9:0}] [L41] CALL, EXPR rangesum(x) VAL [\old(N)=0, N=3, x={9:0}] [L14] int i; [L15] long long ret; [L16] ret = 0 [L17] int cnt = 0; [L18] i = 0 VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=-2147483647, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L41] RET, EXPR rangesum(x) VAL [\old(N)=0, N=3, rangesum(x)=-2147483647, x={9:0}] [L41] ret = rangesum(x) [L43] EXPR x[0] [L43] temp=x[0] [L43] EXPR x[1] [L43] x[0] = x[1] [L43] x[1] = temp VAL [\old(N)=0, N=3, ret=-2147483647, temp=-2147483647, x={9:0}] [L44] CALL, EXPR rangesum(x) VAL [\old(N)=0, N=3, x={9:0}] [L14] int i; [L15] long long ret; [L16] ret = 0 [L17] int cnt = 0; [L18] i = 0 VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=-2147483647, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L44] RET, EXPR rangesum(x) VAL [\old(N)=0, N=3, rangesum(x)=-2147483647, ret=-2147483647, temp=-2147483647, x={9:0}] [L44] ret2 = rangesum(x) [L45] EXPR x[0] [L45] temp=x[0] [L46] int i =0 ; VAL [\old(N)=0, i=0, N=3, ret=-2147483647, ret2=-2147483647, temp=0, x={9:0}] [L46] COND TRUE i N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L50] RET, EXPR rangesum(x) VAL [\old(N)=0, i=2, N=3, rangesum(x)=0, ret=-2147483647, ret2=-2147483647, temp=0, x={9:0}] [L50] ret5 = rangesum(x) [L52] COND TRUE ret != ret2 || ret !=ret5 VAL [\old(N)=0, i=2, N=3, ret=-2147483647, ret2=-2147483647, ret5=0, temp=0, x={9:0}] [L53] __VERIFIER_error() VAL [\old(N)=0, i=2, N=3, ret=-2147483647, ret2=-2147483647, ret5=0, temp=0, x={9:0}] ----- [2018-11-23 12:13:59,184 INFO L145 WitnessManager]: Wrote witness to /storage/repos/svcomp/c/reducercommutativity/rangesum_false-unreach-call_true-termination.i-witness.graphml [2018-11-23 12:13:59,184 INFO L132 PluginConnector]: ------------------------ END Witness Printer---------------------------- [2018-11-23 12:13:59,186 INFO L168 Benchmark]: Toolchain (without parser) took 15572.59 ms. Allocated memory was 1.5 GB in the beginning and 2.4 GB in the end (delta: 849.3 MB). Free memory was 1.4 GB in the beginning and 1.6 GB in the end (delta: -220.0 MB). Peak memory consumption was 629.3 MB. Max. memory is 7.1 GB. [2018-11-23 12:13:59,188 INFO L168 Benchmark]: CDTParser took 0.25 ms. Allocated memory is still 1.5 GB. Free memory is still 1.5 GB. There was no memory consumed. Max. memory is 7.1 GB. [2018-11-23 12:13:59,188 INFO L168 Benchmark]: CACSL2BoogieTranslator took 364.88 ms. Allocated memory is still 1.5 GB. Free memory was 1.4 GB in the beginning and 1.4 GB in the end (delta: 13.2 MB). Peak memory consumption was 13.2 MB. Max. memory is 7.1 GB. [2018-11-23 12:13:59,188 INFO L168 Benchmark]: Boogie Procedure Inliner took 35.36 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:13:59,189 INFO L168 Benchmark]: Boogie Preprocessor took 69.00 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:13:59,189 INFO L168 Benchmark]: RCFGBuilder took 1171.17 ms. Allocated memory was 1.5 GB in the beginning and 2.2 GB in the end (delta: 710.4 MB). Free memory was 1.4 GB in the beginning and 2.1 GB in the end (delta: -748.1 MB). Peak memory consumption was 14.9 MB. Max. memory is 7.1 GB. [2018-11-23 12:13:59,189 INFO L168 Benchmark]: TraceAbstraction took 13730.87 ms. Allocated memory was 2.2 GB in the beginning and 2.4 GB in the end (delta: 138.9 MB). Free memory was 2.1 GB in the beginning and 1.6 GB in the end (delta: 500.1 MB). Peak memory consumption was 639.0 MB. Max. memory is 7.1 GB. [2018-11-23 12:13:59,192 INFO L168 Benchmark]: Witness Printer took 195.51 ms. Allocated memory is still 2.4 GB. Free memory was 1.6 GB in the beginning and 1.6 GB in the end (delta: 14.8 MB). Peak memory consumption was 14.8 MB. Max. memory is 7.1 GB. [2018-11-23 12:13:59,194 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.25 ms. Allocated memory is still 1.5 GB. Free memory is still 1.5 GB. There was no memory consumed. Max. memory is 7.1 GB. * CACSL2BoogieTranslator took 364.88 ms. Allocated memory is still 1.5 GB. Free memory was 1.4 GB in the beginning and 1.4 GB in the end (delta: 13.2 MB). Peak memory consumption was 13.2 MB. Max. memory is 7.1 GB. * Boogie Procedure Inliner took 35.36 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. * Boogie Preprocessor took 69.00 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. * RCFGBuilder took 1171.17 ms. Allocated memory was 1.5 GB in the beginning and 2.2 GB in the end (delta: 710.4 MB). Free memory was 1.4 GB in the beginning and 2.1 GB in the end (delta: -748.1 MB). Peak memory consumption was 14.9 MB. Max. memory is 7.1 GB. * TraceAbstraction took 13730.87 ms. Allocated memory was 2.2 GB in the beginning and 2.4 GB in the end (delta: 138.9 MB). Free memory was 2.1 GB in the beginning and 1.6 GB in the end (delta: 500.1 MB). Peak memory consumption was 639.0 MB. Max. memory is 7.1 GB. * Witness Printer took 195.51 ms. Allocated memory is still 2.4 GB. Free memory was 1.6 GB in the beginning and 1.6 GB in the end (delta: 14.8 MB). Peak memory consumption was 14.8 MB. Max. memory is 7.1 GB. * Results from de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction: - CounterExampleResult [Line: 53]: a call of __VERIFIER_error() is reachable a call of __VERIFIER_error() is reachable We found a FailurePath: [L4] int N; VAL [\old(N)=7, N=0] [L32] N = __VERIFIER_nondet_int() [L33] COND TRUE N > 1 [L34] int x[N]; VAL [\old(N)=0, N=3, x={9:0}] [L35] CALL init_nondet(x) VAL [\old(N)=0, N=3, x={9:0}] [L6] int i; [L7] i = 0 VAL [\old(N)=0, i=0, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=1, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=2, N=3, x={9:0}, x={9:0}] [L7] COND TRUE i < N [L8] x[i] = __VERIFIER_nondet_int() [L7] i++ VAL [\old(N)=0, i=3, N=3, x={9:0}, x={9:0}] [L7] COND FALSE !(i < N) VAL [\old(N)=0, i=3, N=3, x={9:0}, x={9:0}] [L35] RET init_nondet(x) VAL [\old(N)=0, N=3, x={9:0}] [L36] int temp; [L37] int ret; [L38] int ret2; [L39] int ret5; VAL [\old(N)=0, N=3, x={9:0}] [L41] CALL, EXPR rangesum(x) VAL [\old(N)=0, N=3, x={9:0}] [L14] int i; [L15] long long ret; [L16] ret = 0 [L17] int cnt = 0; [L18] i = 0 VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=-2147483647, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L41] RET, EXPR rangesum(x) VAL [\old(N)=0, N=3, rangesum(x)=-2147483647, x={9:0}] [L41] ret = rangesum(x) [L43] EXPR x[0] [L43] temp=x[0] [L43] EXPR x[1] [L43] x[0] = x[1] [L43] x[1] = temp VAL [\old(N)=0, N=3, ret=-2147483647, temp=-2147483647, x={9:0}] [L44] CALL, EXPR rangesum(x) VAL [\old(N)=0, N=3, x={9:0}] [L14] int i; [L15] long long ret; [L16] ret = 0 [L17] int cnt = 0; [L18] i = 0 VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=-2147483647, cnt=1, i=3, N=3, ret=-2147483647, x={9:0}, x={9:0}] [L44] RET, EXPR rangesum(x) VAL [\old(N)=0, N=3, rangesum(x)=-2147483647, ret=-2147483647, temp=-2147483647, x={9:0}] [L44] ret2 = rangesum(x) [L45] EXPR x[0] [L45] temp=x[0] [L46] int i =0 ; VAL [\old(N)=0, i=0, N=3, ret=-2147483647, ret2=-2147483647, temp=0, x={9:0}] [L46] COND TRUE i N/2) VAL [\old(N)=0, cnt=0, i=0, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND FALSE !(i > N/2) VAL [\old(N)=0, cnt=0, i=1, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND TRUE i < N VAL [\old(N)=0, cnt=0, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L19] COND TRUE i > N/2 [L20] EXPR x[i] [L20] ret = ret + x[i] [L21] cnt = cnt + 1 VAL [\old(N)=0, cnt=1, i=2, N=3, ret=0, x={9:0}, x={9:0}] [L18] i++ VAL [\old(N)=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L18] COND FALSE !(i < N) VAL [\old(N)=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L24] COND TRUE cnt !=0 [L25] return ret / cnt; VAL [\old(N)=0, \result=0, cnt=1, i=3, N=3, ret=0, x={9:0}, x={9:0}] [L50] RET, EXPR rangesum(x) VAL [\old(N)=0, i=2, N=3, rangesum(x)=0, ret=-2147483647, ret2=-2147483647, temp=0, x={9:0}] [L50] ret5 = rangesum(x) [L52] COND TRUE ret != ret2 || ret !=ret5 VAL [\old(N)=0, i=2, N=3, ret=-2147483647, ret2=-2147483647, ret5=0, temp=0, x={9:0}] [L53] __VERIFIER_error() VAL [\old(N)=0, i=2, N=3, ret=-2147483647, ret2=-2147483647, ret5=0, temp=0, x={9:0}] - StatisticsResult: Ultimate Automizer benchmark data CFG has 5 procedures, 39 locations, 1 error locations. UNSAFE Result, 13.6s OverallTime, 11 OverallIterations, 9 TraceHistogramMax, 6.9s AutomataDifference, 0.0s DeadEndRemovalTime, 0.0s HoareAnnotationTime, HoareTripleCheckerStatistics: 327 SDtfs, 180 SDslu, 653 SDs, 0 SdLazy, 512 SolverSat, 29 SolverUnsat, 0 SolverUnknown, 0 SolverNotchecked, 0.9s Time, PredicateUnifierStatistics: 0 DeclaredPredicates, 480 GetRequests, 430 SyntacticMatches, 7 SemanticMatches, 43 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 29 ImplicationChecksByTransitivity, 0.9s Time, 0.0s BasicInterpolantAutomatonTime, BiggestAbstraction: size=64occurred in iteration=10, 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.6s AutomataMinimizationTime, 10 MinimizatonAttempts, 26 StatesRemovedByMinimization, 9 NontrivialMinimizations, HoareAnnotationStatistics: No data available, RefinementEngineStatistics: TraceCheckStatistics: 0.1s SsaConstructionTime, 0.3s SatisfiabilityAnalysisTime, 3.4s InterpolantComputationTime, 624 NumberOfCodeBlocks, 624 NumberOfCodeBlocksAsserted, 15 NumberOfCheckSat, 501 ConstructedInterpolants, 0 QuantifiedInterpolants, 58147 SizeOfPredicates, 12 NumberOfNonLiveVariables, 1683 ConjunctsInSsa, 41 ConjunctsInUnsatCore, 10 InterpolantComputations, 5 PerfectInterpolantSequences, 558/580 InterpolantCoveringCapability, InvariantSynthesisStatistics: No data available, InterpolantConsolidationStatistics: No data available, ReuseStatistics: No data available RESULT: Ultimate proved your program to be incorrect! Received shutdown request...