diff --git a/Cargo.toml b/Cargo.toml index ad006953..9741adf9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,69 +1,10 @@ -[package] -name = "reactor_rt" -version = "0.1.0" -authors = ["Clément Fournier "] -edition = "2021" +[workspace] -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[dependencies] -log = "0.4" -index_vec = "0.1" -#itertools = "0.10.1" -#bit-set = "0.5" -smallvec = { version = "1.6", features = ["const_generics"] } -petgraph = "0.6" -array-macro = "2.1" -atomic_refcell = "0.1" -crossbeam-utils = "0.8" -crossbeam-channel = { git = "https://github.com/oowekyala/crossbeam.git", rev = "9eed66904f969156dedad4eef61ce91d23b9cccb" } -static_assertions = "1.1.0" -rayon = { version = "1.5", optional = true } -vecmap = { git = "https://github.com/jhaye/vecmap", rev = "94a2709665620ed7847529cd90a44c19ebd8a195" } -cfg-if = "1.0.0" - -[dev-dependencies] -criterion = "0.3" -env_logger = "0.9" -assert_matches = "1.5" -dmsort = "1.0.1" - -[features] -default=["vec-id-sets"] -# Enable the parallel runtime implementation todo make default -parallel-runtime=["rayon"] -# Enables 64-bit wide reaction ids on 64 bit architectures. -# This may reduce performance, but allows for 2^32 reactor -# instances compared to the default of 2^16, which may feel -# a bit tight for some applications. -wide-ids=[] -vec-id-sets=[] -no-unsafe=[] -# used internally for benchmarking, to access private APIs -public-internals=[] - -[[bench]] -name = "savina_pong" -harness = false - -[[bench]] -name = "global_id" -path = "benches/micro/global_id.rs" -required-features = ["public-internals"] -harness = false - -[[bench]] -name = "dmsort" -path = "benches/micro/dmsort.rs" -required-features = ["public-internals"] -harness = false - -[[bench]] -name = "exec_reactions" -path = "benches/micro/exec_reactions.rs" -required-features = ["public-internals"] -harness = false +members = [ + "runtime", + "vecmap", +] +exclude = [ "vecmap/creusot" ] [profile.bench] -debug = true - +debug = true \ No newline at end of file diff --git a/clippy.toml b/clippy.toml index 1e5837c7..8e42eba9 100644 --- a/clippy.toml +++ b/clippy.toml @@ -1 +1,2 @@ -too-many-arguments-threshold = 10 \ No newline at end of file +too-many-arguments-threshold = 10 +msrv = "1.57.0" \ No newline at end of file diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml new file mode 100644 index 00000000..51a82709 --- /dev/null +++ b/runtime/Cargo.toml @@ -0,0 +1,65 @@ +[package] +name = "reactor_rt" +version = "0.1.0" +authors = ["Clément Fournier "] +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +log = "0.4" +index_vec = "0.1" +#itertools = "0.10.1" +#bit-set = "0.5" +smallvec = { version = "1.6", features = ["const_generics"] } +petgraph = "0.6" +array-macro = "2.1" +atomic_refcell = "0.1" +crossbeam-utils = "0.8" +crossbeam-channel = { git = "https://github.com/oowekyala/crossbeam.git", rev = "9eed66904f969156dedad4eef61ce91d23b9cccb" } +static_assertions = "1.1.0" +rayon = { version = "1.5", optional = true } +vecmap = { path = "../vecmap" } +cfg-if = "1.0.0" + +[dev-dependencies] +criterion = "0.3" +env_logger = "0.9" +assert_matches = "1.5" +dmsort = "1.0.1" + +[features] +default=["vec-id-sets"] +# Enable the parallel runtime implementation todo make default +parallel-runtime=["rayon"] +# Enables 64-bit wide reaction ids on 64 bit architectures. +# This may reduce performance, but allows for 2^32 reactor +# instances compared to the default of 2^16, which may feel +# a bit tight for some applications. +wide-ids=[] +vec-id-sets=[] +no-unsafe=[] +# used internally for benchmarking, to access private APIs +public-internals=[] + +[[bench]] +name = "savina_pong" +harness = false + +[[bench]] +name = "global_id" +path = "benches/micro/global_id.rs" +required-features = ["public-internals"] +harness = false + +[[bench]] +name = "dmsort" +path = "benches/micro/dmsort.rs" +required-features = ["public-internals"] +harness = false + +[[bench]] +name = "exec_reactions" +path = "benches/micro/exec_reactions.rs" +required-features = ["public-internals"] +harness = false diff --git a/benches/README.md b/runtime/benches/README.md similarity index 100% rename from benches/README.md rename to runtime/benches/README.md diff --git a/benches/SavinaPong.lf b/runtime/benches/SavinaPong.lf similarity index 100% rename from benches/SavinaPong.lf rename to runtime/benches/SavinaPong.lf diff --git a/benches/micro/dmsort.rs b/runtime/benches/micro/dmsort.rs similarity index 100% rename from benches/micro/dmsort.rs rename to runtime/benches/micro/dmsort.rs diff --git a/benches/micro/exec_reactions.rs b/runtime/benches/micro/exec_reactions.rs similarity index 100% rename from benches/micro/exec_reactions.rs rename to runtime/benches/micro/exec_reactions.rs diff --git a/benches/micro/global_id.rs b/runtime/benches/micro/global_id.rs similarity index 100% rename from benches/micro/global_id.rs rename to runtime/benches/micro/global_id.rs diff --git a/benches/savina_pong.rs b/runtime/benches/savina_pong.rs similarity index 100% rename from benches/savina_pong.rs rename to runtime/benches/savina_pong.rs diff --git a/src/actions.rs b/runtime/src/actions.rs similarity index 100% rename from src/actions.rs rename to runtime/src/actions.rs diff --git a/src/assembly.rs b/runtime/src/assembly.rs similarity index 100% rename from src/assembly.rs rename to runtime/src/assembly.rs diff --git a/src/ids.rs b/runtime/src/ids.rs similarity index 100% rename from src/ids.rs rename to runtime/src/ids.rs diff --git a/src/lib.rs b/runtime/src/lib.rs similarity index 100% rename from src/lib.rs rename to runtime/src/lib.rs diff --git a/src/ports.rs b/runtime/src/ports.rs similarity index 100% rename from src/ports.rs rename to runtime/src/ports.rs diff --git a/src/scheduler/assembly_impl.rs b/runtime/src/scheduler/assembly_impl.rs similarity index 100% rename from src/scheduler/assembly_impl.rs rename to runtime/src/scheduler/assembly_impl.rs diff --git a/src/scheduler/context.rs b/runtime/src/scheduler/context.rs similarity index 100% rename from src/scheduler/context.rs rename to runtime/src/scheduler/context.rs diff --git a/src/scheduler/debug.rs b/runtime/src/scheduler/debug.rs similarity index 100% rename from src/scheduler/debug.rs rename to runtime/src/scheduler/debug.rs diff --git a/src/scheduler/dependencies.rs b/runtime/src/scheduler/dependencies.rs similarity index 100% rename from src/scheduler/dependencies.rs rename to runtime/src/scheduler/dependencies.rs diff --git a/src/scheduler/events.rs b/runtime/src/scheduler/events.rs similarity index 100% rename from src/scheduler/events.rs rename to runtime/src/scheduler/events.rs diff --git a/src/scheduler/mod.rs b/runtime/src/scheduler/mod.rs similarity index 100% rename from src/scheduler/mod.rs rename to runtime/src/scheduler/mod.rs diff --git a/src/scheduler/scheduler_impl.rs b/runtime/src/scheduler/scheduler_impl.rs similarity index 100% rename from src/scheduler/scheduler_impl.rs rename to runtime/src/scheduler/scheduler_impl.rs diff --git a/src/test/mod.rs b/runtime/src/test/mod.rs similarity index 100% rename from src/test/mod.rs rename to runtime/src/test/mod.rs diff --git a/src/test/stuff_that_must_compile.rs b/runtime/src/test/stuff_that_must_compile.rs similarity index 100% rename from src/test/stuff_that_must_compile.rs rename to runtime/src/test/stuff_that_must_compile.rs diff --git a/src/test/test_ports.rs b/runtime/src/test/test_ports.rs similarity index 100% rename from src/test/test_ports.rs rename to runtime/src/test/test_ports.rs diff --git a/src/test/testutil.rs b/runtime/src/test/testutil.rs similarity index 100% rename from src/test/testutil.rs rename to runtime/src/test/testutil.rs diff --git a/src/time.rs b/runtime/src/time.rs similarity index 100% rename from src/time.rs rename to runtime/src/time.rs diff --git a/src/timers.rs b/runtime/src/timers.rs similarity index 100% rename from src/timers.rs rename to runtime/src/timers.rs diff --git a/src/triggers.rs b/runtime/src/triggers.rs similarity index 100% rename from src/triggers.rs rename to runtime/src/triggers.rs diff --git a/src/util/mod.rs b/runtime/src/util/mod.rs similarity index 100% rename from src/util/mod.rs rename to runtime/src/util/mod.rs diff --git a/vecmap/.gitignore b/vecmap/.gitignore new file mode 100644 index 00000000..4fffb2f8 --- /dev/null +++ b/vecmap/.gitignore @@ -0,0 +1,2 @@ +/target +/Cargo.lock diff --git a/vecmap/Cargo.toml b/vecmap/Cargo.toml new file mode 100644 index 00000000..1494842b --- /dev/null +++ b/vecmap/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "vecmap" +version = "0.1.0" +edition = "2021" +license = "MIT" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/vecmap/LICENSE-LGPL b/vecmap/LICENSE-LGPL new file mode 100644 index 00000000..b885a535 --- /dev/null +++ b/vecmap/LICENSE-LGPL @@ -0,0 +1,505 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 + USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random + Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + diff --git a/vecmap/LICENSE-MIT b/vecmap/LICENSE-MIT new file mode 100644 index 00000000..3605d693 --- /dev/null +++ b/vecmap/LICENSE-MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Technische Universität Dresden + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vecmap/README.md b/vecmap/README.md new file mode 100644 index 00000000..1460c3bd --- /dev/null +++ b/vecmap/README.md @@ -0,0 +1,50 @@ +# VecMap + +A formally verified sorted sparse map implementation using `Vec` underneath. +The data structure is verified using [Creusot](https://github.com/xldenis/creusot).\ +The crate is ready to use as is. + +## Verification + +This section describes the process of reproducing the verification of this crate. + +### Preliminaries + +Creusot's annotations require Rust Nightly, and further some trait restrictions that +would be extra work to implement on usage. This is why this repo contains two `VecMap` +implementations: +- `src/lib.rs` +- `creusot/src/lib.rs` + +The implementation in the `creusot` subdir contains the annotations and trait +restrictions/implementations to work with Creusot. Otherwise the implementations are +identical.\ +To verify this yourself, load the two files into a diff tool of your choosing and +ensure that `src/lib.rs` doesn't add anything over `creusot/src/lib.rs`. Note that +some things like `Debug`/`Display` and iterator implementations are disabled with +[conditional compilation flags](https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute) +for Creusot to work. + +### Creusot + +For verfication with Creusot the following things are needed: +- [Rust](https://www.rust-lang.org/tools/install) via `rustup` +- [Creusot](https://github.com/xldenis/creusot) + - follow the instructions in the [Readme](https://github.com/xldenis/creusot#installing-creusot-as-a-user) +- Make + +Instructions: +1) enter the `creusot` subdir +2) run `make` + - This will compile the project, extract the generated specification, and open it in Why3. +3) In Why3 you can see all the individual proofs in the left column. Select the root node and press `3` on the keyboard. + - This will automatically split and verify the proof goals. +4) Once the root node features a green check mark icon, the verification is complete. + +## Licensing + +This crate for use in other Rust projects is available under the MIT license. +The files in the `creusot/prelude` sub-directory are licensed under LGPLv2.1. +Also note, due to using Creusot (licensed LGPLv2.1) as a dependency for verification, +the compilation artefacts in `creusot` are also licensed LGPLv2.1. +See the respective licensing files for details. diff --git a/vecmap/creusot/.gitignore b/vecmap/creusot/.gitignore new file mode 100644 index 00000000..4fffb2f8 --- /dev/null +++ b/vecmap/creusot/.gitignore @@ -0,0 +1,2 @@ +/target +/Cargo.lock diff --git a/vecmap/creusot/Cargo.toml b/vecmap/creusot/Cargo.toml new file mode 100644 index 00000000..c300aff9 --- /dev/null +++ b/vecmap/creusot/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "vecmap-creusot" +author = ["Johannes Hayeß "] +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +creusot-contracts = { rev = "fbd66041acf5a3f2480c4cc75be024e2f99b0bb7", git = "https://github.com/xldenis/creusot" } + +[features] +default=["contracts"] +contracts = ["creusot-contracts/contracts"] + +[workspace] diff --git a/vecmap/creusot/Makefile b/vecmap/creusot/Makefile new file mode 100644 index 00000000..aa950cca --- /dev/null +++ b/vecmap/creusot/Makefile @@ -0,0 +1,14 @@ +all: creusot ide + +creusot: + cargo creusot -- --features=contracts + -mv -u target/debug/*.mlcfg . + +ide: *.mlcfg + ./ide $< + +clean: + rm *.mlcfg + cargo clean + +.PHONY: all creusot ide clean diff --git a/vecmap/creusot/ide b/vecmap/creusot/ide new file mode 100755 index 00000000..18f379ee --- /dev/null +++ b/vecmap/creusot/ide @@ -0,0 +1,4 @@ +#!/usr/bin/env bash + +SCRIPTPATH=$(dirname "$BASH_SOURCE") +why3 --debug=ignore_unused_vars ide -L $SCRIPTPATH/prelude $@ diff --git a/vecmap/creusot/prelude/prelude.mlw b/vecmap/creusot/prelude/prelude.mlw new file mode 100644 index 00000000..60deef26 --- /dev/null +++ b/vecmap/creusot/prelude/prelude.mlw @@ -0,0 +1,174 @@ +module Opaque + type opaque_ptr +end +module Mapping + function from_fn (f : 'a -> 'b) : ('a -> 'b) = f + val from_fn (f : 'a -> 'b) : ('a -> 'b) + ensures { result = from_fn f } +end +module Bool + let eqb (a : bool) (b : bool) : bool = + ensures { result <-> a = b } + match a, b with + | True, True -> True + | False, False -> True + | _ -> False + end + + let neqb (a : bool) (b : bool) : bool = + ensures { result <-> a <> b } + not (eqb a b) + + let to_int (b : bool) : int = + if b then 1 else 0 + + use int.Int + + let of_int (i : int) : bool = + i = 1 +end +module Borrow + type borrowed 'a = { current : 'a ; final : 'a; } + let function ( *_ ) x = x.current + let function ( ^_ ) x = x.final + val borrow_mut (a : 'a) : borrowed 'a + ensures { *result = a } +end +module Slice + use seq.Seq + type rust_array 'a = seq 'a + function id (s : seq 'a) : seq 'a = s +end +module IntSize + use export mach.int.Int64 + type isize = int64 +end +module UIntSize + use export mach.int.UInt64 + type usize = uint64 +end +module Int8 + use int.Int + + type int8 = < range -0x80 0x7f > + + let constant min_int8 : int = - 0x80 + let constant max_int8 : int = 0x7f + function to_int (x : int8) : int = int8'int x + + clone export mach.int.Bounded_int with + type t = int8, + constant min = int8'minInt, + constant max = int8'maxInt, + function to_int = int8'int, + lemma to_int_in_bounds, + lemma extensionality +end +module Int16 + use int.Int + + type int16 = < range -0x8000 0x7fff > + + let constant min_int16 : int = - 0x8000 + let constant max_int16 : int = 0x7fff + function to_int (x : int16) : int = int16'int x + + clone export mach.int.Bounded_int with + type t = int16, + constant min = int16'minInt, + constant max = int16'maxInt, + function to_int = int16'int, + lemma to_int_in_bounds, + lemma extensionality +end +module Int128 + use int.Int + + type int128 = < range -0x80000000000000000000000000000000 0x7fffffffffffffffffffffffffffffff > + + let constant min_int128 : int = - 0x80000000000000000000000000000000 + let constant max_int128 : int = 0x7fffffffffffffffffffffffffffffff + function to_int (x : int128) : int = int128'int x + + clone export mach.int.Bounded_int with + type t = int128, + constant min = int128'minInt, + constant max = int128'maxInt, + function to_int = int128'int, + lemma to_int_in_bounds, + lemma extensionality +end +module UInt8 + use int.Int + + type uint8 = < range 0x0 0xff > + + let constant min_uint8 : int = 0x00 + let constant max_uint8 : int = 0xff + function to_int (x : uint8) : int = uint8'int x + + clone export mach.int.Bounded_int with + type t = uint8, + constant min = uint8'minInt, + constant max = uint8'maxInt, + function to_int = uint8'int, + lemma to_int_in_bounds, + lemma extensionality +end +module UInt16 + use int.Int + + type uint16 = < range 0x0 0xffff > + + let constant min_uint16 : int = 0x00 + let constant max_uint16 : int = 0xffff + function to_int (x : uint16) : int = uint16'int x + + clone export mach.int.Bounded_int with + type t = uint16, + constant min = uint16'minInt, + constant max = uint16'maxInt, + function to_int = uint16'int, + lemma to_int_in_bounds, + lemma extensionality +end +module UInt128 + use int.Int + + type uint128 = < range 0x0 0xffffffffffffffffffffffffffffffff > + + let constant min_uint128 : int = 0x00000000000000000000000000000000 + let constant max_uint128 : int = 0xffffffffffffffffffffffffffffffff + function to_int (x : uint128) : int = uint128'int x + + clone export mach.int.Bounded_int with + type t = uint128, + constant min = uint128'minInt, + constant max = uint128'maxInt, + function to_int = uint128'int, + lemma to_int_in_bounds, + lemma extensionality +end +module Char + (* utf8 characters (not glyphs) + highly restricted until Why3 supports Unicode strings + *) + use int.Int + + type char + + function code char : int + + axiom code: forall c. 0 <= code c < 0x10FFFF + + val function chr (n: int) : char + + axiom code_chr: forall n. 0 <= n < 0x10FFFF -> code (chr n) = n + + axiom chr_code: forall c. chr (code c) = c +end +module Ghost + type ghost_ty 't = 't + let function new (x : 't) : ghost_ty 't = x + let function inner (x : ghost_ty 't) : 't = x +end \ No newline at end of file diff --git a/vecmap/creusot/prelude/seq_ext.mlw b/vecmap/creusot/prelude/seq_ext.mlw new file mode 100644 index 00000000..bea0e0cc --- /dev/null +++ b/vecmap/creusot/prelude/seq_ext.mlw @@ -0,0 +1,6 @@ +module SeqExt +use seq.Seq + +function subsequence (s : seq 't) (i : int) (j : int) : seq 't = s[i..j] + +end \ No newline at end of file diff --git a/vecmap/creusot/rust-toolchain b/vecmap/creusot/rust-toolchain new file mode 100644 index 00000000..c1d72952 --- /dev/null +++ b/vecmap/creusot/rust-toolchain @@ -0,0 +1,3 @@ +[toolchain] +channel = "nightly-2022-11-25" +components = [ "rustfmt", "rustc-dev", "llvm-tools-preview" ] \ No newline at end of file diff --git a/vecmap/creusot/src/lib.rs b/vecmap/creusot/src/lib.rs new file mode 100644 index 00000000..b14a169f --- /dev/null +++ b/vecmap/creusot/src/lib.rs @@ -0,0 +1,580 @@ +/* + * Copyright (c) 2021, TU Dresden. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +//! This is a formally verified implementation of a sparse map that uses [Vec] underneath. +//! Entries are retained in sorted order by key to facilitate fast search. + +#![feature(min_specialization)] + +use ::std::cmp::Ordering; +#[cfg(not(feature = "contracts"))] +use ::std::fmt::{Debug, Display, Formatter}; +use creusot_contracts::invariant::Invariant; +use creusot_contracts::{Clone, *}; + +/// A sparse map representation over a totally ordered key type. +pub struct VecMap +where + K: Eq + Ord, +{ + v: Vec<(K, V)>, +} + +impl VecMap +where + K: Eq + Ord + DeepModel, + K::DeepModelTy: OrdLogic, +{ + #[logic] + #[trusted] + #[ensures(result.len() == (@self.v).len() && + forall i >= 0 && i < (@self.v).len() ==> + result[i] == (@self.v)[i].0.deep_model())] + fn key_seq(self) -> Seq { + pearlite! { absurd } + } + + #[predicate] + fn is_sorted(self) -> bool { + pearlite! { + forall m >= 0 && n >= 0 && m < (@self.v).len() && n < (@self.v).len() && m < n ==> + self.key_seq()[m] < self.key_seq()[n] + } + } +} + +impl VecMap +where + K: Eq + Ord + DeepModel, + K::DeepModelTy: OrdLogic, +{ + pub fn new() -> Self { + Self { v: Vec::new() } + } + + /// Find an entry with assumption that the key is random access. + /// Logarithmic complexity. + #[requires(self.is_sorted())] + #[ensures(forall result == Entry::Occupied(e) ==> e.invariant())] + #[ensures(forall result == Entry::Vacant(e) ==> e.invariant())] + pub fn entry(&mut self, key: K) -> Entry { + match self.find_k(&key) { + Ok(index) => Entry::Occupied(OccupiedEntry { map: self, index, key }), + Err(index) => Entry::Vacant(VacantEntry { map: self, index, key }), + } + } + + /// Find the entry matching `key`. Use `key_hint` to accelerate search. + /// The function will use the provided hint to skip items before it.\ + /// **Note**: This function makes two assumptions about your input: + /// - `key_hint` is valid, i.e. the underlying key is in the map and since extracting + /// the reference, no item has been removed from the map + /// - `key_hint.key <= key` + /// + /// If either of these assumptions is violated, you might obtain an entry which allows + /// destroying the well-kept order of the items. + #[requires(self.is_sorted())] + #[requires(self.is_valid_keyref_lg(key_hint))] + #[requires(key_hint.key.deep_model() <= key.deep_model())] + #[ensures(forall result == Entry::Occupied(e) ==> e.invariant())] + #[ensures(forall result == Entry::Vacant(e) ==> e.invariant())] + pub fn entry_from_ref(&mut self, key_hint: KeyRef, key: K) -> Entry { + debug_assert!(self.is_valid_keyref(&key_hint.as_ref())); + let KeyRef { min_idx, .. } = key_hint; + + #[invariant(t, true)] + for i in min_idx..self.v.len() { + match self.v[i].0.cmp(&key) { + Ordering::Equal => return Entry::Occupied(OccupiedEntry { map: self, index: i, key }), + Ordering::Greater => { + assert!(i >= 1); // otherwise min_idx + return Entry::Vacant(VacantEntry { map: self, index: i, key }); + } + _ => {} + } + } + let i = self.v.len(); + Entry::Vacant(VacantEntry { map: self, index: i, key }) + } + + /// Finds entry reference, either directly associated with `min_key_inclusive`, or the entry with the + /// closest key (in terms of sorting order) greater than `min_key_inclusive`. Returns `None` if + /// map does not contain entry with key greater or equal to `min_key_inclusive`. + #[requires(self.is_sorted())] + #[ensures(result == None ==> forall i >= 0 && i < (@self.v).len() ==> + self.key_seq()[i] < min_key_inclusive.deep_model())] + #[ensures(forall result == Some(mapping) && i >= 0 && i < @mapping.0.min_idx ==> + self.key_seq()[i] < min_key_inclusive.deep_model())] + #[ensures(forall result == Some(mapping) && i >= @mapping.0.min_idx && i < (@self.v).len() ==> + self.key_seq()[i] >= min_key_inclusive.deep_model())] + #[ensures(forall result == Some(mapping) ==> + (@self.v)[@mapping.0.min_idx].1 == *mapping.1)] + pub fn find_random_mapping_after(&self, min_key_inclusive: K) -> Option<(KeyRef<&K>, &V)> { + match self.find_k(&min_key_inclusive) { + Ok(index) => { + let (key, value) = &self.v[index]; + Some((KeyRef { key, min_idx: index }, value)) + } + Err(index) => match self.v.get(index) { + Some((key, value)) => { + assert!(key >= &min_key_inclusive); + Some((KeyRef { key, min_idx: index }, value)) + } + None => None, + }, + } + } + + /// Insert `value` for `key` in the map. If `key` is already contained, the function + /// replaces the previously held value and returns it. + #[maintains((mut self).is_sorted())] + #[ensures(exists i >= 0 && i < (@(^self).v).len() ==> + (^self).key_seq()[i] == key.deep_model() && (@(^self).v)[i].1 == value)] + pub fn insert(&mut self, key: K, value: V) -> Option { + match self.find_k(&key) { + Ok(index) => Some(std::mem::replace(&mut self.v[index].1, value)), + Err(index) => { + self.insert_internal(index, key, value); + None + } + } + } + + /// Removes the item with `key` and returns its value. If no such item exists, + /// it does nothing. + #[maintains((mut self).is_sorted())] + #[ensures(result == None ==> + !self.key_seq().contains(key.deep_model()) && + *self == ^self)] + #[ensures(forall result == Some(v) ==> + exists i >= 0 && i < (@self.v).len() ==> + self.key_seq()[i] == key.deep_model() && (@self.v)[i].1 == v && + (@(^self).v) == (@self.v).subsequence(0, i).concat( + (@self.v).subsequence(i + 1, (@self.v).len()) + ))] + pub fn remove(&mut self, key: &K) -> Option { + match self.find_k(key) { + Ok(index) => Some(self.v.remove(index).1), + Err(_) => None, + } + } + + /// Get the value associated with `key`, if it exists. + #[requires(self.is_sorted())] + #[ensures(result == None ==> !self.key_seq().contains(key.deep_model()))] + #[ensures(forall result == Some(v) ==> + exists i >= 0 && i < (@self.v).len() ==> + self.key_seq()[i] == key.deep_model() && (@self.v)[i].1 == *v)] + pub fn get(&self, key: &K) -> Option<&V> { + match self.find_k(key) { + Ok(index) => Some(&self.v[index].1), + Err(_) => None, + } + } + + /// Checks if `key` is contained in the map. + #[requires(self.is_sorted())] + #[ensures(result == self.key_seq().contains(key.deep_model()))] + pub fn contains_key(&self, key: &K) -> bool { + self.find_k(key).is_ok() + } + + /// Produces the first mapping that follows the given key + /// in the ascending order of keys. + #[requires(self.is_sorted())] + #[ensures(result == None ==> + forall i >= 0 && i < (@self.v).len() ==> + self.key_seq()[i] <= key.key.deep_model())] + #[ensures(forall result == Some(entry) ==> + exists i >= 0 && i < (@self.v).len() ==> + self.key_seq()[i] == entry.0.key.deep_model() && + self.key_seq()[i] > key.key.deep_model() && + (@self.v)[i].1 == *entry.1 && + forall j >= 0 && j < i ==> + self.key_seq()[j] < entry.0.key.deep_model() && + self.key_seq()[j] <= key.key.deep_model())] + pub fn next_mapping(&self, key: KeyRef<&K>) -> Option<(KeyRef<&K>, &V)> { + let from = if self.is_valid_keyref(&key) { + key.min_idx + } else { + 0 // it's not, maybe it was produced by another vecmap + }; + + #[invariant(prev_leq, forall j >= 0 && j < produced.len() + @from ==> + self.key_seq()[j] <= key.key.deep_model())] + for idx in from..self.v.len() { + if self.v[idx].0 > *key.key { + let (key, value) = &self.v[idx]; + return Some((KeyRef { min_idx: idx, key }, value)); + } + } + None + } + + #[requires(self.is_sorted())] + #[ensures(result == self.is_valid_keyref_lg((*key).to_owned()))] + #[ensures(result ==> @key.min_idx < (@self.v).len())] + #[ensures(result ==> forall i >= 0 && i <= @key.min_idx ==> + self.key_seq()[i] <= key.key.deep_model())] + fn is_valid_keyref(&self, key: &KeyRef<&K>) -> bool { + match self.v.get(key.min_idx) { + Some((k, _)) => k <= key.key, + _ => false, + } + } + + #[predicate] + #[requires(self.is_sorted())] + fn is_valid_keyref_lg(self, key: KeyRef) -> bool { + pearlite! { + match self.key_seq().get(@key.min_idx) { + Some(k) => { + k <= key.key.deep_model() + }, + _ => false + } + } + } + + /// Iterate over all key-value paris in the map. + #[cfg(not(feature = "contracts"))] + pub fn iter(&self) -> impl Iterator + '_ { + self.v.iter() + } + + /// Obtain keyref-value pair of the item with the smallest key, unless the map is empty. + #[requires(self.is_sorted())] + #[ensures(result == None ==> (@self.v).len() == 0)] + #[ensures(forall result == Some(entry) ==> (@self.v)[0] == ((*entry.0.key, *entry.1)))] + #[ensures(forall result == Some(entry) ==> @entry.0.min_idx == 0)] + #[ensures(forall result == Some(entry) ==> + forall i >= 0 && i < (@self.v).len() ==> self.key_seq()[i] >= entry.0.key.deep_model() + )] + pub fn min_entry(&self) -> Option<(KeyRef<&K>, &V)> { + #[allow(clippy::manual_map)] + match self.v.first() { + Some((key, value)) => Some((KeyRef { key, min_idx: 0 }, value)), + None => None, + } + } + + /// Obtain the key of the item with the greatest key, unless the map is empty. + #[requires(self.is_sorted())] + #[ensures(result == None ==> (@self.v).len() == 0)] + #[ensures(forall result == Some(k) ==> + forall i >= 0 && i < (@self.v).len() ==> + self.key_seq()[i] <= k.deep_model() + )] + pub fn max_key(&self) -> Option<&K> { + match self.v.last() { + Some(e) => Some(&e.0), + None => None, + } + } + + /// Attempts to find the given `key`. If found, it returns `Ok` with the index of the key in the + /// underlying `Vec`. Otherwise it returns `Err` with the index where a matching element could be + /// inserted while maintaining sorted order. + #[requires(self.is_sorted())] + #[ensures(match result { + Ok(_) => self.key_seq().contains(key.deep_model()), + Err(_) => !self.key_seq().contains(key.deep_model()), + })] + #[ensures(forall result == Ok(i) ==> self.key_seq()[@i] == key.deep_model())] + #[ensures(forall result == Err(i) ==> j >= @i && j < (@self.v).len() ==> + self.key_seq()[j] > key.deep_model())] + #[ensures(forall result == Err(i) && j >= 0 && j < @i ==> + self.key_seq()[j] < key.deep_model())] + #[ensures(match result { + Ok(idx) => @idx < (@self.v).len(), + Err(idx) => @idx <= (@self.v).len(), + })] + fn find_k(&self, key: &K) -> Result { + let mut size = self.v.len(); + let mut left = 0; + let mut right = size; + let mut mid; + + #[invariant(size_bounds, @size >= 0 && @size <= (@self.v).len())] + #[invariant(left_bounds, @left >= 0 && @left <= (@self.v).len())] + #[invariant(right_bounds, @right >= 0 && @right <= (@self.v).len())] + #[invariant(mid_bounds, @left < @right ==> (@left + (@size / 2)) < (@self.v).len())] + #[invariant(right_gt_mid, @left < @right ==> @right > (@left + (@size / 2)))] + #[invariant(right_geq_key, forall i >= @right && i < (@self.v).len() ==> + self.key_seq()[i] > key.deep_model())] + #[invariant(left_lt_key, forall i >= 0 && i < @left ==> + self.key_seq()[i] < key.deep_model())] + while left < right { + mid = left + size / 2; + + let cmp = self.v[mid].0.cmp(key); + + match cmp { + Ordering::Less => left = mid + 1, + Ordering::Greater => right = mid, + Ordering::Equal => return Ok(mid), + } + + size = right - left; + } + Err(left) + } + + /// Directly insert into the underlying `Vec`. This does not maintain the sorting of elements + /// by itself. + #[requires(@idx <= (@self.v).len())] + #[ensures((@(^self).v).len() == (@self.v).len() + 1)] + #[ensures(forall 0 <= i && i < @idx ==> (@(^self).v)[i] == (@self.v)[i])] + #[ensures((@(^self).v)[@idx] == (key, value))] + #[ensures(forall @idx < i && i < (@(^self).v).len() ==> (@(^self).v)[i] == (@self.v)[i - 1])] + #[ensures(self.is_sorted() && (@self.v).len() == 0 ==> (^self).is_sorted())] + #[ensures(self.is_sorted() && (@self.v).len() > 0 && @idx > 0 && @idx < (@self.v).len() && + (@self.v)[@idx].0.deep_model() > key.deep_model() && + (@self.v)[@idx - 1].0.deep_model() < key.deep_model() ==> + (^self).is_sorted() + )] + #[ensures(self.is_sorted() && (@self.v).len() > 0 && @idx == 0 && + (@self.v)[@idx].0.deep_model() > key.deep_model() ==> + (^self).is_sorted() + )] + #[ensures(self.is_sorted() && (@self.v).len() > 0 && @idx == (@self.v).len() && + (@self.v)[@idx - 1].0.deep_model() < key.deep_model() ==> + (^self).is_sorted() + )] + fn insert_internal(&mut self, idx: usize, key: K, value: V) { + self.v.insert(idx, (key, value)) + } +} + +impl Clone for VecMap { + #[ensures(result == *self)] + fn clone(&self) -> Self { + VecMap { v: self.v.clone() } + } +} + +#[cfg(not(feature = "contracts"))] +impl Debug for VecMap { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + self.v.iter().collect::>().fmt(f) + } +} + +impl ::std::default::Default for VecMap { + #[ensures(result.is_default())] + fn default() -> Self { + Self { v: Vec::new() } + } +} + +impl creusot_contracts::Default for VecMap +where + K: Ord, +{ + #[predicate] + fn is_default(self) -> bool { + pearlite! { (@self.v).len() == 0 } + } +} + +/// A view into a single entry in a map, which may either be vacant or occupied. +pub enum Entry<'a, K, V> +where + K: Ord + Eq, +{ + /// A vacant Entry + Vacant(VacantEntry<'a, K, V>), + + /// An occupied Entry + Occupied(OccupiedEntry<'a, K, V>), +} + +/// A vacant Entry. +pub struct VacantEntry<'a, K, V> +where + K: Ord + Eq, +{ + map: &'a mut VecMap, + key: K, + index: usize, +} + +/// An occupied Entry. +pub struct OccupiedEntry<'a, K, V> +where + K: Ord + Eq, +{ + map: &'a mut VecMap, + key: K, + index: usize, +} + +impl Entry<'_, K, V> +where + K: Ord + Eq + DeepModel, + K::DeepModelTy: OrdLogic, +{ + #[requires(match self { + Entry::Vacant(VacantEntry {map, ..}) => map.is_sorted(), + Entry::Occupied(OccupiedEntry {map, ..}) => map.is_sorted(), + })] + pub fn keyref(&self) -> KeyRef<&K> { + match self { + Entry::Vacant(VacantEntry { key, index, .. }) => KeyRef { min_idx: *index, key }, + Entry::Occupied(OccupiedEntry { key, index, .. }) => KeyRef { min_idx: *index, key }, + } + } +} + +#[trusted] +impl Resolve for VacantEntry<'_, K, V> +where + K: Eq + Ord, +{ + #[predicate] + fn resolve(self) -> bool { + self.map.resolve() && self.key.resolve() + } +} + +impl Invariant for VacantEntry<'_, K, V> +where + K: Eq + Ord + DeepModel, + K::DeepModelTy: OrdLogic, +{ + #[predicate] + fn invariant(self) -> bool { + pearlite! { + self.map.is_sorted() && @self.index <= (@self.map.v).len() + } + } +} + +impl VacantEntry<'_, K, V> +where + K: Ord + Eq + DeepModel, + K::DeepModelTy: OrdLogic, +{ + /// Sets the value of the entry with the VacantEntry's key. + #[requires(self.invariant())] + #[requires(forall i >= 0 && i < @self.index ==> + self.map.key_seq()[i] < self.key.deep_model())] + #[requires(forall i >= @self.index && i < (@self.map.v).len() ==> + self.map.key_seq()[i] > self.key.deep_model())] + #[ensures((^self.map).is_sorted())] + pub fn insert(self, value: V) { + self.map.insert_internal(self.index, self.key, value); + proof_assert!(self.invariant()); + } +} + +impl Invariant for OccupiedEntry<'_, K, V> +where + K: Eq + Ord + DeepModel, + K::DeepModelTy: OrdLogic, +{ + #[predicate] + fn invariant(self) -> bool { + pearlite! { + self.map.is_sorted() && + (@self.map.v).len() > @self.index && + self.map.key_seq()[@self.index] == self.key.deep_model() + } + } +} + +impl OccupiedEntry<'_, K, V> +where + K: Ord + Eq + DeepModel, + K::DeepModelTy: OrdLogic, +{ + /// Replaces the entry's value with `value`. + #[maintains((mut self).invariant())] + #[ensures((@(^self).map.v)[@self.index].1 == value)] + pub fn replace(&mut self, value: V) { + self.map.v[self.index].1 = value; + } + + /// Gets the mutable ref to the entry's value. + #[maintains((mut self).invariant())] + pub fn get_mut(&mut self) -> &mut V { + &mut self.map.v[self.index].1 + } +} + +/// A key zipped with its internal index in this map. +/// For some operations, like manually implemented iteration, +/// the index can be used for optimisation. +#[derive(Copy, Clone)] +pub struct KeyRef { + pub key: K, + /// This is a lower bound on the actual index of key K, + /// it doesn't need to be the index (though it usually will be). + min_idx: usize, +} + +impl DeepModel for KeyRef { + type DeepModelTy = (K::DeepModelTy, Int); + + #[logic] + fn deep_model(self) -> Self::DeepModelTy { + pearlite! {(self.key.deep_model(), @self.min_idx)} + } +} + +impl KeyRef<&K> { + #[inline] + pub fn cloned(self) -> KeyRef { + KeyRef { min_idx: self.min_idx, key: self.key.clone() } + } +} + +impl KeyRef { + #[inline] + #[ensures(self.deep_model() == result.deep_model())] + pub fn as_ref(&self) -> KeyRef<&K> { + KeyRef { min_idx: self.min_idx, key: &self.key } + } +} + +impl KeyRef<&K> { + #[logic] + #[ensures(self.deep_model() == result.deep_model())] + fn to_owned(self) -> KeyRef { + KeyRef { key: *self.key, min_idx: self.min_idx } + } +} + +#[cfg(not(feature = "contracts"))] +impl Display for KeyRef { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.key) + } +} + +impl From for KeyRef { + fn from(key: K) -> Self { + Self { key, min_idx: 0 } + } +} diff --git a/vecmap/creusot/vecmap-rlib.mlcfg b/vecmap/creusot/vecmap-rlib.mlcfg new file mode 100644 index 00000000..d4124be2 --- /dev/null +++ b/vecmap/creusot/vecmap-rlib.mlcfg @@ -0,0 +1,8131 @@ + +module Core_Ptr_NonNull_NonNull_Type + use prelude.Opaque + type t_nonnull 't = + | C_NonNull opaque_ptr + +end +module Core_Marker_PhantomData_Type + type t_phantomdata 't = + | C_PhantomData + +end +module Core_Ptr_Unique_Unique_Type + use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type + use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type + type t_unique 't = + | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) + +end +module Alloc_RawVec_RawVec_Type + use mach.int.Int + use prelude.UIntSize + use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type + type t_rawvec 't 'a = + | C_RawVec (Core_Ptr_Unique_Unique_Type.t_unique 't) usize 'a + +end +module Alloc_Vec_Vec_Type + use mach.int.Int + use prelude.UIntSize + use Alloc_RawVec_RawVec_Type as Alloc_RawVec_RawVec_Type + type t_vec 't 'a = + | C_Vec (Alloc_RawVec_RawVec_Type.t_rawvec 't 'a) usize + +end +module Alloc_Alloc_Global_Type + type t_global = + | C_Global + +end +module Vecmap_VecMap_Type + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + type t_vecmap 'k 'v = + | C_VecMap (Alloc_Vec_Vec_Type.t_vec ('k, 'v) (Alloc_Alloc_Global_Type.t_global)) + + let function vecmap_v (self : t_vecmap 'k 'v) : Alloc_Vec_Vec_Type.t_vec ('k, 'v) (Alloc_Alloc_Global_Type.t_global) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VecMap a -> a + end +end +module Core_Num_Impl12_Max_Stub + use mach.int.Int + use prelude.UIntSize + val constant mAX' : usize +end +module Core_Num_Impl12_Max + use mach.int.Int + use prelude.UIntSize + let constant mAX' : usize = [@vc:do_not_keep_trace] [@vc:sp] + (18446744073709551615 : usize) +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + axiom shallow_model_spec : forall self : Alloc_Vec_Vec_Type.t_vec t a . Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + val shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + ensures { result = shallow_model self } + + axiom shallow_model_spec : forall self : Alloc_Vec_Vec_Type.t_vec t a . Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Model_DeepModel_DeepModelTy_Type + type self + type deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel_Stub + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel_Interface + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy + val deep_model (self : self) : DeepModelTy0.deepModelTy + ensures { result = deep_model self } + +end +module Vecmap_Impl0_KeySeq_Stub + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + function key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + +end +module Vecmap_Impl0_KeySeq_Interface + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + function key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + + axiom key_seq_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v . [#"../src/lib.rs" 52 4 54 56] Seq.length (key_seq self) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (key_seq self) i = DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a)) +end +module Vecmap_Impl0_KeySeq + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + function key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + + val key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + ensures { result = key_seq self } + + axiom key_seq_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v . [#"../src/lib.rs" 52 4 54 56] Seq.length (key_seq self) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (key_seq self) i = DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a)) +end +module Core_Cmp_Ordering_Type + type t_ordering = + | C_Less + | C_Equal + | C_Greater + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering + val cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = cmp_log self _2' } + +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub + type self + predicate lt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface + type self + predicate lt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate lt_log (self : self) (o : self) = + [#"../src/lib.rs" 384 33 384 66] CmpLog0.cmp_log self o = Core_Cmp_Ordering_Type.C_Less + val lt_log (self : self) (o : self) : bool + ensures { result = lt_log self o } + +end +module Vecmap_Impl0_IsSorted_Stub + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl0_IsSorted_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl0_IsSorted + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use mach.int.Int + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + predicate is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) = + [#"../src/lib.rs" 61 8 64 9] forall n : int . forall m : int . m >= 0 /\ n >= 0 /\ m < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ n < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ m < n -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) m) (Seq.get (KeySeq0.key_seq self) n) + val is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) : bool + ensures { result = is_sorted self } + +end +module Alloc_Vec_Impl0_New_Interface + type t + use seq.Seq + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = t, + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val new [@cfg:stackify] (_1' : ()) : Alloc_Vec_Vec_Type.t_vec t (Alloc_Alloc_Global_Type.t_global) + ensures { Seq.length (ShallowModel0.shallow_model result) = 0 } + +end +module Alloc_Vec_Impl0_New + type t + use seq.Seq + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel0 with + type t = t, + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val new [@cfg:stackify] (_1' : ()) : Alloc_Vec_Vec_Type.t_vec t (Alloc_Alloc_Global_Type.t_global) + ensures { Seq.length (ShallowModel0.shallow_model result) = 0 } + +end +module Vecmap_Impl1_New_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + val new [@cfg:stackify] [#"../src/lib.rs" 73 4 73 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v +end +module Vecmap_Impl1_New + type k + type v + clone Core_Num_Impl12_Max as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Alloc_Vec_Impl0_New_Interface as New0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + let rec cfg new [@cfg:stackify] [#"../src/lib.rs" 73 4 73 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_VecMap_Type.t_vecmap k v; + var _1 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + goto BB0 + } + BB0 { + _1 <- ([#"../src/lib.rs" 74 18 74 28] New0.new ()); + goto BB1 + } + BB1 { + _0 <- Vecmap_VecMap_Type.C_VecMap _1; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_OccupiedEntry_Type + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + type t_occupiedentry 'k 'v = + | C_OccupiedEntry (borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v)) 'k usize + + let function occupiedentry_map (self : t_occupiedentry 'k 'v) : borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry a _ _ -> a + end + let function occupiedentry_index (self : t_occupiedentry 'k 'v) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry _ _ a -> a + end + let function occupiedentry_key (self : t_occupiedentry 'k 'v) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry _ a _ -> a + end +end +module Vecmap_VacantEntry_Type + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + type t_vacantentry 'k 'v = + | C_VacantEntry (borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v)) 'k usize + + let function vacantentry_map (self : t_vacantentry 'k 'v) : borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry a _ _ -> a + end + let function vacantentry_index (self : t_vacantentry 'k 'v) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry _ _ a -> a + end + let function vacantentry_key (self : t_vacantentry 'k 'v) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry _ a _ -> a + end +end +module Vecmap_Entry_Type + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + type t_entry 'k 'v = + | C_Vacant (Vecmap_VacantEntry_Type.t_vacantentry 'k 'v) + | C_Occupied (Vecmap_OccupiedEntry_Type.t_occupiedentry 'k 'v) + + let function occupied_0 (self : t_entry 'k 'v) : Vecmap_OccupiedEntry_Type.t_occupiedentry 'k 'v + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Vacant _ -> any Vecmap_OccupiedEntry_Type.t_occupiedentry 'k 'v + | C_Occupied a -> a + end + let function vacant_0 (self : t_entry 'k 'v) : Vecmap_VacantEntry_Type.t_vacantentry 'k 'v + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Vacant a -> a + | C_Occupied _ -> any Vecmap_VacantEntry_Type.t_vacantentry 'k 'v + end +end +module Vecmap_Impl8_Invariant_Stub + type k + type v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + predicate invariant' [#"../src/lib.rs" 537 4 537 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) +end +module Vecmap_Impl8_Invariant_Interface + type k + type v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + predicate invariant' [#"../src/lib.rs" 537 4 537 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) +end +module Vecmap_Impl8_Invariant + type k + type v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + use prelude.Borrow + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate invariant' [#"../src/lib.rs" 537 4 537 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) = + [#"../src/lib.rs" 538 8 542 9] IsSorted0.is_sorted ( * Vecmap_OccupiedEntry_Type.occupiedentry_map self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map self))) > UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index self) /\ Seq.get (KeySeq0.key_seq ( * Vecmap_OccupiedEntry_Type.occupiedentry_map self)) (UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index self)) = DeepModel0.deep_model (Vecmap_OccupiedEntry_Type.occupiedentry_key self) + val invariant' [#"../src/lib.rs" 537 4 537 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) : bool + ensures { result = invariant' self } + +end +module Vecmap_Impl6_Invariant_Stub + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate invariant' [#"../src/lib.rs" 507 4 507 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl6_Invariant_Interface + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate invariant' [#"../src/lib.rs" 507 4 507 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl6_Invariant + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use prelude.Borrow + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate invariant' [#"../src/lib.rs" 507 4 507 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) = + [#"../src/lib.rs" 508 8 510 9] IsSorted0.is_sorted ( * Vecmap_VacantEntry_Type.vacantentry_map self) /\ UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_VacantEntry_Type.vacantentry_map self))) + val invariant' [#"../src/lib.rs" 507 4 507 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) : bool + ensures { result = invariant' self } + +end +module Core_Result_Result_Type + type t_result 't 'e = + | C_Ok 't + | C_Err 'e + + let function err_0 (self : t_result 't 'e) : 'e = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Ok _ -> any 'e + | C_Err a -> a + end + let function ok_0 (self : t_result 't 'e) : 't = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Ok a -> a + | C_Err _ -> any 't + end +end +module CreusotContracts_Model_Impl0_DeepModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + function deep_model (self : t) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_Impl0_DeepModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + function deep_model (self : t) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_Impl0_DeepModel + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = t, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function deep_model (self : t) : DeepModelTy0.deepModelTy = + DeepModel0.deep_model self + val deep_model (self : t) : DeepModelTy0.deepModelTy + ensures { result = deep_model self } + +end +module CreusotContracts_Logic_Seq_Impl0_Contains_Stub + type t + use seq.Seq + predicate contains (self : Seq.seq t) (e : t) +end +module CreusotContracts_Logic_Seq_Impl0_Contains_Interface + type t + use seq.Seq + predicate contains (self : Seq.seq t) (e : t) +end +module CreusotContracts_Logic_Seq_Impl0_Contains + type t + use seq.Seq + use mach.int.Int + predicate contains (self : Seq.seq t) (e : t) = + exists i : int . 0 <= i /\ i < Seq.length self /\ Seq.get self i = e + val contains (self : Seq.seq t) (e : t) : bool + ensures { result = contains self e } + +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub + type self + predicate gt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface + type self + predicate gt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate gt_log (self : self) (o : self) = + [#"../src/lib.rs" 391 35 392 1] CmpLog0.cmp_log self o = Core_Cmp_Ordering_Type.C_Greater + val gt_log (self : self) (o : self) : bool + ensures { result = gt_log self o } + +end +module CreusotContracts_Model_ShallowModel_ShallowModelTy_Type + type self + type shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel_Stub + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel_Interface + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy + val shallow_model (self : self) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module CreusotContracts_Model_Impl1_ShallowModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl1_ShallowModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl1_ShallowModel + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + clone CreusotContracts_Model_ShallowModel_ShallowModel_Stub as ShallowModel0 with + type self = t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy = + ShallowModel0.shallow_model self + val shallow_model (self : t) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type + type t + type a + use seq.Seq + type shallowModelTy = + Seq.seq t +end +module Alloc_Vec_Impl1_Len_Interface + type t + type a + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val len [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : usize + ensures { UInt64.to_int result = Seq.length (ShallowModel0.shallow_model self) } + +end +module Alloc_Vec_Impl1_Len + type t + type a + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val len [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : usize + ensures { UInt64.to_int result = Seq.length (ShallowModel0.shallow_model self) } + +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) + val in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) : bool + ensures { result = in_bounds self seq } + +end +module Core_Slice_Index_SliceIndex_Output_Type + type self + type t + type output +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) + val has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) : bool + ensures { result = has_value self seq out } + +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type + type t + use seq.Seq + type shallowModelTy = + Seq.seq t +end +module Alloc_Vec_Impl16_Index_Interface + type t + type i + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) (index : i) : Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) result } + +end +module Alloc_Vec_Impl16_Index + type t + type i + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) (index : i) : Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) result } + +end +module Core_Cmp_Ord_Cmp_Interface + type self + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val cmp [@cfg:stackify] (self : self) (other : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = CmpLog0.cmp_log (DeepModel0.deep_model self) (DeepModel0.deep_model other) } + +end +module Core_Cmp_Ord_Cmp + type self + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val cmp [@cfg:stackify] (self : self) (other : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = CmpLog0.cmp_log (DeepModel0.deep_model self) (DeepModel0.deep_model other) } + +end +module CreusotContracts_Resolve_Resolve_Resolve_Stub + type self + predicate resolve (self : self) +end +module CreusotContracts_Resolve_Resolve_Resolve_Interface + type self + predicate resolve (self : self) +end +module CreusotContracts_Resolve_Resolve_Resolve + type self + predicate resolve (self : self) + val resolve (self : self) : bool + ensures { result = resolve self } + +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub + type self + predicate le_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface + type self + predicate le_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate le_log (self : self) (o : self) = + [#"../src/lib.rs" 380 31 381 26] CmpLog0.cmp_log self o <> Core_Cmp_Ordering_Type.C_Greater + val le_log (self : self) (o : self) : bool + ensures { result = le_log self o } + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () + axiom cmp_le_log_spec : forall x : self, y : self . [#"../src/lib.rs" 382 3 382 53] LeLog0.le_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () + val cmp_le_log (x : self) (y : self) : () + ensures { result = cmp_le_log x y } + + axiom cmp_le_log_spec : forall x : self, y : self . [#"../src/lib.rs" 382 3 382 53] LeLog0.le_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () + axiom cmp_lt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 384 101 385 42] LtLog0.lt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () + val cmp_lt_log (x : self) (y : self) : () + ensures { result = cmp_lt_log x y } + + axiom cmp_lt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 384 101 385 42] LtLog0.lt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub + type self + predicate ge_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface + type self + predicate ge_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate ge_log (self : self) (o : self) = + [#"../src/lib.rs" 386 78 387 16] CmpLog0.cmp_log self o <> Core_Cmp_Ordering_Type.C_Less + val ge_log (self : self) (o : self) : bool + ensures { result = ge_log self o } + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () + axiom cmp_ge_log_spec : forall x : self, y : self . [#"../src/lib.rs" 387 51 388 31] GeLog0.ge_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () + val cmp_ge_log (x : self) (y : self) : () + ensures { result = cmp_ge_log x y } + + axiom cmp_ge_log_spec : forall x : self, y : self . [#"../src/lib.rs" 387 51 388 31] GeLog0.ge_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () + axiom cmp_gt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 392 36 393 18] GtLog0.gt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () + val cmp_gt_log (x : self) (y : self) : () + ensures { result = cmp_gt_log x y } + + axiom cmp_gt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 392 36 393 18] GtLog0.gt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () + axiom refl_spec : forall x : self . [#"../src/lib.rs" 395 43 395 74] CmpLog0.cmp_log x x = Core_Cmp_Ordering_Type.C_Equal +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () + val refl (x : self) : () + ensures { result = refl x } + + axiom refl_spec : forall x : self . [#"../src/lib.rs" 395 43 395 74] CmpLog0.cmp_log x x = Core_Cmp_Ordering_Type.C_Equal +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + axiom trans_spec : forall x : self, y : self, z : self, o : Core_Cmp_Ordering_Type.t_ordering . ([#"../src/lib.rs" 396 42 396 59] CmpLog0.cmp_log x y = o) -> ([#"../src/lib.rs" 397 5 397 22] CmpLog0.cmp_log y z = o) -> ([#"../src/lib.rs" 398 5 399 15] CmpLog0.cmp_log x z = o) +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + val trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + requires {[#"../src/lib.rs" 396 42 396 59] CmpLog0.cmp_log x y = o} + requires {[#"../src/lib.rs" 397 5 397 22] CmpLog0.cmp_log y z = o} + ensures { result = trans x y z o } + + axiom trans_spec : forall x : self, y : self, z : self, o : Core_Cmp_Ordering_Type.t_ordering . ([#"../src/lib.rs" 396 42 396 59] CmpLog0.cmp_log x y = o) -> ([#"../src/lib.rs" 397 5 397 22] CmpLog0.cmp_log y z = o) -> ([#"../src/lib.rs" 398 5 399 15] CmpLog0.cmp_log x z = o) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () + axiom antisym1_spec : forall x : self, y : self . ([#"../src/lib.rs" 400 33 404 13] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) -> ([#"../src/lib.rs" 404 30 405 2] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1 + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () + val antisym1 (x : self) (y : self) : () + requires {[#"../src/lib.rs" 400 33 404 13] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less} + ensures { result = antisym1 x y } + + axiom antisym1_spec : forall x : self, y : self . ([#"../src/lib.rs" 400 33 404 13] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) -> ([#"../src/lib.rs" 404 30 405 2] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () + axiom antisym2_spec : forall x : self, y : self . ([#"../src/lib.rs" 407 5 408 1] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) -> ([#"../src/lib.rs" 411 9 412 4] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2 + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () + val antisym2 (x : self) (y : self) : () + requires {[#"../src/lib.rs" 407 5 408 1] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater} + ensures { result = antisym2 x y } + + axiom antisym2_spec : forall x : self, y : self . ([#"../src/lib.rs" 407 5 408 1] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) -> ([#"../src/lib.rs" 411 9 412 4] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () + axiom eq_cmp_spec : forall x : self, y : self . [#"../src/lib.rs" 413 7 413 52] (x = y) = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Equal) +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () + val eq_cmp (x : self) (y : self) : () + ensures { result = eq_cmp x y } + + axiom eq_cmp_spec : forall x : self, y : self . [#"../src/lib.rs" 413 7 413 52] (x = y) = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Equal) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) = + UInt64.to_int self < Seq.length seq + val in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) : bool + ensures { result = in_bounds self seq } + +end +module CreusotContracts_Std1_Slice_Impl5_HasValue_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) +end +module CreusotContracts_Std1_Slice_Impl5_HasValue_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) +end +module CreusotContracts_Std1_Slice_Impl5_HasValue + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) = + Seq.get seq (UInt64.to_int self) = out + val has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) : bool + ensures { result = has_value self seq out } + +end +module Core_Slice_Index_Impl2_Output_Type + type t + type output = + t +end +module Vecmap_Impl1_FindK_Interface + type k + type v + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val find_k [@cfg:stackify] [#"../src/lib.rs" 347 4 347 53] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Result_Result_Type.t_result usize usize + requires {[#"../src/lib.rs" 333 15 333 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 334 14 337 5] match (result) with + | Core_Result_Result_Type.C_Ok _ -> Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + | Core_Result_Result_Type.C_Err _ -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + end } + ensures { [#"../src/lib.rs" 338 4 338 91] forall i : usize . result = Core_Result_Result_Type.C_Ok i -> Seq.get (KeySeq0.key_seq self) (UInt64.to_int i) = DeepModel0.deep_model key } + ensures { [#"../src/lib.rs" 339 4 340 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i -> j >= UInt64.to_int i /\ j < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 341 4 342 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i /\ j >= 0 /\ j < UInt64.to_int i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 343 14 346 5] match (result) with + | Core_Result_Result_Type.C_Ok idx -> UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + | Core_Result_Result_Type.C_Err idx -> UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + end } + +end +module Vecmap_Impl1_FindK + type k + type v + use mach.int.Int + use prelude.UIntSize + use prelude.Borrow + use prelude.Int8 + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Core_Cmp_Ord_Cmp_Interface as Cmp0 with + type self = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Core_Result_Result_Type as Core_Result_Result_Type + let rec cfg find_k [@cfg:stackify] [#"../src/lib.rs" 347 4 347 53] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Result_Result_Type.t_result usize usize + requires {[#"../src/lib.rs" 333 15 333 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 334 14 337 5] match (result) with + | Core_Result_Result_Type.C_Ok _ -> Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + | Core_Result_Result_Type.C_Err _ -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + end } + ensures { [#"../src/lib.rs" 338 4 338 91] forall i : usize . result = Core_Result_Result_Type.C_Ok i -> Seq.get (KeySeq0.key_seq self) (UInt64.to_int i) = DeepModel0.deep_model key } + ensures { [#"../src/lib.rs" 339 4 340 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i -> j >= UInt64.to_int i /\ j < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 341 4 342 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i /\ j >= 0 /\ j < UInt64.to_int i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 343 14 346 5] match (result) with + | Core_Result_Result_Type.C_Ok idx -> UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + | Core_Result_Result_Type.C_Err idx -> UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + end } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Result_Result_Type.t_result usize usize; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : k; + var size_9 : usize; + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var left_11 : usize; + var right_12 : usize; + var mid_13 : usize; + var _14 : (); + var _22 : (); + var _23 : bool; + var _24 : usize; + var _25 : usize; + var _26 : usize; + var _27 : usize; + var _28 : usize; + var _29 : bool; + var cmp_30 : Core_Cmp_Ordering_Type.t_ordering; + var _31 : k; + var _32 : (k, v); + var _33 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _34 : usize; + var _35 : k; + var _36 : (); + var _37 : int8; + var _38 : usize; + var _39 : usize; + var _40 : (); + var _41 : usize; + var _42 : usize; + var _43 : usize; + var _44 : (); + var _45 : (); + var _46 : (); + var _47 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _10 <- Vecmap_VecMap_Type.vecmap_v self_1; + size_9 <- ([#"../src/lib.rs" 348 23 348 35] Len0.len _10); + goto BB1 + } + BB1 { + left_11 <- ([#"../src/lib.rs" 349 23 349 24] (0 : usize)); + right_12 <- size_9; + goto BB2 + } + BB2 { + invariant size_bounds { [#"../src/lib.rs" 353 33 353 71] UInt64.to_int size_9 >= 0 /\ UInt64.to_int size_9 <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant left_bounds { [#"../src/lib.rs" 354 33 354 71] UInt64.to_int left_11 >= 0 /\ UInt64.to_int left_11 <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant right_bounds { [#"../src/lib.rs" 355 34 355 74] UInt64.to_int right_12 >= 0 /\ UInt64.to_int right_12 <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant mid_bounds { [#"../src/lib.rs" 353 8 353 73] UInt64.to_int left_11 < UInt64.to_int right_12 -> UInt64.to_int left_11 + div (UInt64.to_int size_9) 2 < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant right_gt_mid { [#"../src/lib.rs" 353 8 353 73] UInt64.to_int left_11 < UInt64.to_int right_12 -> UInt64.to_int right_12 > UInt64.to_int left_11 + div (UInt64.to_int size_9) 2 }; + invariant right_geq_key { [#"../src/lib.rs" 353 8 353 73] forall i : int . i >= UInt64.to_int right_12 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self_1) i) (DeepModel0.deep_model key_2) }; + invariant left_lt_key { [#"../src/lib.rs" 353 8 353 73] forall i : int . i >= 0 /\ i < UInt64.to_int left_11 -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self_1) i) (DeepModel0.deep_model key_2) }; + _24 <- left_11; + _25 <- right_12; + _23 <- ([#"../src/lib.rs" 362 14 362 26] _24 < _25); + switch (_23) + | False -> goto BB12 + | True -> goto BB3 + end + } + BB3 { + _26 <- left_11; + _28 <- size_9; + _29 <- ([#"../src/lib.rs" 363 25 363 33] ([#"../src/lib.rs" 363 32 363 33] (2 : usize)) = ([#"../src/lib.rs" 363 25 363 33] (0 : usize))); + assert { [#"../src/lib.rs" 363 25 363 33] not _29 }; + goto BB4 + } + BB4 { + _27 <- ([#"../src/lib.rs" 363 25 363 33] _28 / ([#"../src/lib.rs" 363 32 363 33] (2 : usize))); + mid_13 <- ([#"../src/lib.rs" 363 12 363 33] _26 + _27); + _33 <- Vecmap_VecMap_Type.vecmap_v self_1; + _34 <- mid_13; + _32 <- ([#"../src/lib.rs" 365 22 365 33] Index0.index _33 _34); + goto BB5 + } + BB5 { + _31 <- (let (a, _) = _32 in a); + assume { Resolve0.resolve _32 }; + _35 <- key_2; + cmp_30 <- ([#"../src/lib.rs" 365 22 365 44] Cmp0.cmp _31 _35); + goto BB6 + } + BB6 { + switch (cmp_30) + | Core_Cmp_Ordering_Type.C_Less -> goto BB9 + | Core_Cmp_Ordering_Type.C_Equal -> goto BB7 + | Core_Cmp_Ordering_Type.C_Greater -> goto BB10 + end + } + BB7 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + _41 <- mid_13; + _0 <- Core_Result_Result_Type.C_Ok _41; + goto BB13 + } + BB8 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + absurd + } + BB9 { + _38 <- mid_13; + left_11 <- ([#"../src/lib.rs" 368 34 368 48] _38 + ([#"../src/lib.rs" 368 47 368 48] (1 : usize))); + _36 <- (); + goto BB11 + } + BB10 { + _39 <- mid_13; + right_12 <- _39; + _39 <- any usize; + _36 <- (); + goto BB11 + } + BB11 { + _42 <- right_12; + _43 <- left_11; + size_9 <- ([#"../src/lib.rs" 373 12 373 31] _42 - _43); + _22 <- (); + goto BB2 + } + BB12 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + _14 <- (); + _47 <- left_11; + _0 <- Core_Result_Result_Type.C_Err _47; + goto BB13 + } + BB13 { + return _0 + } + +end +module CreusotContracts_Resolve_Impl1_Resolve_Stub + type t + use prelude.Borrow + predicate resolve (self : borrowed t) +end +module CreusotContracts_Resolve_Impl1_Resolve_Interface + type t + use prelude.Borrow + predicate resolve (self : borrowed t) +end +module CreusotContracts_Resolve_Impl1_Resolve + type t + use prelude.Borrow + predicate resolve (self : borrowed t) = + ^ self = * self + val resolve (self : borrowed t) : bool + ensures { result = resolve self } + +end +module Vecmap_Impl1_Entry_Interface + type k + type v + use prelude.Borrow + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant_Stub as Invariant1 with + type k = k, + type v = v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + use Vecmap_Entry_Type as Vecmap_Entry_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val entry [@cfg:stackify] [#"../src/lib.rs" 82 4 82 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 79 15 79 31] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 80 4 80 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 81 4 81 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + +end +module Vecmap_Impl1_Entry + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_VecMap_Type.t_vecmap k v + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant as Invariant1 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_Entry_Type as Vecmap_Entry_Type + let rec cfg entry [@cfg:stackify] [#"../src/lib.rs" 82 4 82 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 79 15 79 31] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 80 4 80 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 81 4 81 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_Entry_Type.t_entry k v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_2 : k; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : Vecmap_VecMap_Type.t_vecmap k v; + var _8 : k; + var _9 : k; + var _10 : isize; + var index_11 : usize; + var _12 : Vecmap_OccupiedEntry_Type.t_occupiedentry k v; + var _13 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _14 : usize; + var _15 : k; + var index_16 : usize; + var _17 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var _18 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _19 : usize; + var _20 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- * self_1; + _9 <- key_2; + _8 <- _9; + assume { Resolve0.resolve _9 }; + _6 <- ([#"../src/lib.rs" 83 14 83 31] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + switch (_6) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + index_16 <- Core_Result_Result_Type.err_0 _6; + _18 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _18) }; + assume { Resolve1.resolve self_1 }; + _19 <- index_16; + assume { Resolve2.resolve _20 }; + _20 <- key_2; + key_2 <- any k; + _17 <- Vecmap_VacantEntry_Type.C_VacantEntry _18 _20 _19; + goto BB7 + } + BB3 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + absurd + } + BB4 { + index_11 <- Core_Result_Result_Type.ok_0 _6; + _13 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _13) }; + assume { Resolve1.resolve self_1 }; + _14 <- index_11; + assume { Resolve2.resolve _15 }; + _15 <- key_2; + key_2 <- any k; + _12 <- Vecmap_OccupiedEntry_Type.C_OccupiedEntry _13 _15 _14; + goto BB5 + } + BB5 { + _0 <- Vecmap_Entry_Type.C_Occupied _12; + goto BB6 + } + BB6 { + goto BB9 + } + BB7 { + _0 <- Vecmap_Entry_Type.C_Vacant _17; + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + goto BB10 + } + BB10 { + return _0 + } + +end +module Vecmap_KeyRef_Type + use mach.int.Int + use prelude.UIntSize + type t_keyref 'k = + | C_KeyRef 'k usize + + let function keyref_key (self : t_keyref 'k) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_KeyRef a _ -> a + end + let function keyref_min_idx (self : t_keyref 'k) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_KeyRef _ a -> a + end +end +module Core_Option_Option_Type + type t_option 't = + | C_None + | C_Some 't + + let function some_0 (self : t_option 't) : 't = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_None -> any 't + | C_Some a -> a + end +end +module CreusotContracts_Logic_Seq_Impl0_Get_Stub + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t +end +module CreusotContracts_Logic_Seq_Impl0_Get_Interface + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t +end +module CreusotContracts_Logic_Seq_Impl0_Get + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t = + if ix < Seq.length self then Core_Option_Option_Type.C_Some (Seq.get self ix) else Core_Option_Option_Type.C_None + val get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t + ensures { result = get self ix } + +end +module Vecmap_Impl1_IsValidKeyrefLg_Stub + type k + type v + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate is_valid_keyref_lg [#"../src/lib.rs" 284 4 284 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + +end +module Vecmap_Impl1_IsValidKeyrefLg_Interface + type k + type v + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate is_valid_keyref_lg [#"../src/lib.rs" 284 4 284 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + + axiom is_valid_keyref_lg_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v, key : Vecmap_KeyRef_Type.t_keyref k . ([#"../src/lib.rs" 283 15 283 31] IsSorted0.is_sorted self) -> true +end +module Vecmap_Impl1_IsValidKeyrefLg + type k + type v + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + use mach.int.UInt64 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get_Stub as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + predicate is_valid_keyref_lg [#"../src/lib.rs" 284 4 284 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + + = + [#"../src/lib.rs" 286 12 291 13] match (Get0.get (KeySeq0.key_seq self) (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key))) with + | Core_Option_Option_Type.C_Some k -> LeLog0.le_log k (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)) + | _ -> false + end + val is_valid_keyref_lg [#"../src/lib.rs" 284 4 284 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 283 15 283 31] IsSorted0.is_sorted self} + ensures { result = is_valid_keyref_lg self key } + + axiom is_valid_keyref_lg_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v, key : Vecmap_KeyRef_Type.t_keyref k . ([#"../src/lib.rs" 283 15 283 31] IsSorted0.is_sorted self) -> true +end +module Vecmap_Impl1_IsValidKeyrefLg_Impl + type k + type v + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec ghost predicate is_valid_keyref_lg [#"../src/lib.rs" 284 4 284 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + requires {[#"../src/lib.rs" 283 15 283 31] IsSorted0.is_sorted self} + + = [@vc:do_not_keep_trace] [@vc:sp] + [#"../src/lib.rs" 286 12 291 13] match (let a' = KeySeq0.key_seq self in Get0.get a' (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key))) with + | Core_Option_Option_Type.C_Some k -> let b' = DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key) in LeLog0.le_log k b' + | _ -> false + end +end +module Vecmap_Impl10_DeepModel_Stub + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + function deep_model [#"../src/lib.rs" 580 4 580 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + +end +module Vecmap_Impl10_DeepModel_Interface + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + function deep_model [#"../src/lib.rs" 580 4 580 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + +end +module Vecmap_Impl10_DeepModel + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function deep_model [#"../src/lib.rs" 580 4 580 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + + = + [#"../src/lib.rs" 581 19 581 57] (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key self), UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx self)) + val deep_model [#"../src/lib.rs" 580 4 580 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + ensures { result = deep_model self } + +end +module Vecmap_Impl10_DeepModelTy_Type + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + type deepModelTy = + (DeepModelTy0.deepModelTy, int) +end +module CreusotContracts_Model_Impl0_DeepModelTy_Type + type t + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + type deepModelTy = + DeepModelTy0.deepModelTy +end +module Vecmap_Impl12_AsRef_Interface + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy2 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone Vecmap_Impl10_DeepModelTy_Type as DeepModelTy0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = Vecmap_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val as_ref [@cfg:stackify] [#"../src/lib.rs" 598 4 598 38] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 597 14 597 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + +end +module Vecmap_Impl12_AsRef + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy2 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel4 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel3 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone Vecmap_Impl10_DeepModelTy_Type as DeepModelTy0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Vecmap_Impl10_DeepModel as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = Vecmap_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel2.deep_model + let rec cfg as_ref [@cfg:stackify] [#"../src/lib.rs" 598 4 598 38] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 597 14 597 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_KeyRef_Type.t_keyref k; + var _3 : usize; + var _4 : k; + var _5 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _3 <- Vecmap_KeyRef_Type.keyref_min_idx self_1; + _5 <- Vecmap_KeyRef_Type.keyref_key self_1; + assume { Resolve0.resolve self_1 }; + _4 <- _5; + assume { Resolve1.resolve _5 }; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _4 _3; + return _0 + } + +end +module Vecmap_Impl13_ToOwned_Stub + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 609 4 609 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + +end +module Vecmap_Impl13_ToOwned_Interface + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 609 4 609 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + + axiom to_owned_spec : forall self : Vecmap_KeyRef_Type.t_keyref k . [#"../src/lib.rs" 608 14 608 54] DeepModel0.deep_model self = DeepModel1.deep_model (to_owned self) +end +module Vecmap_Impl13_ToOwned + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 609 4 609 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + + = + [#"../src/lib.rs" 610 8 613 9] Vecmap_KeyRef_Type.C_KeyRef (Vecmap_KeyRef_Type.keyref_key self) (Vecmap_KeyRef_Type.keyref_min_idx self) + val to_owned [#"../src/lib.rs" 609 4 609 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { result = to_owned self } + + axiom to_owned_spec : forall self : Vecmap_KeyRef_Type.t_keyref k . [#"../src/lib.rs" 608 14 608 54] DeepModel0.deep_model self = DeepModel1.deep_model (to_owned self) +end +module Vecmap_Impl13_ToOwned_Impl + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel3 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone Vecmap_Impl10_DeepModel as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel2.deep_model + let rec ghost function to_owned [#"../src/lib.rs" 609 4 609 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 608 14 608 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + + = [@vc:do_not_keep_trace] [@vc:sp] + [#"../src/lib.rs" 610 8 613 9] Vecmap_KeyRef_Type.C_KeyRef (Vecmap_KeyRef_Type.keyref_key self) (Vecmap_KeyRef_Type.keyref_min_idx self) +end +module Alloc_Vec_Impl10_Deref_Interface + type t + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t, + type a = a + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val deref [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : seq t + ensures { ShallowModel0.shallow_model result = ShallowModel1.shallow_model self } + +end +module Alloc_Vec_Impl10_Deref + type t + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t, + type a = a + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val deref [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : seq t + ensures { ShallowModel0.shallow_model result = ShallowModel1.shallow_model self } + +end +module Core_Slice_Impl0_Get_Interface + type t + type i + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + type Output0.output = Output0.output + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val get [@cfg:stackify] (self : seq t) (index : i) : Core_Option_Option_Type.t_option Output0.output + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) -> (exists r : Output0.output . result = Core_Option_Option_Type.C_Some r /\ HasValue0.has_value index (ShallowModel0.shallow_model self) r) } + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) \/ result = Core_Option_Option_Type.C_None } + +end +module Core_Slice_Impl0_Get + type t + type i + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + type Output0.output = Output0.output + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val get [@cfg:stackify] (self : seq t) (index : i) : Core_Option_Option_Type.t_option Output0.output + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) -> (exists r : Output0.output . result = Core_Option_Option_Type.C_Some r /\ HasValue0.has_value index (ShallowModel0.shallow_model self) r) } + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) \/ result = Core_Option_Option_Type.C_None } + +end +module Core_Cmp_Impls_Impl10_Le_Interface + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val le [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = LeLog0.le_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_Impls_Impl10_Le + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val le [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = LeLog0.le_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel_Stub + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel_Interface + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t + axiom shallow_model_spec : forall self : seq t . shallow_model self = Slice.id self && Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t + val shallow_model (self : seq t) : Seq.seq t + ensures { result = shallow_model self } + + axiom shallow_model_spec : forall self : seq t . shallow_model self = Slice.id self && Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module Vecmap_Impl1_IsValidKeyref_Interface + type k + type v + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel3 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel3.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone Vecmap_Impl1_IsValidKeyrefLg_Stub as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + axiom . + clone Vecmap_Impl13_ToOwned_Stub as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy1.deepModelTy, + axiom . + val is_valid_keyref [@cfg:stackify] [#"../src/lib.rs" 275 4 275 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 270 15 270 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 271 14 271 66] result = IsValidKeyrefLg0.is_valid_keyref_lg self (ToOwned0.to_owned key) } + ensures { [#"../src/lib.rs" 272 4 272 57] result -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) } + ensures { [#"../src/lib.rs" 273 4 274 57] result -> (forall i : int . i >= 0 /\ i <= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + +end +module Vecmap_Impl1_IsValidKeyref + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use mach.int.UInt64 + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel4 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get1 with + type t = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel3 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone Core_Cmp_Impls_Impl10_Le_Interface as Le0 with + type a = k, + type b = k, + function DeepModel0.deep_model = DeepModel4.deep_model, + function DeepModel1.deep_model = DeepModel4.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = Core_Option_Option_Type.t_option (k, v) + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Core_Slice_Impl0_Get_Interface as Get0 with + type t = (k, v), + type i = usize, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + type Output0.output = Output0.output, + predicate HasValue0.has_value = HasValue0.has_value + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get1.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + let rec cfg is_valid_keyref [@cfg:stackify] [#"../src/lib.rs" 275 4 275 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 270 15 270 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 271 14 271 66] result = IsValidKeyrefLg0.is_valid_keyref_lg self (ToOwned0.to_owned key) } + ensures { [#"../src/lib.rs" 272 4 272 57] result -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) } + ensures { [#"../src/lib.rs" 273 4 274 57] result -> (forall i : int . i >= 0 /\ i <= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : bool; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : Vecmap_KeyRef_Type.t_keyref k; + var _7 : Core_Option_Option_Type.t_option (k, v); + var _8 : seq (k, v); + var _9 : seq (k, v); + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _11 : usize; + var _12 : isize; + var k_13 : k; + var _14 : k; + var _15 : k; + var _16 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _10 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _9 <- ([#"../src/lib.rs" 276 14 276 37] Deref0.deref _10); + goto BB1 + } + BB1 { + _8 <- _9; + assume { Resolve1.resolve _9 }; + _11 <- Vecmap_KeyRef_Type.keyref_min_idx key_2; + _7 <- ([#"../src/lib.rs" 276 14 276 37] Get0.get _8 _11); + goto BB2 + } + BB2 { + switch (_7) + | Core_Option_Option_Type.C_Some _ -> goto BB4 + | _ -> goto BB3 + end + } + BB3 { + assume { Resolve2.resolve key_2 }; + assume { Resolve3.resolve _7 }; + _0 <- ([#"../src/lib.rs" 278 17 278 22] false); + goto BB6 + } + BB4 { + k_13 <- (let (a, _) = Core_Option_Option_Type.some_0 _7 in a); + assume { Resolve3.resolve _7 }; + _14 <- k_13; + assume { Resolve4.resolve k_13 }; + _16 <- Vecmap_KeyRef_Type.keyref_key key_2; + assume { Resolve2.resolve key_2 }; + _15 <- _16; + assume { Resolve4.resolve _16 }; + _0 <- ([#"../src/lib.rs" 277 28 277 40] Le0.le _14 _15); + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Ops_Range_Range_Type + type t_range 'idx = + | C_Range 'idx 'idx + + let function range_end (self : t_range 'idx) : 'idx = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Range _ a -> a + end + let function range_start (self : t_range 'idx) : 'idx = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Range a _ -> a + end +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Stub + type self + predicate into_iter_pre (self : self) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Interface + type self + predicate into_iter_pre (self : self) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre + type self + predicate into_iter_pre (self : self) = + true + val into_iter_pre (self : self) : bool + ensures { result = into_iter_pre self } + +end +module Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type + type self + type intoIter +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Stub + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Interface + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) + val into_iter_post (self : self) (res : IntoIter0.intoIter) : bool + ensures { result = into_iter_post self res } + +end +module CreusotContracts_Invariant_Invariant_Invariant_Stub + type self + predicate invariant' (self : self) +end +module CreusotContracts_Invariant_Invariant_Invariant_Interface + type self + predicate invariant' (self : self) +end +module CreusotContracts_Invariant_Invariant_Invariant + type self + predicate invariant' (self : self) + val invariant' (self : self) : bool + ensures { result = invariant' self } + +end +module Core_Iter_Traits_Collect_Impl0_IntoIter_Type + type i + type intoIter = + i +end +module Core_Iter_Traits_Collect_Impl0_IntoIter_Interface + type i + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter0 with + type i = i + clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with + type self = i + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Stub as IntoIterPost0 with + type self = i, + type IntoIter0.intoIter = IntoIter0.intoIter + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Stub as IntoIterPre0 with + type self = i + val into_iter [@cfg:stackify] (self : i) : i + requires {IntoIterPre0.into_iter_pre self} + ensures { IntoIterPost0.into_iter_post self result } + ensures { Invariant0.invariant' result } + +end +module Core_Iter_Traits_Collect_Impl0_IntoIter + type i + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter0 with + type i = i + clone CreusotContracts_Invariant_Invariant_Invariant_Interface as Invariant0 with + type self = i + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Interface as IntoIterPost0 with + type self = i, + type IntoIter0.intoIter = IntoIter0.intoIter + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Interface as IntoIterPre0 with + type self = i + val into_iter [@cfg:stackify] (self : i) : i + requires {IntoIterPre0.into_iter_pre self} + ensures { IntoIterPost0.into_iter_post self result } + ensures { Invariant0.invariant' result } + +end +module CreusotContracts_Std1_Ops_Impl3_Invariant_Stub + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) +end +module CreusotContracts_Std1_Ops_Impl3_Invariant_Interface + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) +end +module CreusotContracts_Std1_Ops_Impl3_Invariant + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) = + true + val invariant' (self : Core_Ops_Range_Range_Type.t_range idx) : bool + ensures { result = invariant' self } + +end +module CreusotContracts_Std1_Iter_Iterator_Completed_Stub + type self + use prelude.Borrow + predicate completed (self : borrowed self) +end +module CreusotContracts_Std1_Iter_Iterator_Completed_Interface + type self + use prelude.Borrow + predicate completed (self : borrowed self) +end +module CreusotContracts_Std1_Iter_Iterator_Completed + type self + use prelude.Borrow + predicate completed (self : borrowed self) + val completed (self : borrowed self) : bool + ensures { result = completed self } + +end +module Core_Iter_Traits_Iterator_Iterator_Item_Type + type self + type item +end +module CreusotContracts_Std1_Iter_Iterator_Produces_Stub + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) +end +module CreusotContracts_Std1_Iter_Iterator_Produces_Interface + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) +end +module CreusotContracts_Std1_Iter_Iterator_Produces + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) + val produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) : bool + ensures { result = produces self visited _3' } + +end +module Core_Iter_Range_Impl3_Item_Type + type a + type item = + a +end +module Core_Iter_Range_Impl3_Next_Interface + type a + use prelude.Borrow + use seq.Seq + clone Core_Iter_Range_Impl3_Item_Type as Item1 with + type a = a + use Core_Option_Option_Type as Core_Option_Option_Type + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Iterator_Produces_Stub as Produces0 with + type self = Core_Ops_Range_Range_Type.t_range a, + type Item0.item = Item1.item + clone CreusotContracts_Std1_Iter_Iterator_Completed_Stub as Completed0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = a + val next [@cfg:stackify] (self : borrowed (Core_Ops_Range_Range_Type.t_range a)) : Core_Option_Option_Type.t_option a + requires {Invariant0.invariant' ( * self)} + ensures { Invariant0.invariant' ( ^ self) } + ensures { match (result) with + | Core_Option_Option_Type.C_None -> Completed0.completed self + | Core_Option_Option_Type.C_Some v -> Produces0.produces ( * self) (Seq.singleton v) ( ^ self) + end } + +end +module Core_Iter_Range_Impl3_Next + type a + use prelude.Borrow + use seq.Seq + clone Core_Iter_Range_Impl3_Item_Type as Item1 with + type a = a + use Core_Option_Option_Type as Core_Option_Option_Type + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Iterator_Produces_Interface as Produces0 with + type self = Core_Ops_Range_Range_Type.t_range a, + type Item0.item = Item1.item + clone CreusotContracts_Std1_Iter_Iterator_Completed_Interface as Completed0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Interface as Invariant0 with + type idx = a + val next [@cfg:stackify] (self : borrowed (Core_Ops_Range_Range_Type.t_range a)) : Core_Option_Option_Type.t_option a + requires {Invariant0.invariant' ( * self)} + ensures { Invariant0.invariant' ( ^ self) } + ensures { match (result) with + | Core_Option_Option_Type.C_None -> Completed0.completed self + | Core_Option_Option_Type.C_Some v -> Produces0.produces ( * self) (Seq.singleton v) ( ^ self) + end } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = idx, + type DeepModelTy0.deepModelTy = int + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + + = + Core_Ops_Range_Range_Type.range_end self = Core_Ops_Range_Range_Type.range_end o /\ DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) <= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) /\ (Seq.length visited > 0 -> DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) <= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_end o)) /\ Seq.length visited = DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) - DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) /\ (forall i : int . 0 <= i /\ i < Seq.length visited -> DeepModel0.deep_model (Seq.get visited i) = DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) + i) + val produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) : bool + ensures { result = produces self visited o } + +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre_Stub + type i + predicate into_iter_pre (self : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre_Interface + type i + predicate into_iter_pre (self : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre + type i + clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with + type self = i + predicate into_iter_pre (self : i) = + Invariant0.invariant' self + val into_iter_pre (self : i) : bool + ensures { result = into_iter_pre self } + +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost_Stub + type i + predicate into_iter_post (self : i) (res : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost_Interface + type i + predicate into_iter_post (self : i) (res : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost + type i + predicate into_iter_post (self : i) (res : i) = + self = res + val into_iter_post (self : i) (res : i) : bool + ensures { result = into_iter_post self res } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () + axiom produces_refl_spec : forall a : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Produces0.produces a (Seq.empty ) a +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () = + () + val produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () + requires {Invariant0.invariant' a} + ensures { result = produces_refl a } + + axiom produces_refl_spec : forall a : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Produces0.produces a (Seq.empty ) a +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + + axiom produces_trans_spec : forall a : Core_Ops_Range_Range_Type.t_range idx, ab : Seq.seq idx, b : Core_Ops_Range_Range_Type.t_range idx, bc : Seq.seq idx, c : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Invariant0.invariant' b -> Invariant0.invariant' c -> Produces0.produces a ab b -> Produces0.produces b bc c -> Produces0.produces a (Seq.(++) ab bc) c +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + + = + () + val produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + requires {Invariant0.invariant' a} + requires {Invariant0.invariant' b} + requires {Invariant0.invariant' c} + requires {Produces0.produces a ab b} + requires {Produces0.produces b bc c} + ensures { result = produces_trans a ab b bc c } + + axiom produces_trans_spec : forall a : Core_Ops_Range_Range_Type.t_range idx, ab : Seq.seq idx, b : Core_Ops_Range_Range_Type.t_range idx, bc : Seq.seq idx, c : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Invariant0.invariant' b -> Invariant0.invariant' c -> Produces0.produces a ab b -> Produces0.produces b bc c -> Produces0.produces a (Seq.(++) ab bc) c +end +module CreusotContracts_Logic_Int_Impl18_DeepModel_Stub + use mach.int.Int + use prelude.UIntSize + function deep_model (self : usize) : int +end +module CreusotContracts_Logic_Int_Impl18_DeepModel_Interface + use mach.int.Int + use prelude.UIntSize + function deep_model (self : usize) : int +end +module CreusotContracts_Logic_Int_Impl18_DeepModel + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + function deep_model (self : usize) : int = + [#"../src/lib.rs" 319 31 320 0] UInt64.to_int self + val deep_model (self : usize) : int + ensures { result = deep_model self } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed_Stub + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed_Interface + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = idx, + type DeepModelTy0.deepModelTy = int + clone CreusotContracts_Resolve_Impl1_Resolve_Stub as Resolve0 with + type t = Core_Ops_Range_Range_Type.t_range idx + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) = + Resolve0.resolve self /\ DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start ( * self)) >= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_end ( * self)) + val completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) : bool + ensures { result = completed self } + +end +module Vecmap_Impl1_EntryFromRef_Interface + type k + type v + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant_Stub as Invariant1 with + type k = k, + type v = v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + use Vecmap_Entry_Type as Vecmap_Entry_Type + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone Vecmap_Impl1_IsValidKeyrefLg_Stub as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + axiom . + val entry_from_ref [@cfg:stackify] [#"../src/lib.rs" 111 4 111 80] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key_hint : Vecmap_KeyRef_Type.t_keyref k) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 106 15 106 31] IsSorted0.is_sorted ( * self)} + requires {[#"../src/lib.rs" 107 15 107 48] IsValidKeyrefLg0.is_valid_keyref_lg ( * self) key_hint} + requires {[#"../src/lib.rs" 108 15 108 60] LeLog0.le_log (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key_hint)) (DeepModel0.deep_model key)} + ensures { [#"../src/lib.rs" 109 4 109 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 110 4 110 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + +end +module Vecmap_Impl1_EntryFromRef + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.Ghost + use seq.Seq + use prelude.IntSize + use prelude.Int8 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + clone CreusotContracts_Logic_Int_Impl18_DeepModel as DeepModel5 + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with + type t = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Completed as Completed0 with + type idx = usize, + predicate Resolve0.resolve = Resolve3.resolve, + function DeepModel0.deep_model = DeepModel5.deep_model + clone Core_Iter_Range_Impl3_Item_Type as Item0 with + type a = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces as Produces0 with + type idx = usize, + function DeepModel0.deep_model = DeepModel5.deep_model + clone CreusotContracts_Std1_Ops_Impl3_Invariant as Invariant2 with + type idx = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans as ProducesTrans0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl as ProducesRefl0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter1 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPost as IntoIterPost0 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPre as IntoIterPre0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate Invariant0.invariant' = Invariant2.invariant' + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel4 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel3 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone Vecmap_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel4.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + clone Vecmap_Impl10_DeepModelTy_Type as DeepModelTy1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = Vecmap_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Core_Cmp_Ord_Cmp_Interface as Cmp0 with + type self = k, + function DeepModel0.deep_model = DeepModel0.deep_model, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve7 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Core_Iter_Range_Impl3_Next_Interface as Next0 with + type a = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + type Item0.item = Item0.item, + predicate Completed0.completed = Completed0.completed, + predicate Produces0.produces = Produces0.produces + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Interface as IntoIter0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate IntoIterPre0.into_iter_pre = IntoIterPre0.into_iter_pre, + predicate IntoIterPost0.into_iter_post = IntoIterPost0.into_iter_post, + predicate Invariant0.invariant' = Invariant2.invariant' + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get0.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl1_IsValidKeyref_Interface as IsValidKeyref0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ToOwned0.to_owned = ToOwned0.to_owned, + predicate IsValidKeyrefLg0.is_valid_keyref_lg = IsValidKeyrefLg0.is_valid_keyref_lg, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel3.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function DeepModel1.deep_model = DeepModel2.deep_model, + function DeepModel2.deep_model = DeepModel4.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + function DeepModel3.deep_model = DeepModel0.deep_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Vecmap_Impl12_AsRef_Interface as AsRef0 with + type k = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + type DeepModelTy2.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant as Invariant1 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_Entry_Type as Vecmap_Entry_Type + let rec cfg entry_from_ref [@cfg:stackify] [#"../src/lib.rs" 111 4 111 80] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key_hint : Vecmap_KeyRef_Type.t_keyref k) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 106 15 106 31] IsSorted0.is_sorted ( * self)} + requires {[#"../src/lib.rs" 107 15 107 48] IsValidKeyrefLg0.is_valid_keyref_lg ( * self) key_hint} + requires {[#"../src/lib.rs" 108 15 108 60] LeLog0.le_log (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key_hint)) (DeepModel0.deep_model key)} + ensures { [#"../src/lib.rs" 109 4 109 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 110 4 110 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_Entry_Type.t_entry k v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_hint_2 : Vecmap_KeyRef_Type.t_keyref k; + var key_3 : k; + var _9 : (); + var _10 : bool; + var _11 : (); + var _12 : bool; + var _13 : bool; + var _14 : Vecmap_VecMap_Type.t_vecmap k v; + var _15 : Vecmap_KeyRef_Type.t_keyref k; + var _16 : Vecmap_KeyRef_Type.t_keyref k; + var _17 : Vecmap_KeyRef_Type.t_keyref k; + var _18 : Vecmap_KeyRef_Type.t_keyref k; + var _19 : (); + var min_idx_20 : usize; + var _21 : (); + var iter_22 : Core_Ops_Range_Range_Type.t_range usize; + var _23 : Core_Ops_Range_Range_Type.t_range usize; + var _24 : usize; + var _25 : usize; + var _26 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var iter_old_27 : Ghost.ghost_ty (Core_Ops_Range_Range_Type.t_range usize); + var _29 : (); + var produced_30 : Ghost.ghost_ty (Seq.seq usize); + var _33 : (); + var _37 : (); + var _38 : Core_Option_Option_Type.t_option usize; + var _39 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _40 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _41 : isize; + var i_42 : usize; + var _43 : Ghost.ghost_ty (Seq.seq usize); + var _45 : (); + var i_46 : usize; + var _47 : Core_Cmp_Ordering_Type.t_ordering; + var _48 : k; + var _49 : (k, v); + var _50 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _51 : usize; + var _52 : k; + var _53 : k; + var _54 : int8; + var _55 : (); + var _56 : Vecmap_OccupiedEntry_Type.t_occupiedentry k v; + var _57 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _58 : usize; + var _59 : k; + var _60 : (); + var _61 : (); + var _62 : bool; + var _63 : bool; + var _64 : usize; + var _65 : (); + var _66 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var _67 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _68 : usize; + var _69 : k; + var _70 : (); + var i_71 : usize; + var _72 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _73 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var _74 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _75 : usize; + var _76 : k; + { + self_1 <- self; + key_hint_2 <- key_hint; + key_3 <- key; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + _10 <- true; + switch (_10) + | False -> goto BB8 + | True -> goto BB3 + end + } + BB3 { + _14 <- * self_1; + _18 <- key_hint_2; + _17 <- ([#"../src/lib.rs" 112 44 112 61] AsRef0.as_ref _18); + goto BB4 + } + BB4 { + _16 <- _17; + assume { Resolve0.resolve _17 }; + _15 <- _16; + assume { Resolve1.resolve _16 }; + _13 <- ([#"../src/lib.rs" 112 22 112 62] IsValidKeyref0.is_valid_keyref _14 _15); + goto BB5 + } + BB5 { + _12 <- not _13; + switch (_12) + | False -> goto BB7 + | True -> goto BB6 + end + } + BB6 { + assume { Resolve2.resolve self_1 }; + absurd + } + BB7 { + _11 <- (); + _9 <- (); + goto BB9 + } + BB8 { + _9 <- (); + goto BB9 + } + BB9 { + min_idx_20 <- Vecmap_KeyRef_Type.keyref_min_idx key_hint_2; + _24 <- min_idx_20; + _26 <- Vecmap_VecMap_Type.vecmap_v ( * self_1); + _25 <- ([#"../src/lib.rs" 116 26 116 38] Len0.len _26); + goto BB10 + } + BB10 { + _23 <- Core_Ops_Range_Range_Type.C_Range _24 _25; + iter_22 <- ([#"../src/lib.rs" 115 8 115 29] IntoIter0.into_iter _23); + goto BB11 + } + BB11 { + _29 <- (); + iter_old_27 <- ([#"../src/lib.rs" 115 8 115 29] Ghost.new iter_22); + goto BB12 + } + BB12 { + _33 <- (); + produced_30 <- ([#"../src/lib.rs" 115 8 115 29] Ghost.new (Seq.empty )); + goto BB13 + } + BB13 { + goto BB14 + } + BB14 { + invariant type_invariant { [#"../src/lib.rs" 115 8 115 29] Invariant2.invariant' iter_22 }; + invariant structural { [#"../src/lib.rs" 115 8 115 29] Produces0.produces (Ghost.inner iter_old_27) (Ghost.inner produced_30) iter_22 }; + invariant t { [#"../src/lib.rs" 115 23 115 27] true }; + _40 <- borrow_mut iter_22; + iter_22 <- ^ _40; + _39 <- borrow_mut ( * _40); + _40 <- { _40 with current = ( ^ _39) }; + _38 <- ([#"../src/lib.rs" 115 8 115 29] Next0.next _39); + goto BB15 + } + BB15 { + assume { Resolve3.resolve _40 }; + switch (_38) + | Core_Option_Option_Type.C_None -> goto BB16 + | Core_Option_Option_Type.C_Some _ -> goto BB18 + end + } + BB16 { + _21 <- (); + _72 <- Vecmap_VecMap_Type.vecmap_v ( * self_1); + i_71 <- ([#"../src/lib.rs" 136 16 136 28] Len0.len _72); + goto BB31 + } + BB17 { + assume { Resolve2.resolve self_1 }; + assume { Resolve4.resolve key_hint_2 }; + assume { Resolve5.resolve key_3 }; + absurd + } + BB18 { + i_42 <- Core_Option_Option_Type.some_0 _38; + _45 <- (); + _43 <- ([#"../src/lib.rs" 115 8 115 29] Ghost.new (Seq.(++) (Ghost.inner produced_30) (Seq.singleton i_42))); + goto BB19 + } + BB19 { + produced_30 <- _43; + _43 <- any Ghost.ghost_ty (Seq.seq usize); + i_46 <- i_42; + _50 <- Vecmap_VecMap_Type.vecmap_v ( * self_1); + _51 <- i_46; + _49 <- ([#"../src/lib.rs" 117 18 117 27] Index0.index _50 _51); + goto BB20 + } + BB20 { + _48 <- (let (a, _) = _49 in a); + assume { Resolve6.resolve _49 }; + _53 <- key_3; + _52 <- _53; + assume { Resolve7.resolve _53 }; + _47 <- ([#"../src/lib.rs" 117 18 117 39] Cmp0.cmp _48 _52); + goto BB21 + } + BB21 { + switch (_47) + | Core_Cmp_Ordering_Type.C_Equal -> goto BB23 + | Core_Cmp_Ordering_Type.C_Greater -> goto BB26 + | _ -> goto BB22 + end + } + BB22 { + _37 <- (); + goto BB14 + } + BB23 { + _57 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _57) }; + assume { Resolve2.resolve self_1 }; + _58 <- i_46; + assume { Resolve5.resolve _59 }; + _59 <- key_3; + key_3 <- any k; + _56 <- Vecmap_OccupiedEntry_Type.C_OccupiedEntry _57 _59 _58; + goto BB24 + } + BB24 { + _0 <- Vecmap_Entry_Type.C_Occupied _56; + goto BB25 + } + BB25 { + goto BB35 + } + BB26 { + _64 <- i_46; + _63 <- ([#"../src/lib.rs" 126 28 126 34] _64 >= ([#"../src/lib.rs" 126 33 126 34] (1 : usize))); + _62 <- not _63; + switch (_62) + | False -> goto BB28 + | True -> goto BB27 + end + } + BB27 { + assume { Resolve2.resolve self_1 }; + absurd + } + BB28 { + _61 <- (); + _67 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _67) }; + assume { Resolve2.resolve self_1 }; + _68 <- i_46; + assume { Resolve5.resolve _69 }; + _69 <- key_3; + key_3 <- any k; + _66 <- Vecmap_VacantEntry_Type.C_VacantEntry _67 _69 _68; + goto BB29 + } + BB29 { + _0 <- Vecmap_Entry_Type.C_Vacant _66; + goto BB30 + } + BB30 { + goto BB35 + } + BB31 { + _74 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _74) }; + assume { Resolve2.resolve self_1 }; + _75 <- i_71; + assume { Resolve5.resolve _76 }; + _76 <- key_3; + key_3 <- any k; + _73 <- Vecmap_VacantEntry_Type.C_VacantEntry _74 _76 _75; + goto BB32 + } + BB32 { + _0 <- Vecmap_Entry_Type.C_Vacant _73; + goto BB33 + } + BB33 { + goto BB34 + } + BB34 { + goto BB37 + } + BB35 { + goto BB36 + } + BB36 { + goto BB37 + } + BB37 { + assume { Resolve4.resolve key_hint_2 }; + return _0 + } + +end +module Core_Cmp_Impls_Impl10_Ge_Interface + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val ge [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = GeLog0.ge_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_Impls_Impl10_Ge + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val ge [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = GeLog0.ge_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Vecmap_Impl1_FindRandomMappingAfter_Interface + type k + type v + use mach.int.Int + use seq.Seq + use prelude.Borrow + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val find_random_mapping_after [@cfg:stackify] [#"../src/lib.rs" 156 4 156 93] (self : Vecmap_VecMap_Type.t_vecmap k v) (min_key_inclusive : k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 147 15 147 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 148 4 149 66] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive)) } + ensures { [#"../src/lib.rs" 150 4 151 66] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= 0 /\ i < UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 152 4 153 67] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 154 4 155 61] forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping -> (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a))) in a) = (let (_, a) = mapping in a) } + +end +module Vecmap_Impl1_FindRandomMappingAfter + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use prelude.Slice + use seq.Seq + use mach.int.UInt64 + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel2.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = v + clone Core_Cmp_Impls_Impl10_Ge_Interface as Ge0 with + type a = k, + type b = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + predicate GeLog0.ge_log = GeLog0.ge_log, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_Get_Interface as Get0 with + type t = (k, v), + type i = usize, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + type Output0.output = Output0.output, + predicate HasValue0.has_value = HasValue0.has_value + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg find_random_mapping_after [@cfg:stackify] [#"../src/lib.rs" 156 4 156 93] (self : Vecmap_VecMap_Type.t_vecmap k v) (min_key_inclusive : k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 147 15 147 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 148 4 149 66] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive)) } + ensures { [#"../src/lib.rs" 150 4 151 66] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= 0 /\ i < UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 152 4 153 67] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 154 4 155 61] forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping -> (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a))) in a) = (let (_, a) = mapping in a) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v); + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var min_key_inclusive_2 : k; + var _8 : Core_Result_Result_Type.t_result usize usize; + var _9 : Vecmap_VecMap_Type.t_vecmap k v; + var _10 : k; + var _11 : k; + var _12 : isize; + var index_13 : usize; + var key_14 : k; + var value_15 : v; + var _16 : (k, v); + var _17 : (k, v); + var _18 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _19 : usize; + var _20 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _21 : Vecmap_KeyRef_Type.t_keyref k; + var _22 : k; + var _23 : usize; + var _24 : v; + var index_25 : usize; + var _26 : Core_Option_Option_Type.t_option (k, v); + var _27 : seq (k, v); + var _28 : seq (k, v); + var _29 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _30 : usize; + var _31 : isize; + var key_32 : k; + var value_33 : v; + var _34 : (); + var _35 : bool; + var _36 : bool; + var _37 : k; + var _38 : k; + var _39 : k; + var _40 : k; + var _41 : (); + var _42 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _43 : Vecmap_KeyRef_Type.t_keyref k; + var _44 : k; + var _45 : usize; + var _46 : v; + { + self_1 <- self; + min_key_inclusive_2 <- min_key_inclusive; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + _9 <- self_1; + _11 <- min_key_inclusive_2; + _10 <- _11; + assume { Resolve0.resolve _11 }; + _8 <- ([#"../src/lib.rs" 157 14 157 45] FindK0.find_k _9 _10); + goto BB4 + } + BB4 { + switch (_8) + | Core_Result_Result_Type.C_Ok _ -> goto BB7 + | Core_Result_Result_Type.C_Err _ -> goto BB5 + end + } + BB5 { + index_25 <- Core_Result_Result_Type.err_0 _8; + _29 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _28 <- ([#"../src/lib.rs" 168 32 168 49] Deref0.deref _29); + goto BB9 + } + BB6 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve min_key_inclusive_2 }; + absurd + } + BB7 { + index_13 <- Core_Result_Result_Type.ok_0 _8; + _18 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _19 <- index_13; + _17 <- ([#"../src/lib.rs" 159 36 159 49] Index0.index _18 _19); + goto BB8 + } + BB8 { + _16 <- _17; + assume { Resolve6.resolve _17 }; + key_14 <- (let (a, _) = _16 in a); + value_15 <- (let (_, a) = _16 in a); + assume { Resolve6.resolve _16 }; + _22 <- key_14; + assume { Resolve0.resolve key_14 }; + _23 <- index_13; + _21 <- Vecmap_KeyRef_Type.C_KeyRef _22 _23; + _24 <- value_15; + assume { Resolve5.resolve value_15 }; + _20 <- (_21, _24); + _0 <- Core_Option_Option_Type.C_Some _20; + goto BB18 + } + BB9 { + _27 <- _28; + assume { Resolve3.resolve _28 }; + _30 <- index_25; + _26 <- ([#"../src/lib.rs" 168 32 168 49] Get0.get _27 _30); + goto BB10 + } + BB10 { + switch (_26) + | Core_Option_Option_Type.C_None -> goto BB11 + | Core_Option_Option_Type.C_Some _ -> goto BB13 + end + } + BB11 { + assume { Resolve4.resolve _26 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB17 + } + BB12 { + assume { Resolve2.resolve min_key_inclusive_2 }; + assume { Resolve4.resolve _26 }; + absurd + } + BB13 { + key_32 <- (let (a, _) = Core_Option_Option_Type.some_0 _26 in a); + value_33 <- (let (_, a) = Core_Option_Option_Type.some_0 _26 in a); + assume { Resolve4.resolve _26 }; + _37 <- key_32; + _40 <- min_key_inclusive_2; + _39 <- _40; + assume { Resolve0.resolve _40 }; + _38 <- _39; + assume { Resolve0.resolve _39 }; + _36 <- ([#"../src/lib.rs" 170 28 170 53] Ge0.ge _37 _38); + goto BB14 + } + BB14 { + _35 <- not _36; + switch (_35) + | False -> goto BB16 + | True -> goto BB15 + end + } + BB15 { + assume { Resolve0.resolve key_32 }; + assume { Resolve5.resolve value_33 }; + absurd + } + BB16 { + _34 <- (); + _44 <- key_32; + assume { Resolve0.resolve key_32 }; + _45 <- index_25; + _43 <- Vecmap_KeyRef_Type.C_KeyRef _44 _45; + _46 <- value_33; + assume { Resolve5.resolve value_33 }; + _42 <- (_43, _46); + _0 <- Core_Option_Option_Type.C_Some _42; + goto BB17 + } + BB17 { + goto BB18 + } + BB18 { + goto BB19 + } + BB19 { + assume { Resolve2.resolve min_key_inclusive_2 }; + return _0 + } + +end +module CreusotContracts_Model_Impl3_ShallowModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl3_ShallowModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl3_ShallowModel + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + clone CreusotContracts_Model_ShallowModel_ShallowModel_Stub as ShallowModel0 with + type self = t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy = + ShallowModel0.shallow_model ( * self) + val shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module Alloc_Vec_Impl1_Insert_Interface + type t + type a + use prelude.Borrow + use seq.Seq + use mach.int.Int + use mach.int.UInt64 + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + val insert [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) (element : t) : () + ensures { Seq.length (ShallowModel0.shallow_model ( ^ self)) = Seq.length (ShallowModel1.shallow_model self) + 1 } + ensures { forall i : int . 0 <= i /\ i < UInt64.to_int index -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) i } + ensures { Seq.get (ShallowModel0.shallow_model ( ^ self)) (UInt64.to_int index) = element } + ensures { forall i : int . UInt64.to_int index < i /\ i < Seq.length (ShallowModel0.shallow_model ( ^ self)) -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) (i - 1) } + +end +module Alloc_Vec_Impl1_Insert + type t + type a + use prelude.Borrow + use seq.Seq + use mach.int.Int + use mach.int.UInt64 + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel0 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + val insert [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) (element : t) : () + ensures { Seq.length (ShallowModel0.shallow_model ( ^ self)) = Seq.length (ShallowModel1.shallow_model self) + 1 } + ensures { forall i : int . 0 <= i /\ i < UInt64.to_int index -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) i } + ensures { Seq.get (ShallowModel0.shallow_model ( ^ self)) (UInt64.to_int index) = element } + ensures { forall i : int . UInt64.to_int index < i /\ i < Seq.length (ShallowModel0.shallow_model ( ^ self)) -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) (i - 1) } + +end +module Vecmap_Impl1_InsertInternal_Interface + type k + type v + use mach.int.UInt64 + use prelude.Borrow + use seq.Seq + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val insert_internal [@cfg:stackify] [#"../src/lib.rs" 399 4 399 63] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (idx : usize) (key : k) (value : v) : () + requires {[#"../src/lib.rs" 380 15 380 38] UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))} + ensures { [#"../src/lib.rs" 381 14 381 55] Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) + 1 } + ensures { [#"../src/lib.rs" 382 4 382 85] forall i : int . 0 <= i /\ i < UInt64.to_int idx -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i } + ensures { [#"../src/lib.rs" 383 14 383 48] Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) (UInt64.to_int idx) = (key, value) } + ensures { [#"../src/lib.rs" 384 4 384 105] forall i : int . UInt64.to_int idx < i /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i - 1) } + ensures { [#"../src/lib.rs" 385 4 385 80] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) = 0 -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 386 4 390 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx > 0 /\ UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 391 4 394 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = 0 /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 395 4 398 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + +end +module Vecmap_Impl1_InsertInternal + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone Alloc_Vec_Impl1_Insert_Interface as Insert0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function ShallowModel1.shallow_model = ShallowModel1.shallow_model, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg insert_internal [@cfg:stackify] [#"../src/lib.rs" 399 4 399 63] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (idx : usize) (key : k) (value : v) : () + requires {[#"../src/lib.rs" 380 15 380 38] UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))} + ensures { [#"../src/lib.rs" 381 14 381 55] Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) + 1 } + ensures { [#"../src/lib.rs" 382 4 382 85] forall i : int . 0 <= i /\ i < UInt64.to_int idx -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i } + ensures { [#"../src/lib.rs" 383 14 383 48] Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) (UInt64.to_int idx) = (key, value) } + ensures { [#"../src/lib.rs" 384 4 384 105] forall i : int . UInt64.to_int idx < i /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i - 1) } + ensures { [#"../src/lib.rs" 385 4 385 80] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) = 0 -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 386 4 390 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx > 0 /\ UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 391 4 394 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = 0 /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 395 4 398 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var idx_2 : usize; + var key_3 : k; + var value_4 : v; + var _14 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _15 : usize; + var _16 : (k, v); + var _17 : k; + var _18 : v; + { + self_1 <- self; + idx_2 <- idx; + key_3 <- key; + value_4 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + goto BB4 + } + BB4 { + _14 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let Vecmap_VecMap_Type.C_VecMap a = * self_1 in Vecmap_VecMap_Type.C_VecMap ( ^ _14)) }; + _15 <- idx_2; + assume { Resolve0.resolve _17 }; + _17 <- key_3; + key_3 <- any k; + assume { Resolve1.resolve _18 }; + _18 <- value_4; + value_4 <- any v; + _16 <- (_17, _18); + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + _0 <- ([#"../src/lib.rs" 400 8 400 40] Insert0.insert _14 _15 _16); + goto BB7 + } + BB7 { + assume { Resolve2.resolve self_1 }; + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + return _0 + } + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Stub + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Interface + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + + val resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) : bool + ensures { result = resolve_elswhere self old' fin } + +end +module Alloc_Vec_Impl17_IndexMut_Interface + type t + type i + type a + use prelude.Borrow + use seq.Seq + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Stub as ResolveElswhere0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index_mut [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : i) : borrowed Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) ( * result) } + ensures { HasValue0.has_value index (ShallowModel1.shallow_model ( ^ self)) ( ^ result) } + ensures { ResolveElswhere0.resolve_elswhere index (ShallowModel0.shallow_model self) (ShallowModel1.shallow_model ( ^ self)) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) } + +end +module Alloc_Vec_Impl17_IndexMut + type t + type i + type a + use prelude.Borrow + use seq.Seq + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Interface as ResolveElswhere0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index_mut [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : i) : borrowed Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) ( * result) } + ensures { HasValue0.has_value index (ShallowModel1.shallow_model ( ^ self)) ( ^ result) } + ensures { ResolveElswhere0.resolve_elswhere index (ShallowModel0.shallow_model self) (ShallowModel1.shallow_model ( ^ self)) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) } + +end +module Core_Mem_Replace_Interface + type t + use prelude.Borrow + val replace [@cfg:stackify] (dest : borrowed t) (src : t) : t + ensures { ^ dest = src } + ensures { result = * dest } + +end +module Core_Mem_Replace + type t + use prelude.Borrow + val replace [@cfg:stackify] (dest : borrowed t) (src : t) : t + ensures { ^ dest = src } + ensures { result = * dest } + +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) = + forall i : int . 0 <= i /\ i <> UInt64.to_int self /\ i < Seq.length old' -> Seq.get old' i = Seq.get fin i + val resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) : bool + ensures { result = resolve_elswhere self old' fin } + +end +module Vecmap_Impl1_Insert_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val insert [@cfg:stackify] [#"../src/lib.rs" 189 4 189 59] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) (value : v) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 186 4 186 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 186 4 186 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 187 4 188 86] exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (KeySeq0.key_seq ( ^ self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i in a) = value } + +end +module Vecmap_Impl1_Insert + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve5 with + type t = v + clone Core_Mem_Replace_Interface as Replace0 with + type t = v + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve4 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_InsertInternal_Interface as InsertInternal0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_VecMap_Type.t_vecmap k v + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg insert [@cfg:stackify] [#"../src/lib.rs" 189 4 189 59] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) (value : v) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 186 4 186 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 186 4 186 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 187 4 188 86] exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (KeySeq0.key_seq ( ^ self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i in a) = value } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_2 : k; + var value_3 : v; + var _7 : Core_Result_Result_Type.t_result usize usize; + var _8 : Vecmap_VecMap_Type.t_vecmap k v; + var _9 : k; + var _10 : k; + var _11 : isize; + var index_12 : usize; + var _13 : v; + var _14 : borrowed v; + var _15 : borrowed v; + var _16 : borrowed (k, v); + var _17 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _18 : usize; + var _19 : v; + var index_20 : usize; + var _21 : (); + var _22 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _23 : usize; + var _24 : k; + var _25 : v; + { + self_1 <- self; + key_2 <- key; + value_3 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + _8 <- * self_1; + _10 <- key_2; + _9 <- _10; + assume { Resolve0.resolve _10 }; + _7 <- ([#"../src/lib.rs" 190 14 190 31] FindK0.find_k _8 _9); + goto BB2 + } + BB2 { + switch (_7) + | Core_Result_Result_Type.C_Ok _ -> goto BB5 + | Core_Result_Result_Type.C_Err _ -> goto BB3 + end + } + BB3 { + index_20 <- Core_Result_Result_Type.err_0 _7; + _22 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _22) }; + _23 <- index_20; + assume { Resolve2.resolve _24 }; + _24 <- key_2; + key_2 <- any k; + assume { Resolve3.resolve _25 }; + _25 <- value_3; + value_3 <- any v; + _21 <- ([#"../src/lib.rs" 193 16 193 55] InsertInternal0.insert_internal _22 _23 _24 _25); + goto BB9 + } + BB4 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + assume { Resolve3.resolve value_3 }; + absurd + } + BB5 { + index_12 <- Core_Result_Result_Type.ok_0 _7; + _17 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let Vecmap_VecMap_Type.C_VecMap a = * self_1 in Vecmap_VecMap_Type.C_VecMap ( ^ _17)) }; + assume { Resolve1.resolve self_1 }; + _18 <- index_12; + _16 <- ([#"../src/lib.rs" 191 53 191 66] IndexMut0.index_mut _17 _18); + goto BB6 + } + BB6 { + _15 <- borrow_mut (let (_, a) = * _16 in a); + _16 <- { _16 with current = (let (a, b) = * _16 in (a, ^ _15)) }; + assume { Resolve4.resolve _16 }; + _14 <- borrow_mut ( * _15); + _15 <- { _15 with current = ( ^ _14) }; + assume { Resolve3.resolve _19 }; + _19 <- value_3; + value_3 <- any v; + _13 <- ([#"../src/lib.rs" 191 30 191 76] Replace0.replace _14 _19); + goto BB7 + } + BB7 { + assume { Resolve5.resolve _15 }; + _0 <- Core_Option_Option_Type.C_Some _13; + goto BB8 + } + BB8 { + goto BB10 + } + BB9 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB10 + } + BB10 { + goto BB11 + } + BB11 { + goto BB12 + } + BB12 { + return _0 + } + +end +module Alloc_Vec_Impl1_Remove_Interface + type t + type a + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + use seq_ext.SeqExt + use prelude.UIntSize + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val remove [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) : t + requires {UInt64.to_int index < Seq.length (ShallowModel0.shallow_model self)} + ensures { result = Seq.get (ShallowModel0.shallow_model self) (UInt64.to_int index) } + ensures { ShallowModel1.shallow_model ( ^ self) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model self) 0 (UInt64.to_int index)) (SeqExt.subsequence (ShallowModel0.shallow_model self) (UInt64.to_int index + 1) (Seq.length (ShallowModel0.shallow_model self))) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) - 1 } + +end +module Alloc_Vec_Impl1_Remove + type t + type a + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + use seq_ext.SeqExt + use prelude.UIntSize + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val remove [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) : t + requires {UInt64.to_int index < Seq.length (ShallowModel0.shallow_model self)} + ensures { result = Seq.get (ShallowModel0.shallow_model self) (UInt64.to_int index) } + ensures { ShallowModel1.shallow_model ( ^ self) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model self) 0 (UInt64.to_int index)) (SeqExt.subsequence (ShallowModel0.shallow_model self) (UInt64.to_int index + 1) (Seq.length (ShallowModel0.shallow_model self))) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) - 1 } + +end +module CreusotContracts_Resolve_Impl0_Resolve_Stub + type t1 + type t2 + predicate resolve (self : (t1, t2)) +end +module CreusotContracts_Resolve_Impl0_Resolve_Interface + type t1 + type t2 + predicate resolve (self : (t1, t2)) +end +module CreusotContracts_Resolve_Impl0_Resolve + type t1 + type t2 + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve1 with + type self = t2 + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve0 with + type self = t1 + predicate resolve (self : (t1, t2)) = + Resolve0.resolve (let (a, _) = self in a) /\ Resolve1.resolve (let (_, a) = self in a) + val resolve (self : (t1, t2)) : bool + ensures { result = resolve self } + +end +module Vecmap_Impl1_Remove_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + use seq_ext.SeqExt + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val remove [@cfg:stackify] [#"../src/lib.rs" 211 4 211 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 201 4 201 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 201 4 201 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 202 4 204 30] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq ( * self)) (DeepModel0.deep_model key) /\ * self = ^ self } + ensures { [#"../src/lib.rs" 205 4 210 17] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) -> Seq.get (KeySeq0.key_seq ( * self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i in a) = v /\ ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self)) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) 0 i) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i + 1) (Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))))) } + +end +module Vecmap_Impl1_Remove + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + use seq_ext.SeqExt + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = v + clone CreusotContracts_Resolve_Impl0_Resolve as Resolve3 with + type t1 = k, + type t2 = v, + predicate Resolve0.resolve = Resolve4.resolve, + predicate Resolve1.resolve = Resolve2.resolve + clone Alloc_Vec_Impl1_Remove_Interface as Remove0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg remove [@cfg:stackify] [#"../src/lib.rs" 211 4 211 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 201 4 201 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 201 4 201 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 202 4 204 30] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq ( * self)) (DeepModel0.deep_model key) /\ * self = ^ self } + ensures { [#"../src/lib.rs" 205 4 210 17] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) -> Seq.get (KeySeq0.key_seq ( * self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i in a) = v /\ ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self)) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) 0 i) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i + 1) (Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_2 : k; + var _7 : Core_Result_Result_Type.t_result usize usize; + var _8 : Vecmap_VecMap_Type.t_vecmap k v; + var _9 : k; + var _10 : isize; + var index_11 : usize; + var _12 : v; + var _13 : (k, v); + var _14 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _15 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _8 <- * self_1; + _9 <- key_2; + assume { Resolve0.resolve key_2 }; + _7 <- ([#"../src/lib.rs" 212 14 212 30] FindK0.find_k _8 _9); + goto BB1 + } + BB1 { + switch (_7) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB8 + } + BB3 { + assume { Resolve1.resolve self_1 }; + absurd + } + BB4 { + index_11 <- Core_Result_Result_Type.ok_0 _7; + _14 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let Vecmap_VecMap_Type.C_VecMap a = * self_1 in Vecmap_VecMap_Type.C_VecMap ( ^ _14)) }; + _15 <- index_11; + _13 <- ([#"../src/lib.rs" 213 30 213 50] Remove0.remove _14 _15); + goto BB5 + } + BB5 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve _12 }; + _12 <- (let (_, a) = _13 in a); + _13 <- (let (a, b) = _13 in (a, any v)); + _0 <- Core_Option_Option_Type.C_Some _12; + goto BB6 + } + BB6 { + goto BB7 + } + BB7 { + assume { Resolve3.resolve _13 }; + goto BB8 + } + BB8 { + return _0 + } + +end +module Vecmap_Impl1_Get_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val get [@cfg:stackify] [#"../src/lib.rs" 224 4 224 44] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 219 15 219 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 220 4 220 77] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 221 4 223 77] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = v) } + +end +module Vecmap_Impl1_Get + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg get [@cfg:stackify] [#"../src/lib.rs" 224 4 224 44] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 219 15 219 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 220 4 220 77] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 221 4 223 77] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = v) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : k; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : Vecmap_VecMap_Type.t_vecmap k v; + var _8 : k; + var _9 : isize; + var index_10 : usize; + var _11 : v; + var _12 : v; + var _13 : (k, v); + var _14 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _15 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- self_1; + _8 <- key_2; + assume { Resolve0.resolve key_2 }; + _6 <- ([#"../src/lib.rs" 225 14 225 30] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + switch (_6) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB3 { + assume { Resolve1.resolve self_1 }; + absurd + } + BB4 { + index_10 <- Core_Result_Result_Type.ok_0 _6; + _14 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _15 <- index_10; + _13 <- ([#"../src/lib.rs" 226 31 226 44] Index0.index _14 _15); + goto BB5 + } + BB5 { + _12 <- (let (_, a) = _13 in a); + assume { Resolve2.resolve _13 }; + _11 <- _12; + assume { Resolve3.resolve _12 }; + _0 <- Core_Option_Option_Type.C_Some _11; + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Result_Impl0_IsOk_Interface + type t + type e + use prelude.Borrow + use Core_Result_Result_Type as Core_Result_Result_Type + val is_ok [@cfg:stackify] (self : Core_Result_Result_Type.t_result t e) : bool + ensures { result = (exists t : t . self = Core_Result_Result_Type.C_Ok t) } + +end +module Core_Result_Impl0_IsOk + type t + type e + use prelude.Borrow + use Core_Result_Result_Type as Core_Result_Result_Type + val is_ok [@cfg:stackify] (self : Core_Result_Result_Type.t_result t e) : bool + ensures { result = (exists t : t . self = Core_Result_Result_Type.C_Ok t) } + +end +module Vecmap_Impl1_ContainsKey_Interface + type k + type v + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val contains_key [@cfg:stackify] [#"../src/lib.rs" 234 4 234 47] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : bool + requires {[#"../src/lib.rs" 232 15 232 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 233 14 233 65] result = Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + +end +module Vecmap_Impl1_ContainsKey + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Core_Result_Impl0_IsOk_Interface as IsOk0 with + type t = usize, + type e = usize + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + let rec cfg contains_key [@cfg:stackify] [#"../src/lib.rs" 234 4 234 47] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : bool + requires {[#"../src/lib.rs" 232 15 232 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 233 14 233 65] result = Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : bool; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : k; + var _5 : Core_Result_Result_Type.t_result usize usize; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : Vecmap_VecMap_Type.t_vecmap k v; + var _8 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- self_1; + assume { Resolve0.resolve self_1 }; + _8 <- key_2; + assume { Resolve1.resolve key_2 }; + _6 <- ([#"../src/lib.rs" 235 8 235 24] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + _5 <- _6; + _0 <- ([#"../src/lib.rs" 235 8 235 32] IsOk0.is_ok _5); + goto BB2 + } + BB2 { + return _0 + } + +end +module Core_Cmp_PartialOrd_Gt_Interface + type self + type rhs + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = rhs, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val gt [@cfg:stackify] (self : self) (other : rhs) : bool + ensures { result = GtLog0.gt_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_PartialOrd_Gt + type self + type rhs + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = rhs, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val gt [@cfg:stackify] (self : self) (other : rhs) : bool + ensures { result = GtLog0.gt_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Vecmap_Impl1_NextMapping_Interface + type k + type v + use mach.int.Int + use seq.Seq + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val next_mapping [@cfg:stackify] [#"../src/lib.rs" 252 4 252 75] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 240 15 240 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 241 4 243 57] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + ensures { [#"../src/lib.rs" 244 4 251 57] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)) /\ GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)) /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = (let (_, a) = entry in a) /\ (forall j : int . j >= 0 /\ j < i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a))) /\ LeLog0.le_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)))) } + +end +module Vecmap_Impl1_NextMapping + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.Ghost + use seq.Seq + use prelude.IntSize + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + clone CreusotContracts_Logic_Int_Impl18_DeepModel as DeepModel4 + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Completed as Completed0 with + type idx = usize, + predicate Resolve0.resolve = Resolve1.resolve, + function DeepModel0.deep_model = DeepModel4.deep_model + clone Core_Iter_Range_Impl3_Item_Type as Item0 with + type a = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces as Produces0 with + type idx = usize, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Std1_Ops_Impl3_Invariant as Invariant0 with + type idx = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans as ProducesTrans0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl as ProducesRefl0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter1 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPost as IntoIterPost0 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPre as IntoIterPre0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate Invariant0.invariant' = Invariant0.invariant' + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl10_DeepModel as DeepModel3 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get0.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = k + clone Core_Cmp_PartialOrd_Gt_Interface as Gt0 with + type self = k, + type rhs = k, + function DeepModel0.deep_model = DeepModel0.deep_model, + function DeepModel1.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Core_Iter_Range_Impl3_Next_Interface as Next0 with + type a = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + type Item0.item = Item0.item, + predicate Completed0.completed = Completed0.completed, + predicate Produces0.produces = Produces0.produces + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Interface as IntoIter0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate IntoIterPre0.into_iter_pre = IntoIterPre0.into_iter_pre, + predicate IntoIterPost0.into_iter_post = IntoIterPost0.into_iter_post, + predicate Invariant0.invariant' = Invariant0.invariant' + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone Vecmap_Impl1_IsValidKeyref_Interface as IsValidKeyref0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ToOwned0.to_owned = ToOwned0.to_owned, + predicate IsValidKeyrefLg0.is_valid_keyref_lg = IsValidKeyrefLg0.is_valid_keyref_lg, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function DeepModel1.deep_model = DeepModel2.deep_model, + function DeepModel2.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + function DeepModel3.deep_model = DeepModel1.deep_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + let rec cfg next_mapping [@cfg:stackify] [#"../src/lib.rs" 252 4 252 75] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 240 15 240 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 241 4 243 57] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + ensures { [#"../src/lib.rs" 244 4 251 57] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)) /\ GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)) /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = (let (_, a) = entry in a) /\ (forall j : int . j >= 0 /\ j < i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a))) /\ LeLog0.le_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v); + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : Vecmap_KeyRef_Type.t_keyref k; + var from_6 : usize; + var _7 : bool; + var _8 : Vecmap_VecMap_Type.t_vecmap k v; + var _9 : Vecmap_KeyRef_Type.t_keyref k; + var _10 : Vecmap_KeyRef_Type.t_keyref k; + var _11 : (); + var iter_12 : Core_Ops_Range_Range_Type.t_range usize; + var _13 : Core_Ops_Range_Range_Type.t_range usize; + var _14 : usize; + var _15 : usize; + var _16 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var iter_old_17 : Ghost.ghost_ty (Core_Ops_Range_Range_Type.t_range usize); + var _19 : (); + var produced_20 : Ghost.ghost_ty (Seq.seq usize); + var _23 : (); + var _27 : (); + var _28 : Core_Option_Option_Type.t_option usize; + var _29 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _30 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _31 : isize; + var i_32 : usize; + var _33 : Ghost.ghost_ty (Seq.seq usize); + var _35 : (); + var idx_36 : usize; + var _37 : bool; + var _38 : k; + var _39 : (k, v); + var _40 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _41 : usize; + var _42 : k; + var _43 : (); + var key_44 : k; + var value_45 : v; + var _46 : (k, v); + var _47 : (k, v); + var _48 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _49 : usize; + var _50 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _51 : Vecmap_KeyRef_Type.t_keyref k; + var _52 : usize; + var _53 : k; + var _54 : v; + var _55 : (); + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _8 <- self_1; + _10 <- key_2; + _9 <- _10; + assume { Resolve0.resolve _10 }; + _7 <- ([#"../src/lib.rs" 253 22 253 48] IsValidKeyref0.is_valid_keyref _8 _9); + goto BB1 + } + BB1 { + switch (_7) + | False -> goto BB3 + | True -> goto BB2 + end + } + BB2 { + from_6 <- Vecmap_KeyRef_Type.keyref_min_idx key_2; + goto BB4 + } + BB3 { + from_6 <- ([#"../src/lib.rs" 256 12 256 13] (0 : usize)); + goto BB4 + } + BB4 { + _14 <- from_6; + _16 <- Vecmap_VecMap_Type.vecmap_v self_1; + _15 <- ([#"../src/lib.rs" 261 25 261 37] Len0.len _16); + goto BB5 + } + BB5 { + _13 <- Core_Ops_Range_Range_Type.C_Range _14 _15; + iter_12 <- ([#"../src/lib.rs" 259 8 260 63] IntoIter0.into_iter _13); + goto BB6 + } + BB6 { + _19 <- (); + iter_old_17 <- ([#"../src/lib.rs" 259 8 260 63] Ghost.new iter_12); + goto BB7 + } + BB7 { + _23 <- (); + produced_20 <- ([#"../src/lib.rs" 259 8 260 63] Ghost.new (Seq.empty )); + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + invariant type_invariant { [#"../src/lib.rs" 259 8 260 63] Invariant0.invariant' iter_12 }; + invariant structural { [#"../src/lib.rs" 259 8 260 63] Produces0.produces (Ghost.inner iter_old_17) (Ghost.inner produced_20) iter_12 }; + invariant prev_leq { [#"../src/lib.rs" 259 8 260 63] forall j : int . j >= 0 /\ j < Seq.length (Ghost.inner produced_20) + UInt64.to_int from_6 -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self_1) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key_2)) }; + _30 <- borrow_mut iter_12; + iter_12 <- ^ _30; + _29 <- borrow_mut ( * _30); + _30 <- { _30 with current = ( ^ _29) }; + _28 <- ([#"../src/lib.rs" 259 8 260 63] Next0.next _29); + goto BB10 + } + BB10 { + assume { Resolve1.resolve _30 }; + switch (_28) + | Core_Option_Option_Type.C_None -> goto BB11 + | Core_Option_Option_Type.C_Some _ -> goto BB13 + end + } + BB11 { + assume { Resolve2.resolve self_1 }; + assume { Resolve3.resolve key_2 }; + _11 <- (); + _0 <- Core_Option_Option_Type.C_None; + goto BB20 + } + BB12 { + assume { Resolve2.resolve self_1 }; + assume { Resolve3.resolve key_2 }; + absurd + } + BB13 { + i_32 <- Core_Option_Option_Type.some_0 _28; + _35 <- (); + _33 <- ([#"../src/lib.rs" 259 8 260 63] Ghost.new (Seq.(++) (Ghost.inner produced_20) (Seq.singleton i_32))); + goto BB14 + } + BB14 { + produced_20 <- _33; + _33 <- any Ghost.ghost_ty (Seq.seq usize); + idx_36 <- i_32; + _40 <- Vecmap_VecMap_Type.vecmap_v self_1; + _41 <- idx_36; + _39 <- ([#"../src/lib.rs" 262 15 262 26] Index0.index _40 _41); + goto BB15 + } + BB15 { + _38 <- (let (a, _) = _39 in a); + assume { Resolve4.resolve _39 }; + _42 <- Vecmap_KeyRef_Type.keyref_key key_2; + _37 <- ([#"../src/lib.rs" 262 15 262 39] Gt0.gt _38 _42); + goto BB16 + } + BB16 { + switch (_37) + | False -> goto BB19 + | True -> goto BB17 + end + } + BB17 { + assume { Resolve3.resolve key_2 }; + _48 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve2.resolve self_1 }; + _49 <- idx_36; + _47 <- ([#"../src/lib.rs" 263 36 263 47] Index0.index _48 _49); + goto BB18 + } + BB18 { + _46 <- _47; + assume { Resolve4.resolve _47 }; + key_44 <- (let (a, _) = _46 in a); + value_45 <- (let (_, a) = _46 in a); + assume { Resolve4.resolve _46 }; + _52 <- idx_36; + _53 <- key_44; + assume { Resolve5.resolve key_44 }; + _51 <- Vecmap_KeyRef_Type.C_KeyRef _53 _52; + _54 <- value_45; + assume { Resolve6.resolve value_45 }; + _50 <- (_51, _54); + _0 <- Core_Option_Option_Type.C_Some _50; + goto BB20 + } + BB19 { + _27 <- (); + goto BB9 + } + BB20 { + return _0 + } + +end +module Core_Slice_Impl0_First_Interface + type t + use seq.Seq + use prelude.Borrow + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val first [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) 0 = x } + +end +module Core_Slice_Impl0_First + type t + use seq.Seq + use prelude.Borrow + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val first [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) 0 = x } + +end +module Vecmap_Impl1_MinEntry_Interface + type k + type v + use seq.Seq + use prelude.Borrow + use mach.int.UInt64 + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val min_entry [@cfg:stackify] [#"../src/lib.rs" 309 4 309 55] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 302 15 302 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 303 4 303 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 304 4 304 101] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) 0 = (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a), let (_, a) = entry in a) } + ensures { [#"../src/lib.rs" 305 4 305 80] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = entry in a)) = 0 } + ensures { [#"../src/lib.rs" 306 4 308 6] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)))) } + +end +module Vecmap_Impl1_MinEntry + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.IntSize + use mach.int.UInt64 + use prelude.UIntSize + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_First_Interface as First0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg min_entry [@cfg:stackify] [#"../src/lib.rs" 309 4 309 55] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 302 15 302 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 303 4 303 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 304 4 304 101] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) 0 = (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a), let (_, a) = entry in a) } + ensures { [#"../src/lib.rs" 305 4 305 80] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = entry in a)) = 0 } + ensures { [#"../src/lib.rs" 306 4 308 6] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v); + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var _7 : Core_Option_Option_Type.t_option (k, v); + var _8 : seq (k, v); + var _9 : seq (k, v); + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _11 : isize; + var key_12 : k; + var value_13 : v; + var _14 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _15 : Vecmap_KeyRef_Type.t_keyref k; + var _16 : k; + var _17 : v; + { + self_1 <- self; + goto BB0 + } + BB0 { + _10 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _9 <- ([#"../src/lib.rs" 310 14 310 28] Deref0.deref _10); + goto BB1 + } + BB1 { + _8 <- _9; + assume { Resolve1.resolve _9 }; + _7 <- ([#"../src/lib.rs" 310 14 310 28] First0.first _8); + goto BB2 + } + BB2 { + switch (_7) + | Core_Option_Option_Type.C_None -> goto BB3 + | Core_Option_Option_Type.C_Some _ -> goto BB5 + end + } + BB3 { + assume { Resolve2.resolve _7 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB4 { + assume { Resolve2.resolve _7 }; + absurd + } + BB5 { + key_12 <- (let (a, _) = Core_Option_Option_Type.some_0 _7 in a); + value_13 <- (let (_, a) = Core_Option_Option_Type.some_0 _7 in a); + assume { Resolve2.resolve _7 }; + _16 <- key_12; + assume { Resolve3.resolve key_12 }; + _15 <- Vecmap_KeyRef_Type.C_KeyRef _16 ([#"../src/lib.rs" 311 63 311 64] (0 : usize)); + _17 <- value_13; + assume { Resolve4.resolve value_13 }; + _14 <- (_15, _17); + _0 <- Core_Option_Option_Type.C_Some _14; + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Slice_Impl0_Last_Interface + type t + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val last [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) (Seq.length (ShallowModel0.shallow_model self) - 1) = x } + +end +module Core_Slice_Impl0_Last + type t + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val last [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) (Seq.length (ShallowModel0.shallow_model self) - 1) = x } + +end +module Vecmap_Impl1_MaxKey_Interface + type k + type v + use seq.Seq + use prelude.Borrow + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val max_key [@cfg:stackify] [#"../src/lib.rs" 323 4 323 39] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option k + requires {[#"../src/lib.rs" 317 15 317 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 318 4 318 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 319 4 322 6] forall k : k . result = Core_Option_Option_Type.C_Some k -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model k)) } + +end +module Vecmap_Impl1_MaxKey + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.IntSize + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = (k, v) + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_Last_Interface as Last0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg max_key [@cfg:stackify] [#"../src/lib.rs" 323 4 323 39] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option k + requires {[#"../src/lib.rs" 317 15 317 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 318 4 318 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 319 4 322 6] forall k : k . result = Core_Option_Option_Type.C_Some k -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model k)) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option k; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var _5 : Core_Option_Option_Type.t_option (k, v); + var _6 : seq (k, v); + var _7 : seq (k, v); + var _8 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _9 : isize; + var e_10 : (k, v); + var _11 : k; + var _12 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _8 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _7 <- ([#"../src/lib.rs" 324 14 324 27] Deref0.deref _8); + goto BB1 + } + BB1 { + _6 <- _7; + assume { Resolve1.resolve _7 }; + _5 <- ([#"../src/lib.rs" 324 14 324 27] Last0.last _6); + goto BB2 + } + BB2 { + switch (_5) + | Core_Option_Option_Type.C_None -> goto BB3 + | Core_Option_Option_Type.C_Some _ -> goto BB5 + end + } + BB3 { + assume { Resolve2.resolve _5 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB4 { + assume { Resolve2.resolve _5 }; + absurd + } + BB5 { + assume { Resolve3.resolve e_10 }; + e_10 <- Core_Option_Option_Type.some_0 _5; + assume { Resolve2.resolve _5 }; + _12 <- (let (a, _) = e_10 in a); + assume { Resolve3.resolve e_10 }; + _11 <- _12; + assume { Resolve4.resolve _12 }; + _0 <- Core_Option_Option_Type.C_Some _11; + goto BB6 + } + BB6 { + return _0 + } + +end +module Alloc_Vec_Impl14_Clone_Interface + type t + type a + use prelude.Borrow + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + val clone' [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : Alloc_Vec_Vec_Type.t_vec t a + ensures { result = self } + +end +module Alloc_Vec_Impl14_Clone + type t + type a + use prelude.Borrow + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + val clone' [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : Alloc_Vec_Vec_Type.t_vec t a + ensures { result = self } + +end +module Vecmap_Impl2_Clone_Interface + type k + type v + use prelude.Borrow + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + val clone' [@cfg:stackify] [#"../src/lib.rs" 406 4 406 27] (self : Vecmap_VecMap_Type.t_vecmap k v) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 405 14 405 29] result = self } + +end +module Vecmap_Impl2_Clone + type k + type v + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Alloc_Vec_Impl14_Clone_Interface as Clone0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + let rec cfg clone' [@cfg:stackify] [#"../src/lib.rs" 406 4 406 27] (self : Vecmap_VecMap_Type.t_vecmap k v) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 405 14 405 29] result = self } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_VecMap_Type.t_vecmap k v; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var _3 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _4 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + self_1 <- self; + goto BB0 + } + BB0 { + _4 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _3 <- ([#"../src/lib.rs" 407 20 407 34] Clone0.clone' _4); + goto BB1 + } + BB1 { + _0 <- Vecmap_VecMap_Type.C_VecMap _3; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl4_IsDefault_Stub + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_default [#"../src/lib.rs" 430 4 430 31] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl4_IsDefault_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_default [#"../src/lib.rs" 430 4 430 31] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl4_IsDefault + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + predicate is_default [#"../src/lib.rs" 430 4 430 31] (self : Vecmap_VecMap_Type.t_vecmap k v) = + [#"../src/lib.rs" 431 20 431 40] Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 + val is_default [#"../src/lib.rs" 430 4 430 31] (self : Vecmap_VecMap_Type.t_vecmap k v) : bool + ensures { result = is_default self } + +end +module Vecmap_Impl3_Default_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl4_IsDefault_Stub as IsDefault0 with + type k = k, + type v = v + val default [@cfg:stackify] [#"../src/lib.rs" 420 4 420 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 419 14 419 33] IsDefault0.is_default result } + +end +module Vecmap_Impl3_Default + type k + type v + clone Core_Num_Impl12_Max as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Alloc_Vec_Impl0_New_Interface as New0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl4_IsDefault as IsDefault0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + let rec cfg default [@cfg:stackify] [#"../src/lib.rs" 420 4 420 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 419 14 419 33] IsDefault0.is_default result } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_VecMap_Type.t_vecmap k v; + var _2 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + goto BB0 + } + BB0 { + _2 <- ([#"../src/lib.rs" 421 18 421 28] New0.new ()); + goto BB1 + } + BB1 { + _0 <- Vecmap_VecMap_Type.C_VecMap _2; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl5_Keyref_Interface + type k + type v + use prelude.Borrow + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use Vecmap_Entry_Type as Vecmap_Entry_Type + val keyref [@cfg:stackify] [#"../src/lib.rs" 476 4 476 38] (self : Vecmap_Entry_Type.t_entry k v) : Vecmap_KeyRef_Type.t_keyref k + requires {[#"../src/lib.rs" 472 15 475 5] match (self) with + | Vecmap_Entry_Type.C_Vacant (Vecmap_VacantEntry_Type.C_VacantEntry map _ _) -> IsSorted0.is_sorted ( * map) + | Vecmap_Entry_Type.C_Occupied (Vecmap_OccupiedEntry_Type.C_OccupiedEntry map _ _) -> IsSorted0.is_sorted ( * map) + end} + +end +module Vecmap_Impl5_Keyref + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.IntSize + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + use Vecmap_Entry_Type as Vecmap_Entry_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_Entry_Type.t_entry k v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg keyref [@cfg:stackify] [#"../src/lib.rs" 476 4 476 38] (self : Vecmap_Entry_Type.t_entry k v) : Vecmap_KeyRef_Type.t_keyref k + requires {[#"../src/lib.rs" 472 15 475 5] match (self) with + | Vecmap_Entry_Type.C_Vacant (Vecmap_VacantEntry_Type.C_VacantEntry map _ _) -> IsSorted0.is_sorted ( * map) + | Vecmap_Entry_Type.C_Occupied (Vecmap_OccupiedEntry_Type.C_OccupiedEntry map _ _) -> IsSorted0.is_sorted ( * map) + end} + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_Entry_Type.t_entry k v; + var _3 : isize; + var key_4 : k; + var index_5 : usize; + var _6 : usize; + var _7 : k; + var key_8 : k; + var index_9 : usize; + var _10 : usize; + var _11 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + switch (self_1) + | Vecmap_Entry_Type.C_Vacant _ -> goto BB3 + | Vecmap_Entry_Type.C_Occupied _ -> goto BB1 + end + } + BB1 { + key_8 <- Vecmap_OccupiedEntry_Type.occupiedentry_key (Vecmap_Entry_Type.occupied_0 self_1); + index_9 <- Vecmap_OccupiedEntry_Type.occupiedentry_index (Vecmap_Entry_Type.occupied_0 self_1); + assume { Resolve0.resolve self_1 }; + _10 <- index_9; + _11 <- key_8; + assume { Resolve1.resolve key_8 }; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _11 _10; + goto BB4 + } + BB2 { + assume { Resolve0.resolve self_1 }; + absurd + } + BB3 { + key_4 <- Vecmap_VacantEntry_Type.vacantentry_key (Vecmap_Entry_Type.vacant_0 self_1); + index_5 <- Vecmap_VacantEntry_Type.vacantentry_index (Vecmap_Entry_Type.vacant_0 self_1); + assume { Resolve0.resolve self_1 }; + _6 <- index_5; + _7 <- key_4; + assume { Resolve1.resolve key_4 }; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _7 _6; + goto BB4 + } + BB4 { + return _0 + } + +end +module Vecmap_Impl15_Resolve_Stub + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate resolve [#"../src/lib.rs" 496 4 496 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl15_Resolve_Interface + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate resolve [#"../src/lib.rs" 496 4 496 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl15_Resolve + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve_Stub as Resolve0 with + type t = Vecmap_VecMap_Type.t_vecmap k v + predicate resolve [#"../src/lib.rs" 496 4 496 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) = + [#"../src/lib.rs" 495 4 495 16] Resolve0.resolve (Vecmap_VacantEntry_Type.vacantentry_map self) /\ Resolve1.resolve (Vecmap_VacantEntry_Type.vacantentry_key self) + val resolve [#"../src/lib.rs" 496 4 496 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) : bool + ensures { result = resolve self } + +end +module Vecmap_Impl7_Insert_Interface + type k + type v + use mach.int.Int + use mach.int.UInt64 + use prelude.Borrow + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val insert [@cfg:stackify] [#"../src/lib.rs" 526 4 526 33] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) (value : v) : () + requires {[#"../src/lib.rs" 520 15 520 31] Invariant0.invariant' self} + requires {[#"../src/lib.rs" 521 4 522 62] forall i : int . i >= 0 /\ i < UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + requires {[#"../src/lib.rs" 523 4 524 62] forall i : int . i >= UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_VacantEntry_Type.vacantentry_map self))) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + ensures { [#"../src/lib.rs" 525 14 525 37] IsSorted0.is_sorted ( ^ Vecmap_VacantEntry_Type.vacantentry_map self) } + +end +module Vecmap_Impl7_Insert + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl15_Resolve as Resolve2 with + type k = k, + type v = v, + predicate Resolve0.resolve = Resolve3.resolve, + predicate Resolve1.resolve = Resolve0.resolve + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_InsertInternal_Interface as InsertInternal0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = v + clone Vecmap_Impl6_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + let rec cfg insert [@cfg:stackify] [#"../src/lib.rs" 526 4 526 33] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) (value : v) : () + requires {[#"../src/lib.rs" 520 15 520 31] Invariant0.invariant' self} + requires {[#"../src/lib.rs" 521 4 522 62] forall i : int . i >= 0 /\ i < UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + requires {[#"../src/lib.rs" 523 4 524 62] forall i : int . i >= UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_VacantEntry_Type.vacantentry_map self))) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + ensures { [#"../src/lib.rs" 525 14 525 37] IsSorted0.is_sorted ( ^ Vecmap_VacantEntry_Type.vacantentry_map self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var value_2 : v; + var _7 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _8 : usize; + var _9 : k; + var _10 : v; + { + self_1 <- self; + value_2 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + _7 <- borrow_mut ( * Vecmap_VacantEntry_Type.vacantentry_map self_1); + self_1 <- (let Vecmap_VacantEntry_Type.C_VacantEntry a b c = self_1 in Vecmap_VacantEntry_Type.C_VacantEntry ({ (Vecmap_VacantEntry_Type.vacantentry_map self_1) with current = ( ^ _7) }) b c); + _8 <- Vecmap_VacantEntry_Type.vacantentry_index self_1; + assume { Resolve0.resolve _9 }; + _9 <- Vecmap_VacantEntry_Type.vacantentry_key self_1; + self_1 <- (let Vecmap_VacantEntry_Type.C_VacantEntry a b c = self_1 in Vecmap_VacantEntry_Type.C_VacantEntry a (any k) c); + assume { Resolve1.resolve _10 }; + _10 <- value_2; + value_2 <- any v; + _0 <- ([#"../src/lib.rs" 527 8 527 61] InsertInternal0.insert_internal _7 _8 _9 _10); + goto BB4 + } + BB4 { + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + assume { Resolve2.resolve self_1 }; + return _0 + } + +end +module Vecmap_Impl9_Replace_Interface + type k + type v + use prelude.Borrow + use mach.int.UInt64 + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val replace [@cfg:stackify] [#"../src/lib.rs" 554 4 554 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) (value : v) : () + requires {[#"../src/lib.rs" 552 4 552 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 552 4 552 40] Invariant0.invariant' ( ^ self) } + ensures { [#"../src/lib.rs" 553 14 553 54] (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( ^ self)))) (UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self))) in a) = value } + +end +module Vecmap_Impl9_Replace + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_OccupiedEntry_Type.t_occupiedentry k v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = v + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg replace [@cfg:stackify] [#"../src/lib.rs" 554 4 554 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) (value : v) : () + requires {[#"../src/lib.rs" 552 4 552 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 552 4 552 40] Invariant0.invariant' ( ^ self) } + ensures { [#"../src/lib.rs" 553 14 553 54] (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( ^ self)))) (UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self))) in a) = value } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v); + var value_2 : v; + var _6 : v; + var _7 : borrowed (k, v); + var _8 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _9 : usize; + { + self_1 <- self; + value_2 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + assume { Resolve0.resolve _6 }; + _6 <- value_2; + value_2 <- any v; + _8 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1))); + self_1 <- { self_1 with current = (let Vecmap_OccupiedEntry_Type.C_OccupiedEntry a b c = * self_1 in Vecmap_OccupiedEntry_Type.C_OccupiedEntry ({ (Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1)) with current = (let Vecmap_VecMap_Type.C_VecMap a = * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1) in Vecmap_VecMap_Type.C_VecMap ( ^ _8)) }) b c) }; + _9 <- Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self_1); + assume { Resolve1.resolve self_1 }; + _7 <- ([#"../src/lib.rs" 555 8 555 30] IndexMut0.index_mut _8 _9); + goto BB2 + } + BB2 { + assume { Resolve0.resolve (let (_, a) = * _7 in a) }; + _7 <- { _7 with current = (let (a, b) = * _7 in (a, _6)) }; + goto BB3 + } + BB3 { + assume { Resolve2.resolve _7 }; + goto BB4 + } + BB4 { + _0 <- (); + goto BB5 + } + BB5 { + return _0 + } + +end +module Vecmap_Impl9_GetMut_Interface + type k + type v + use prelude.Borrow + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val get_mut [@cfg:stackify] [#"../src/lib.rs" 560 4 560 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) : borrowed v + requires {[#"../src/lib.rs" 559 4 559 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 559 4 559 40] Invariant0.invariant' ( ^ self) } + +end +module Vecmap_Impl9_GetMut + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = v + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with + type t = Vecmap_OccupiedEntry_Type.t_occupiedentry k v + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg get_mut [@cfg:stackify] [#"../src/lib.rs" 560 4 560 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) : borrowed v + requires {[#"../src/lib.rs" 559 4 559 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 559 4 559 40] Invariant0.invariant' ( ^ self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : borrowed v; + var self_1 : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v); + var _2 : borrowed v; + var _5 : borrowed v; + var _6 : borrowed (k, v); + var _7 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _8 : usize; + { + self_1 <- self; + goto BB0 + } + BB0 { + _7 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1))); + self_1 <- { self_1 with current = (let Vecmap_OccupiedEntry_Type.C_OccupiedEntry a b c = * self_1 in Vecmap_OccupiedEntry_Type.C_OccupiedEntry ({ (Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1)) with current = (let Vecmap_VecMap_Type.C_VecMap a = * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1) in Vecmap_VecMap_Type.C_VecMap ( ^ _7)) }) b c) }; + _8 <- Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self_1); + assume { Resolve0.resolve self_1 }; + _6 <- ([#"../src/lib.rs" 561 13 561 35] IndexMut0.index_mut _7 _8); + goto BB1 + } + BB1 { + _5 <- borrow_mut (let (_, a) = * _6 in a); + _6 <- { _6 with current = (let (a, b) = * _6 in (a, ^ _5)) }; + assume { Resolve1.resolve _6 }; + _2 <- borrow_mut ( * _5); + _5 <- { _5 with current = ( ^ _2) }; + assume { Resolve2.resolve _5 }; + _0 <- borrow_mut ( * _2); + _2 <- { _2 with current = ( ^ _0) }; + assume { Resolve2.resolve _2 }; + return _0 + } + +end +module Core_Clone_Clone_Clone_Interface + type self + use prelude.Borrow + val clone' [@cfg:stackify] (self : self) : self + ensures { result = self } + +end +module Core_Clone_Clone_Clone + type self + use prelude.Borrow + val clone' [@cfg:stackify] (self : self) : self + ensures { result = self } + +end +module Core_Clone_Impls_Impl5_Clone_Interface + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + val clone' [@cfg:stackify] (self : usize) : usize + ensures { result = self } + +end +module Core_Clone_Impls_Impl5_Clone + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + val clone' [@cfg:stackify] (self : usize) : usize + ensures { result = self } + +end +module Vecmap_Impl17_Clone_Interface + type k + use prelude.Borrow + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + val clone' [@cfg:stackify] [#"../src/lib.rs" 568 15 568 20] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 568 15 568 20] result = self } + +end +module Vecmap_Impl17_Clone + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone Core_Clone_Impls_Impl5_Clone_Interface as Clone1 + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Core_Clone_Clone_Clone_Interface as Clone0 with + type self = k + let rec cfg clone' [@cfg:stackify] [#"../src/lib.rs" 568 15 568 20] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 568 15 568 20] result = self } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_KeyRef_Type.t_keyref k; + var _3 : k; + var _4 : k; + var _5 : usize; + var _6 : usize; + { + self_1 <- self; + goto BB0 + } + BB0 { + _4 <- Vecmap_KeyRef_Type.keyref_key self_1; + _3 <- ([#"../src/lib.rs" 570 4 570 14] Clone0.clone' _4); + goto BB1 + } + BB1 { + _6 <- Vecmap_KeyRef_Type.keyref_min_idx self_1; + assume { Resolve0.resolve self_1 }; + _5 <- ([#"../src/lib.rs" 571 4 573 18] Clone1.clone' _6); + goto BB2 + } + BB2 { + _0 <- Vecmap_KeyRef_Type.C_KeyRef _3 _5; + goto BB3 + } + BB3 { + return _0 + } + +end +module Vecmap_Impl11_Cloned_Interface + type k + use prelude.Borrow + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + val cloned [@cfg:stackify] [#"../src/lib.rs" 587 4 587 36] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + +end +module Vecmap_Impl11_Cloned + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone Core_Clone_Clone_Clone_Interface as Clone0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + let rec cfg cloned [@cfg:stackify] [#"../src/lib.rs" 587 4 587 36] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_KeyRef_Type.t_keyref k; + var _2 : usize; + var _3 : k; + var _4 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _2 <- Vecmap_KeyRef_Type.keyref_min_idx self_1; + _4 <- Vecmap_KeyRef_Type.keyref_key self_1; + assume { Resolve0.resolve self_1 }; + _3 <- ([#"../src/lib.rs" 590 17 590 33] Clone0.clone' _4); + goto BB1 + } + BB1 { + _0 <- Vecmap_KeyRef_Type.C_KeyRef _3 _2; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl14_From_Interface + type k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + val from [@cfg:stackify] [#"../src/lib.rs" 625 4 625 27] (key : k) : Vecmap_KeyRef_Type.t_keyref k +end +module Vecmap_Impl14_From + type k + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg from [@cfg:stackify] [#"../src/lib.rs" 625 4 625 27] (key : k) : Vecmap_KeyRef_Type.t_keyref k + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var key_1 : k; + var _2 : k; + { + key_1 <- key; + goto BB0 + } + BB0 { + assume { Resolve0.resolve _2 }; + _2 <- key_1; + key_1 <- any k; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _2 ([#"../src/lib.rs" 626 29 626 30] (0 : usize)); + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl2 + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl2_Clone_Interface as Clone0 with + type k = k, + type v = v + clone Core_Clone_Clone_Clone_Interface as Clone1 with + type self = Vecmap_VecMap_Type.t_vecmap k v, + val clone' = Clone0.clone' +end +module Vecmap_Impl17 + type k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl17_Clone_Interface as Clone0 with + type k = k + clone Core_Clone_Clone_Clone_Interface as Clone1 with + type self = Vecmap_KeyRef_Type.t_keyref k, + val clone' = Clone0.clone' +end +module CreusotContracts_Std1_Default_Default_IsDefault_Stub + type self + predicate is_default (self : self) +end +module CreusotContracts_Std1_Default_Default_IsDefault_Interface + type self + predicate is_default (self : self) +end +module CreusotContracts_Std1_Default_Default_IsDefault + type self + predicate is_default (self : self) + val is_default (self : self) : bool + ensures { result = is_default self } + +end +module Core_Default_Default_Default_Interface + type self + clone CreusotContracts_Std1_Default_Default_IsDefault_Stub as IsDefault0 with + type self = self + val default [@cfg:stackify] (_1' : ()) : self + ensures { IsDefault0.is_default result } + +end +module Core_Default_Default_Default + type self + clone CreusotContracts_Std1_Default_Default_IsDefault_Interface as IsDefault0 with + type self = self + val default [@cfg:stackify] (_1' : ()) : self + ensures { IsDefault0.is_default result } + +end +module Vecmap_Impl3 + type k + type v + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl4_IsDefault as IsDefault0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + clone Vecmap_Impl3_Default_Interface as Default0 with + type k = k, + type v = v, + predicate IsDefault0.is_default = IsDefault0.is_default + clone Core_Default_Default_Default_Interface as Default1 with + type self = Vecmap_VecMap_Type.t_vecmap k v, + val default = Default0.default, + predicate IsDefault0.is_default = IsDefault0.is_default +end +module Vecmap_Impl4 + type k + type v +end +module Vecmap_Impl15 + type k + type v +end +module Vecmap_Impl6 + type k + type v +end +module Vecmap_Impl8 + type k + type v +end +module Vecmap_Impl16 + type k +end +module Vecmap_Impl10 + type k +end +module Vecmap_Impl14 + type k +end diff --git a/vecmap/creusot/vecmap_creusot-rlib.mlcfg b/vecmap/creusot/vecmap_creusot-rlib.mlcfg new file mode 100644 index 00000000..a5e2fc31 --- /dev/null +++ b/vecmap/creusot/vecmap_creusot-rlib.mlcfg @@ -0,0 +1,8139 @@ + +module Core_Ptr_NonNull_NonNull_Type + use prelude.Opaque + type t_nonnull 't = + | C_NonNull opaque_ptr + +end +module Core_Marker_PhantomData_Type + type t_phantomdata 't = + | C_PhantomData + +end +module Core_Ptr_Unique_Unique_Type + use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type + use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type + type t_unique 't = + | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) + +end +module Alloc_RawVec_RawVec_Type + use mach.int.Int + use prelude.UIntSize + use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type + type t_rawvec 't 'a = + | C_RawVec (Core_Ptr_Unique_Unique_Type.t_unique 't) usize 'a + +end +module Alloc_Vec_Vec_Type + use mach.int.Int + use prelude.UIntSize + use Alloc_RawVec_RawVec_Type as Alloc_RawVec_RawVec_Type + type t_vec 't 'a = + | C_Vec (Alloc_RawVec_RawVec_Type.t_rawvec 't 'a) usize + +end +module Alloc_Alloc_Global_Type + type t_global = + | C_Global + +end +module VecmapCreusot_VecMap_Type + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + type t_vecmap 'k 'v = + | C_VecMap (Alloc_Vec_Vec_Type.t_vec ('k, 'v) (Alloc_Alloc_Global_Type.t_global)) + + let function vecmap_v (self : t_vecmap 'k 'v) : Alloc_Vec_Vec_Type.t_vec ('k, 'v) (Alloc_Alloc_Global_Type.t_global) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VecMap a -> a + end +end +module Core_Num_Impl12_Max_Stub + use mach.int.Int + use prelude.UIntSize + val constant mAX' : usize +end +module Core_Num_Impl12_Max + use mach.int.Int + use prelude.UIntSize + let constant mAX' : usize = [@vc:do_not_keep_trace] [@vc:sp] + (18446744073709551615 : usize) +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + axiom shallow_model_spec : forall self : Alloc_Vec_Vec_Type.t_vec t a . Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + val shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + ensures { result = shallow_model self } + + axiom shallow_model_spec : forall self : Alloc_Vec_Vec_Type.t_vec t a . Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Model_DeepModel_DeepModelTy_Type + type self + type deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel_Stub + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel_Interface + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy + val deep_model (self : self) : DeepModelTy0.deepModelTy + ensures { result = deep_model self } + +end +module VecmapCreusot_Impl0_KeySeq_Stub + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + function key_seq [#"../src/lib.rs" 54 4 54 43] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + +end +module VecmapCreusot_Impl0_KeySeq_Interface + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + function key_seq [#"../src/lib.rs" 54 4 54 43] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + + axiom key_seq_spec : forall self : VecmapCreusot_VecMap_Type.t_vecmap k v . [#"../src/lib.rs" 51 4 53 56] Seq.length (key_seq self) = Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) /\ (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> Seq.get (key_seq self) i = DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) i in a)) +end +module VecmapCreusot_Impl0_KeySeq + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + function key_seq [#"../src/lib.rs" 54 4 54 43] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + + val key_seq [#"../src/lib.rs" 54 4 54 43] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + ensures { result = key_seq self } + + axiom key_seq_spec : forall self : VecmapCreusot_VecMap_Type.t_vecmap k v . [#"../src/lib.rs" 51 4 53 56] Seq.length (key_seq self) = Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) /\ (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> Seq.get (key_seq self) i = DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) i in a)) +end +module Core_Cmp_Ordering_Type + type t_ordering = + | C_Less + | C_Equal + | C_Greater + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering + val cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = cmp_log self _2' } + +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub + type self + predicate lt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface + type self + predicate lt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate lt_log (self : self) (o : self) = + [#"../src/lib.rs" 361 6 361 39] CmpLog0.cmp_log self o = Core_Cmp_Ordering_Type.C_Less + val lt_log (self : self) (o : self) : bool + ensures { result = lt_log self o } + +end +module VecmapCreusot_Impl0_IsSorted_Stub + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + predicate is_sorted [#"../src/lib.rs" 59 4 59 30] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) +end +module VecmapCreusot_Impl0_IsSorted_Interface + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + predicate is_sorted [#"../src/lib.rs" 59 4 59 30] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) +end +module VecmapCreusot_Impl0_IsSorted + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + use mach.int.Int + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + predicate is_sorted [#"../src/lib.rs" 59 4 59 30] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) = + [#"../src/lib.rs" 60 8 63 9] forall n : int . forall m : int . m >= 0 /\ n >= 0 /\ m < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) /\ n < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) /\ m < n -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) m) (Seq.get (KeySeq0.key_seq self) n) + val is_sorted [#"../src/lib.rs" 59 4 59 30] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : bool + ensures { result = is_sorted self } + +end +module Alloc_Vec_Impl0_New_Interface + type t + use seq.Seq + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = t, + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val new [@cfg:stackify] (_1' : ()) : Alloc_Vec_Vec_Type.t_vec t (Alloc_Alloc_Global_Type.t_global) + ensures { Seq.length (ShallowModel0.shallow_model result) = 0 } + +end +module Alloc_Vec_Impl0_New + type t + use seq.Seq + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel0 with + type t = t, + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val new [@cfg:stackify] (_1' : ()) : Alloc_Vec_Vec_Type.t_vec t (Alloc_Alloc_Global_Type.t_global) + ensures { Seq.length (ShallowModel0.shallow_model result) = 0 } + +end +module VecmapCreusot_Impl1_New_Interface + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + val new [@cfg:stackify] [#"../src/lib.rs" 72 4 72 24] (_1' : ()) : VecmapCreusot_VecMap_Type.t_vecmap k v +end +module VecmapCreusot_Impl1_New + type k + type v + clone Core_Num_Impl12_Max as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Alloc_Vec_Impl0_New_Interface as New0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + let rec cfg new [@cfg:stackify] [#"../src/lib.rs" 72 4 72 24] (_1' : ()) : VecmapCreusot_VecMap_Type.t_vecmap k v + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _1 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + goto BB0 + } + BB0 { + _1 <- ([#"../src/lib.rs" 73 18 73 28] New0.new ()); + goto BB1 + } + BB1 { + _0 <- VecmapCreusot_VecMap_Type.C_VecMap _1; + goto BB2 + } + BB2 { + return _0 + } + +end +module VecmapCreusot_OccupiedEntry_Type + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + type t_occupiedentry 'k 'v = + | C_OccupiedEntry (borrowed (VecmapCreusot_VecMap_Type.t_vecmap 'k 'v)) 'k usize + + let function occupiedentry_map (self : t_occupiedentry 'k 'v) : borrowed (VecmapCreusot_VecMap_Type.t_vecmap 'k 'v) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry a _ _ -> a + end + let function occupiedentry_index (self : t_occupiedentry 'k 'v) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry _ _ a -> a + end + let function occupiedentry_key (self : t_occupiedentry 'k 'v) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry _ a _ -> a + end +end +module VecmapCreusot_VacantEntry_Type + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + type t_vacantentry 'k 'v = + | C_VacantEntry (borrowed (VecmapCreusot_VecMap_Type.t_vecmap 'k 'v)) 'k usize + + let function vacantentry_map (self : t_vacantentry 'k 'v) : borrowed (VecmapCreusot_VecMap_Type.t_vecmap 'k 'v) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry a _ _ -> a + end + let function vacantentry_index (self : t_vacantentry 'k 'v) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry _ _ a -> a + end + let function vacantentry_key (self : t_vacantentry 'k 'v) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry _ a _ -> a + end +end +module VecmapCreusot_Entry_Type + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + type t_entry 'k 'v = + | C_Vacant (VecmapCreusot_VacantEntry_Type.t_vacantentry 'k 'v) + | C_Occupied (VecmapCreusot_OccupiedEntry_Type.t_occupiedentry 'k 'v) + + let function occupied_0 (self : t_entry 'k 'v) : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry 'k 'v + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Vacant _ -> any VecmapCreusot_OccupiedEntry_Type.t_occupiedentry 'k 'v + | C_Occupied a -> a + end + let function vacant_0 (self : t_entry 'k 'v) : VecmapCreusot_VacantEntry_Type.t_vacantentry 'k 'v + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Vacant a -> a + | C_Occupied _ -> any VecmapCreusot_VacantEntry_Type.t_vacantentry 'k 'v + end +end +module VecmapCreusot_Impl8_Invariant_Stub + type k + type v + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + predicate invariant' [#"../src/lib.rs" 498 4 498 30] (self : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v) +end +module VecmapCreusot_Impl8_Invariant_Interface + type k + type v + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + predicate invariant' [#"../src/lib.rs" 498 4 498 30] (self : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v) +end +module VecmapCreusot_Impl8_Invariant + type k + type v + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + use prelude.Borrow + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate invariant' [#"../src/lib.rs" 498 4 498 30] (self : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v) = + [#"../src/lib.rs" 499 8 503 9] IsSorted0.is_sorted ( * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map self))) > UInt64.to_int (VecmapCreusot_OccupiedEntry_Type.occupiedentry_index self) /\ Seq.get (KeySeq0.key_seq ( * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map self)) (UInt64.to_int (VecmapCreusot_OccupiedEntry_Type.occupiedentry_index self)) = DeepModel0.deep_model (VecmapCreusot_OccupiedEntry_Type.occupiedentry_key self) + val invariant' [#"../src/lib.rs" 498 4 498 30] (self : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v) : bool + ensures { result = invariant' self } + +end +module VecmapCreusot_Impl6_Invariant_Stub + type k + type v + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + predicate invariant' [#"../src/lib.rs" 467 4 467 30] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) +end +module VecmapCreusot_Impl6_Invariant_Interface + type k + type v + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + predicate invariant' [#"../src/lib.rs" 467 4 467 30] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) +end +module VecmapCreusot_Impl6_Invariant + type k + type v + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + use prelude.Borrow + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate invariant' [#"../src/lib.rs" 467 4 467 30] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) = + [#"../src/lib.rs" 468 8 470 9] IsSorted0.is_sorted ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self) /\ UInt64.to_int (VecmapCreusot_VacantEntry_Type.vacantentry_index self) <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self))) + val invariant' [#"../src/lib.rs" 467 4 467 30] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) : bool + ensures { result = invariant' self } + +end +module Core_Result_Result_Type + type t_result 't 'e = + | C_Ok 't + | C_Err 'e + + let function err_0 (self : t_result 't 'e) : 'e = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Ok _ -> any 'e + | C_Err a -> a + end + let function ok_0 (self : t_result 't 'e) : 't = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Ok a -> a + | C_Err _ -> any 't + end +end +module CreusotContracts_Model_Impl0_DeepModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + function deep_model (self : t) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_Impl0_DeepModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + function deep_model (self : t) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_Impl0_DeepModel + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = t, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function deep_model (self : t) : DeepModelTy0.deepModelTy = + DeepModel0.deep_model self + val deep_model (self : t) : DeepModelTy0.deepModelTy + ensures { result = deep_model self } + +end +module CreusotContracts_Logic_Seq_Impl0_Contains_Stub + type t + use seq.Seq + predicate contains (self : Seq.seq t) (e : t) +end +module CreusotContracts_Logic_Seq_Impl0_Contains_Interface + type t + use seq.Seq + predicate contains (self : Seq.seq t) (e : t) +end +module CreusotContracts_Logic_Seq_Impl0_Contains + type t + use seq.Seq + use mach.int.Int + predicate contains (self : Seq.seq t) (e : t) = + exists i : int . 0 <= i /\ i < Seq.length self /\ Seq.get self i = e + val contains (self : Seq.seq t) (e : t) : bool + ensures { result = contains self e } + +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub + type self + predicate gt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface + type self + predicate gt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate gt_log (self : self) (o : self) = + [#"../src/lib.rs" 373 34 377 24] CmpLog0.cmp_log self o = Core_Cmp_Ordering_Type.C_Greater + val gt_log (self : self) (o : self) : bool + ensures { result = gt_log self o } + +end +module CreusotContracts_Model_ShallowModel_ShallowModelTy_Type + type self + type shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel_Stub + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel_Interface + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy + val shallow_model (self : self) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module CreusotContracts_Model_Impl1_ShallowModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl1_ShallowModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl1_ShallowModel + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + clone CreusotContracts_Model_ShallowModel_ShallowModel_Stub as ShallowModel0 with + type self = t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy = + ShallowModel0.shallow_model self + val shallow_model (self : t) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type + type t + type a + use seq.Seq + type shallowModelTy = + Seq.seq t +end +module Alloc_Vec_Impl1_Len_Interface + type t + type a + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val len [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : usize + ensures { UInt64.to_int result = Seq.length (ShallowModel0.shallow_model self) } + +end +module Alloc_Vec_Impl1_Len + type t + type a + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val len [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : usize + ensures { UInt64.to_int result = Seq.length (ShallowModel0.shallow_model self) } + +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) + val in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) : bool + ensures { result = in_bounds self seq } + +end +module Core_Slice_Index_SliceIndex_Output_Type + type self + type t + type output +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) + val has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) : bool + ensures { result = has_value self seq out } + +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type + type t + use seq.Seq + type shallowModelTy = + Seq.seq t +end +module Alloc_Vec_Impl16_Index_Interface + type t + type i + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) (index : i) : Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) result } + +end +module Alloc_Vec_Impl16_Index + type t + type i + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) (index : i) : Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) result } + +end +module Core_Cmp_Ord_Cmp_Interface + type self + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val cmp [@cfg:stackify] (self : self) (other : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = CmpLog0.cmp_log (DeepModel0.deep_model self) (DeepModel0.deep_model other) } + +end +module Core_Cmp_Ord_Cmp + type self + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val cmp [@cfg:stackify] (self : self) (other : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = CmpLog0.cmp_log (DeepModel0.deep_model self) (DeepModel0.deep_model other) } + +end +module CreusotContracts_Resolve_Resolve_Resolve_Stub + type self + predicate resolve (self : self) +end +module CreusotContracts_Resolve_Resolve_Resolve_Interface + type self + predicate resolve (self : self) +end +module CreusotContracts_Resolve_Resolve_Resolve + type self + predicate resolve (self : self) + val resolve (self : self) : bool + ensures { result = resolve self } + +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub + type self + predicate le_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface + type self + predicate le_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate le_log (self : self) (o : self) = + [#"../src/lib.rs" 354 60 355 24] CmpLog0.cmp_log self o <> Core_Cmp_Ordering_Type.C_Greater + val le_log (self : self) (o : self) : bool + ensures { result = le_log self o } + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () + axiom cmp_le_log_spec : forall x : self, y : self . [#"../src/lib.rs" 357 18 357 68] LeLog0.le_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () + val cmp_le_log (x : self) (y : self) : () + ensures { result = cmp_le_log x y } + + axiom cmp_le_log_spec : forall x : self, y : self . [#"../src/lib.rs" 357 18 357 68] LeLog0.le_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () + axiom cmp_lt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 361 74 362 37] LtLog0.lt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () + val cmp_lt_log (x : self) (y : self) : () + ensures { result = cmp_lt_log x y } + + axiom cmp_lt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 361 74 362 37] LtLog0.lt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub + type self + predicate ge_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface + type self + predicate ge_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate ge_log (self : self) (o : self) = + [#"../src/lib.rs" 365 41 366 8] CmpLog0.cmp_log self o <> Core_Cmp_Ordering_Type.C_Less + val ge_log (self : self) (o : self) : bool + ensures { result = ge_log self o } + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () + axiom cmp_ge_log_spec : forall x : self, y : self . [#"../src/lib.rs" 367 2 370 40] GeLog0.ge_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () + val cmp_ge_log (x : self) (y : self) : () + ensures { result = cmp_ge_log x y } + + axiom cmp_ge_log_spec : forall x : self, y : self . [#"../src/lib.rs" 367 2 370 40] GeLog0.ge_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () + axiom cmp_gt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 378 24 379 13] GtLog0.gt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () + val cmp_gt_log (x : self) (y : self) : () + ensures { result = cmp_gt_log x y } + + axiom cmp_gt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 378 24 379 13] GtLog0.gt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () + axiom refl_spec : forall x : self . [#"../src/lib.rs" 380 16 380 47] CmpLog0.cmp_log x x = Core_Cmp_Ordering_Type.C_Equal +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () + val refl (x : self) : () + ensures { result = refl x } + + axiom refl_spec : forall x : self . [#"../src/lib.rs" 380 16 380 47] CmpLog0.cmp_log x x = Core_Cmp_Ordering_Type.C_Equal +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + axiom trans_spec : forall x : self, y : self, z : self, o : Core_Cmp_Ordering_Type.t_ordering . ([#"../src/lib.rs" 384 35 384 52] CmpLog0.cmp_log x y = o) -> ([#"../src/lib.rs" 385 6 385 23] CmpLog0.cmp_log y z = o) -> ([#"../src/lib.rs" 386 4 386 21] CmpLog0.cmp_log x z = o) +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + val trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + requires {[#"../src/lib.rs" 384 35 384 52] CmpLog0.cmp_log x y = o} + requires {[#"../src/lib.rs" 385 6 385 23] CmpLog0.cmp_log y z = o} + ensures { result = trans x y z o } + + axiom trans_spec : forall x : self, y : self, z : self, o : Core_Cmp_Ordering_Type.t_ordering . ([#"../src/lib.rs" 384 35 384 52] CmpLog0.cmp_log x y = o) -> ([#"../src/lib.rs" 385 6 385 23] CmpLog0.cmp_log y z = o) -> ([#"../src/lib.rs" 386 4 386 21] CmpLog0.cmp_log x z = o) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () + axiom antisym1_spec : forall x : self, y : self . ([#"../src/lib.rs" 391 38 393 7] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) -> ([#"../src/lib.rs" 395 10 396 26] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1 + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () + val antisym1 (x : self) (y : self) : () + requires {[#"../src/lib.rs" 391 38 393 7] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less} + ensures { result = antisym1 x y } + + axiom antisym1_spec : forall x : self, y : self . ([#"../src/lib.rs" 391 38 393 7] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) -> ([#"../src/lib.rs" 395 10 396 26] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () + axiom antisym2_spec : forall x : self, y : self . ([#"../src/lib.rs" 401 5 401 38] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) -> ([#"../src/lib.rs" 401 55 402 4] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2 + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () + val antisym2 (x : self) (y : self) : () + requires {[#"../src/lib.rs" 401 5 401 38] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater} + ensures { result = antisym2 x y } + + axiom antisym2_spec : forall x : self, y : self . ([#"../src/lib.rs" 401 5 401 38] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) -> ([#"../src/lib.rs" 401 55 402 4] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () + axiom eq_cmp_spec : forall x : self, y : self . [#"../src/lib.rs" 406 18 409 4] (x = y) = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Equal) +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () + val eq_cmp (x : self) (y : self) : () + ensures { result = eq_cmp x y } + + axiom eq_cmp_spec : forall x : self, y : self . [#"../src/lib.rs" 406 18 409 4] (x = y) = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Equal) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) = + UInt64.to_int self < Seq.length seq + val in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) : bool + ensures { result = in_bounds self seq } + +end +module CreusotContracts_Std1_Slice_Impl5_HasValue_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) +end +module CreusotContracts_Std1_Slice_Impl5_HasValue_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) +end +module CreusotContracts_Std1_Slice_Impl5_HasValue + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) = + Seq.get seq (UInt64.to_int self) = out + val has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) : bool + ensures { result = has_value self seq out } + +end +module Core_Slice_Index_Impl2_Output_Type + type t + type output = + t +end +module VecmapCreusot_Impl1_FindK_Interface + type k + type v + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val find_k [@cfg:stackify] [#"../src/lib.rs" 313 4 313 53] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : k) : Core_Result_Result_Type.t_result usize usize + requires {[#"../src/lib.rs" 299 15 299 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 300 14 303 5] match (result) with + | Core_Result_Result_Type.C_Ok _ -> Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + | Core_Result_Result_Type.C_Err _ -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + end } + ensures { [#"../src/lib.rs" 304 4 304 91] forall i : usize . result = Core_Result_Result_Type.C_Ok i -> Seq.get (KeySeq0.key_seq self) (UInt64.to_int i) = DeepModel0.deep_model key } + ensures { [#"../src/lib.rs" 305 4 306 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i -> j >= UInt64.to_int i /\ j < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 307 4 308 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i /\ j >= 0 /\ j < UInt64.to_int i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 309 14 312 5] match (result) with + | Core_Result_Result_Type.C_Ok idx -> UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) + | Core_Result_Result_Type.C_Err idx -> UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) + end } + +end +module VecmapCreusot_Impl1_FindK + type k + type v + use mach.int.Int + use prelude.UIntSize + use prelude.Borrow + use prelude.Int8 + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + clone Core_Cmp_Ord_Cmp_Interface as Cmp0 with + type self = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Core_Result_Result_Type as Core_Result_Result_Type + let rec cfg find_k [@cfg:stackify] [#"../src/lib.rs" 313 4 313 53] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : k) : Core_Result_Result_Type.t_result usize usize + requires {[#"../src/lib.rs" 299 15 299 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 300 14 303 5] match (result) with + | Core_Result_Result_Type.C_Ok _ -> Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + | Core_Result_Result_Type.C_Err _ -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + end } + ensures { [#"../src/lib.rs" 304 4 304 91] forall i : usize . result = Core_Result_Result_Type.C_Ok i -> Seq.get (KeySeq0.key_seq self) (UInt64.to_int i) = DeepModel0.deep_model key } + ensures { [#"../src/lib.rs" 305 4 306 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i -> j >= UInt64.to_int i /\ j < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 307 4 308 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i /\ j >= 0 /\ j < UInt64.to_int i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 309 14 312 5] match (result) with + | Core_Result_Result_Type.C_Ok idx -> UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) + | Core_Result_Result_Type.C_Err idx -> UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) + end } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Result_Result_Type.t_result usize usize; + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var key_2 : k; + var size_9 : usize; + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var left_11 : usize; + var right_12 : usize; + var mid_13 : usize; + var _14 : (); + var _22 : (); + var _23 : bool; + var _24 : usize; + var _25 : usize; + var _26 : usize; + var _27 : usize; + var _28 : usize; + var _29 : bool; + var cmp_30 : Core_Cmp_Ordering_Type.t_ordering; + var _31 : k; + var _32 : (k, v); + var _33 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _34 : usize; + var _35 : k; + var _36 : (); + var _37 : int8; + var _38 : usize; + var _39 : usize; + var _40 : (); + var _41 : usize; + var _42 : usize; + var _43 : usize; + var _44 : (); + var _45 : (); + var _46 : (); + var _47 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _10 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + size_9 <- ([#"../src/lib.rs" 314 23 314 35] Len0.len _10); + goto BB1 + } + BB1 { + left_11 <- ([#"../src/lib.rs" 315 23 315 24] (0 : usize)); + right_12 <- size_9; + goto BB2 + } + BB2 { + invariant size_bounds { [#"../src/lib.rs" 319 33 319 71] UInt64.to_int size_9 >= 0 /\ UInt64.to_int size_9 <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self_1)) }; + invariant left_bounds { [#"../src/lib.rs" 320 33 320 71] UInt64.to_int left_11 >= 0 /\ UInt64.to_int left_11 <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self_1)) }; + invariant right_bounds { [#"../src/lib.rs" 321 34 321 74] UInt64.to_int right_12 >= 0 /\ UInt64.to_int right_12 <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self_1)) }; + invariant mid_bounds { [#"../src/lib.rs" 319 8 319 73] UInt64.to_int left_11 < UInt64.to_int right_12 -> UInt64.to_int left_11 + div (UInt64.to_int size_9) 2 < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self_1)) }; + invariant right_gt_mid { [#"../src/lib.rs" 319 8 319 73] UInt64.to_int left_11 < UInt64.to_int right_12 -> UInt64.to_int right_12 > UInt64.to_int left_11 + div (UInt64.to_int size_9) 2 }; + invariant right_geq_key { [#"../src/lib.rs" 319 8 319 73] forall i : int . i >= UInt64.to_int right_12 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self_1)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self_1) i) (DeepModel0.deep_model key_2) }; + invariant left_lt_key { [#"../src/lib.rs" 319 8 319 73] forall i : int . i >= 0 /\ i < UInt64.to_int left_11 -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self_1) i) (DeepModel0.deep_model key_2) }; + _24 <- left_11; + _25 <- right_12; + _23 <- ([#"../src/lib.rs" 328 14 328 26] _24 < _25); + switch (_23) + | False -> goto BB12 + | True -> goto BB3 + end + } + BB3 { + _26 <- left_11; + _28 <- size_9; + _29 <- ([#"../src/lib.rs" 329 25 329 33] ([#"../src/lib.rs" 329 32 329 33] (2 : usize)) = ([#"../src/lib.rs" 329 25 329 33] (0 : usize))); + assert { [#"../src/lib.rs" 329 25 329 33] not _29 }; + goto BB4 + } + BB4 { + _27 <- ([#"../src/lib.rs" 329 25 329 33] _28 / ([#"../src/lib.rs" 329 32 329 33] (2 : usize))); + mid_13 <- ([#"../src/lib.rs" 329 12 329 33] _26 + _27); + _33 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + _34 <- mid_13; + _32 <- ([#"../src/lib.rs" 331 22 331 33] Index0.index _33 _34); + goto BB5 + } + BB5 { + _31 <- (let (a, _) = _32 in a); + assume { Resolve0.resolve _32 }; + _35 <- key_2; + cmp_30 <- ([#"../src/lib.rs" 331 22 331 44] Cmp0.cmp _31 _35); + goto BB6 + } + BB6 { + switch (cmp_30) + | Core_Cmp_Ordering_Type.C_Less -> goto BB9 + | Core_Cmp_Ordering_Type.C_Equal -> goto BB7 + | Core_Cmp_Ordering_Type.C_Greater -> goto BB10 + end + } + BB7 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + _41 <- mid_13; + _0 <- Core_Result_Result_Type.C_Ok _41; + goto BB13 + } + BB8 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + absurd + } + BB9 { + _38 <- mid_13; + left_11 <- ([#"../src/lib.rs" 334 34 334 48] _38 + ([#"../src/lib.rs" 334 47 334 48] (1 : usize))); + _36 <- (); + goto BB11 + } + BB10 { + _39 <- mid_13; + right_12 <- _39; + _39 <- any usize; + _36 <- (); + goto BB11 + } + BB11 { + _42 <- right_12; + _43 <- left_11; + size_9 <- ([#"../src/lib.rs" 339 12 339 31] _42 - _43); + _22 <- (); + goto BB2 + } + BB12 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + _14 <- (); + _47 <- left_11; + _0 <- Core_Result_Result_Type.C_Err _47; + goto BB13 + } + BB13 { + return _0 + } + +end +module CreusotContracts_Resolve_Impl1_Resolve_Stub + type t + use prelude.Borrow + predicate resolve (self : borrowed t) +end +module CreusotContracts_Resolve_Impl1_Resolve_Interface + type t + use prelude.Borrow + predicate resolve (self : borrowed t) +end +module CreusotContracts_Resolve_Impl1_Resolve + type t + use prelude.Borrow + predicate resolve (self : borrowed t) = + ^ self = * self + val resolve (self : borrowed t) : bool + ensures { result = resolve self } + +end +module VecmapCreusot_Impl1_Entry_Interface + type k + type v + use prelude.Borrow + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + clone VecmapCreusot_Impl6_Invariant_Stub as Invariant1 with + type k = k, + type v = v + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + use VecmapCreusot_Entry_Type as VecmapCreusot_Entry_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val entry [@cfg:stackify] [#"../src/lib.rs" 81 4 81 50] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key : k) : VecmapCreusot_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 78 15 78 31] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 79 4 79 75] forall e : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v . result = VecmapCreusot_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 80 4 80 73] forall e : VecmapCreusot_VacantEntry_Type.t_vacantentry k v . result = VecmapCreusot_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + +end +module VecmapCreusot_Impl1_Entry + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = VecmapCreusot_VecMap_Type.t_vecmap k v + use Core_Result_Result_Type as Core_Result_Result_Type + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + clone VecmapCreusot_Impl6_Invariant as Invariant1 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_Entry_Type as VecmapCreusot_Entry_Type + let rec cfg entry [@cfg:stackify] [#"../src/lib.rs" 81 4 81 50] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key : k) : VecmapCreusot_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 78 15 78 31] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 79 4 79 75] forall e : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v . result = VecmapCreusot_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 80 4 80 73] forall e : VecmapCreusot_VacantEntry_Type.t_vacantentry k v . result = VecmapCreusot_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_Entry_Type.t_entry k v; + var self_1 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var key_2 : k; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _8 : k; + var _9 : k; + var _10 : isize; + var index_11 : usize; + var _12 : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v; + var _13 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var _14 : usize; + var _15 : k; + var index_16 : usize; + var _17 : VecmapCreusot_VacantEntry_Type.t_vacantentry k v; + var _18 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var _19 : usize; + var _20 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- * self_1; + _9 <- key_2; + _8 <- _9; + assume { Resolve0.resolve _9 }; + _6 <- ([#"../src/lib.rs" 82 14 82 31] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + switch (_6) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + index_16 <- Core_Result_Result_Type.err_0 _6; + _18 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _18) }; + assume { Resolve1.resolve self_1 }; + _19 <- index_16; + assume { Resolve2.resolve _20 }; + _20 <- key_2; + key_2 <- any k; + _17 <- VecmapCreusot_VacantEntry_Type.C_VacantEntry _18 _20 _19; + goto BB7 + } + BB3 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + absurd + } + BB4 { + index_11 <- Core_Result_Result_Type.ok_0 _6; + _13 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _13) }; + assume { Resolve1.resolve self_1 }; + _14 <- index_11; + assume { Resolve2.resolve _15 }; + _15 <- key_2; + key_2 <- any k; + _12 <- VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry _13 _15 _14; + goto BB5 + } + BB5 { + _0 <- VecmapCreusot_Entry_Type.C_Occupied _12; + goto BB6 + } + BB6 { + goto BB9 + } + BB7 { + _0 <- VecmapCreusot_Entry_Type.C_Vacant _17; + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + goto BB10 + } + BB10 { + return _0 + } + +end +module VecmapCreusot_KeyRef_Type + use mach.int.Int + use prelude.UIntSize + type t_keyref 'k = + | C_KeyRef 'k usize + + let function keyref_key (self : t_keyref 'k) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_KeyRef a _ -> a + end + let function keyref_min_idx (self : t_keyref 'k) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_KeyRef _ a -> a + end +end +module Core_Option_Option_Type + type t_option 't = + | C_None + | C_Some 't + + let function some_0 (self : t_option 't) : 't = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_None -> any 't + | C_Some a -> a + end +end +module CreusotContracts_Logic_Seq_Impl0_Get_Stub + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t +end +module CreusotContracts_Logic_Seq_Impl0_Get_Interface + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t +end +module CreusotContracts_Logic_Seq_Impl0_Get + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t = + if ix < Seq.length self then Core_Option_Option_Type.C_Some (Seq.get self ix) else Core_Option_Option_Type.C_None + val get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t + ensures { result = get self ix } + +end +module VecmapCreusot_Impl1_IsValidKeyrefLg_Stub + type k + type v + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate is_valid_keyref_lg [#"../src/lib.rs" 249 4 249 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) + +end +module VecmapCreusot_Impl1_IsValidKeyrefLg_Interface + type k + type v + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate is_valid_keyref_lg [#"../src/lib.rs" 249 4 249 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) + + axiom is_valid_keyref_lg_spec : forall self : VecmapCreusot_VecMap_Type.t_vecmap k v, key : VecmapCreusot_KeyRef_Type.t_keyref k . ([#"../src/lib.rs" 248 15 248 31] IsSorted0.is_sorted self) -> true +end +module VecmapCreusot_Impl1_IsValidKeyrefLg + type k + type v + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + use mach.int.UInt64 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get_Stub as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + predicate is_valid_keyref_lg [#"../src/lib.rs" 249 4 249 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) + + = + [#"../src/lib.rs" 251 12 256 13] match (Get0.get (KeySeq0.key_seq self) (UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx key))) with + | Core_Option_Option_Type.C_Some k -> LeLog0.le_log k (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key)) + | _ -> false + end + val is_valid_keyref_lg [#"../src/lib.rs" 249 4 249 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 248 15 248 31] IsSorted0.is_sorted self} + ensures { result = is_valid_keyref_lg self key } + + axiom is_valid_keyref_lg_spec : forall self : VecmapCreusot_VecMap_Type.t_vecmap k v, key : VecmapCreusot_KeyRef_Type.t_keyref k . ([#"../src/lib.rs" 248 15 248 31] IsSorted0.is_sorted self) -> true +end +module VecmapCreusot_Impl1_IsValidKeyrefLg_Impl + type k + type v + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec ghost predicate is_valid_keyref_lg [#"../src/lib.rs" 249 4 249 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) + requires {[#"../src/lib.rs" 248 15 248 31] IsSorted0.is_sorted self} + + = [@vc:do_not_keep_trace] [@vc:sp] + [#"../src/lib.rs" 251 12 256 13] match (let a' = KeySeq0.key_seq self in Get0.get a' (UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx key))) with + | Core_Option_Option_Type.C_Some k -> let b' = DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key) in LeLog0.le_log k b' + | _ -> false + end +end +module VecmapCreusot_Impl10_DeepModel_Stub + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + function deep_model [#"../src/lib.rs" 541 4 541 44] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + +end +module VecmapCreusot_Impl10_DeepModel_Interface + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + function deep_model [#"../src/lib.rs" 541 4 541 44] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + +end +module VecmapCreusot_Impl10_DeepModel + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function deep_model [#"../src/lib.rs" 541 4 541 44] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + + = + [#"../src/lib.rs" 542 19 542 57] (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key self), UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx self)) + val deep_model [#"../src/lib.rs" 541 4 541 44] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + ensures { result = deep_model self } + +end +module VecmapCreusot_Impl10_DeepModelTy_Type + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + type deepModelTy = + (DeepModelTy0.deepModelTy, int) +end +module CreusotContracts_Model_Impl0_DeepModelTy_Type + type t + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + type deepModelTy = + DeepModelTy0.deepModelTy +end +module VecmapCreusot_Impl12_AsRef_Interface + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy2 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone VecmapCreusot_Impl10_DeepModelTy_Type as DeepModelTy0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = VecmapCreusot_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val as_ref [@cfg:stackify] [#"../src/lib.rs" 556 4 556 38] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 555 14 555 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + +end +module VecmapCreusot_Impl12_AsRef + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy2 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel4 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel3 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone VecmapCreusot_Impl10_DeepModelTy_Type as DeepModelTy0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + clone VecmapCreusot_Impl10_DeepModel as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = VecmapCreusot_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel2.deep_model + let rec cfg as_ref [@cfg:stackify] [#"../src/lib.rs" 556 4 556 38] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 555 14 555 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_KeyRef_Type.t_keyref k; + var self_1 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _3 : usize; + var _4 : k; + var _5 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _3 <- VecmapCreusot_KeyRef_Type.keyref_min_idx self_1; + _5 <- VecmapCreusot_KeyRef_Type.keyref_key self_1; + assume { Resolve0.resolve self_1 }; + _4 <- _5; + assume { Resolve1.resolve _5 }; + _0 <- VecmapCreusot_KeyRef_Type.C_KeyRef _4 _3; + return _0 + } + +end +module VecmapCreusot_Impl13_ToOwned_Stub + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 564 4 564 34] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + +end +module VecmapCreusot_Impl13_ToOwned_Interface + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 564 4 564 34] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + + axiom to_owned_spec : forall self : VecmapCreusot_KeyRef_Type.t_keyref k . [#"../src/lib.rs" 563 14 563 54] DeepModel0.deep_model self = DeepModel1.deep_model (to_owned self) +end +module VecmapCreusot_Impl13_ToOwned + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 564 4 564 34] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + + = + [#"../src/lib.rs" 565 8 565 56] VecmapCreusot_KeyRef_Type.C_KeyRef (VecmapCreusot_KeyRef_Type.keyref_key self) (VecmapCreusot_KeyRef_Type.keyref_min_idx self) + val to_owned [#"../src/lib.rs" 564 4 564 34] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + ensures { result = to_owned self } + + axiom to_owned_spec : forall self : VecmapCreusot_KeyRef_Type.t_keyref k . [#"../src/lib.rs" 563 14 563 54] DeepModel0.deep_model self = DeepModel1.deep_model (to_owned self) +end +module VecmapCreusot_Impl13_ToOwned_Impl + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel3 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone VecmapCreusot_Impl10_DeepModel as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel2.deep_model + let rec ghost function to_owned [#"../src/lib.rs" 564 4 564 34] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 563 14 563 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + + = [@vc:do_not_keep_trace] [@vc:sp] + [#"../src/lib.rs" 565 8 565 56] VecmapCreusot_KeyRef_Type.C_KeyRef (VecmapCreusot_KeyRef_Type.keyref_key self) (VecmapCreusot_KeyRef_Type.keyref_min_idx self) +end +module Alloc_Vec_Impl10_Deref_Interface + type t + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t, + type a = a + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val deref [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : seq t + ensures { ShallowModel0.shallow_model result = ShallowModel1.shallow_model self } + +end +module Alloc_Vec_Impl10_Deref + type t + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t, + type a = a + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val deref [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : seq t + ensures { ShallowModel0.shallow_model result = ShallowModel1.shallow_model self } + +end +module Core_Slice_Impl0_Get_Interface + type t + type i + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + type Output0.output = Output0.output + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val get [@cfg:stackify] (self : seq t) (index : i) : Core_Option_Option_Type.t_option Output0.output + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) -> (exists r : Output0.output . result = Core_Option_Option_Type.C_Some r /\ HasValue0.has_value index (ShallowModel0.shallow_model self) r) } + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) \/ result = Core_Option_Option_Type.C_None } + +end +module Core_Slice_Impl0_Get + type t + type i + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + type Output0.output = Output0.output + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val get [@cfg:stackify] (self : seq t) (index : i) : Core_Option_Option_Type.t_option Output0.output + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) -> (exists r : Output0.output . result = Core_Option_Option_Type.C_Some r /\ HasValue0.has_value index (ShallowModel0.shallow_model self) r) } + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) \/ result = Core_Option_Option_Type.C_None } + +end +module Core_Cmp_Impls_Impl10_Le_Interface + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val le [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = LeLog0.le_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_Impls_Impl10_Le + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val le [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = LeLog0.le_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel_Stub + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel_Interface + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t + axiom shallow_model_spec : forall self : seq t . shallow_model self = Slice.id self && Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t + val shallow_model (self : seq t) : Seq.seq t + ensures { result = shallow_model self } + + axiom shallow_model_spec : forall self : seq t . shallow_model self = Slice.id self && Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module VecmapCreusot_Impl1_IsValidKeyref_Interface + type k + type v + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel3 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone VecmapCreusot_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel3.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone VecmapCreusot_Impl1_IsValidKeyrefLg_Stub as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + axiom . + clone VecmapCreusot_Impl13_ToOwned_Stub as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy1.deepModelTy, + axiom . + val is_valid_keyref [@cfg:stackify] [#"../src/lib.rs" 240 4 240 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 235 15 235 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 236 14 236 66] result = IsValidKeyrefLg0.is_valid_keyref_lg self (ToOwned0.to_owned key) } + ensures { [#"../src/lib.rs" 237 4 237 57] result -> UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx key) < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) } + ensures { [#"../src/lib.rs" 238 4 239 57] result -> (forall i : int . i >= 0 /\ i <= UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx key) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key))) } + +end +module VecmapCreusot_Impl1_IsValidKeyref + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use mach.int.UInt64 + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel4 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get1 with + type t = DeepModelTy0.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel as DeepModel3 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone Core_Cmp_Impls_Impl10_Le_Interface as Le0 with + type a = k, + type b = k, + function DeepModel0.deep_model = DeepModel4.deep_model, + function DeepModel1.deep_model = DeepModel4.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = Core_Option_Option_Type.t_option (k, v) + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + clone Core_Slice_Impl0_Get_Interface as Get0 with + type t = (k, v), + type i = usize, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + type Output0.output = Output0.output, + predicate HasValue0.has_value = HasValue0.has_value + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get1.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + let rec cfg is_valid_keyref [@cfg:stackify] [#"../src/lib.rs" 240 4 240 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 235 15 235 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 236 14 236 66] result = IsValidKeyrefLg0.is_valid_keyref_lg self (ToOwned0.to_owned key) } + ensures { [#"../src/lib.rs" 237 4 237 57] result -> UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx key) < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) } + ensures { [#"../src/lib.rs" 238 4 239 57] result -> (forall i : int . i >= 0 /\ i <= UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx key) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : bool; + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var key_2 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _7 : Core_Option_Option_Type.t_option (k, v); + var _8 : seq (k, v); + var _9 : seq (k, v); + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _11 : usize; + var _12 : isize; + var k_13 : k; + var _14 : k; + var _15 : k; + var _16 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _10 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _9 <- ([#"../src/lib.rs" 241 14 241 37] Deref0.deref _10); + goto BB1 + } + BB1 { + _8 <- _9; + assume { Resolve1.resolve _9 }; + _11 <- VecmapCreusot_KeyRef_Type.keyref_min_idx key_2; + _7 <- ([#"../src/lib.rs" 241 14 241 37] Get0.get _8 _11); + goto BB2 + } + BB2 { + switch (_7) + | Core_Option_Option_Type.C_Some _ -> goto BB4 + | _ -> goto BB3 + end + } + BB3 { + assume { Resolve2.resolve key_2 }; + assume { Resolve3.resolve _7 }; + _0 <- ([#"../src/lib.rs" 243 17 243 22] false); + goto BB6 + } + BB4 { + k_13 <- (let (a, _) = Core_Option_Option_Type.some_0 _7 in a); + assume { Resolve3.resolve _7 }; + _14 <- k_13; + assume { Resolve4.resolve k_13 }; + _16 <- VecmapCreusot_KeyRef_Type.keyref_key key_2; + assume { Resolve2.resolve key_2 }; + _15 <- _16; + assume { Resolve4.resolve _16 }; + _0 <- ([#"../src/lib.rs" 242 28 242 40] Le0.le _14 _15); + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Ops_Range_Range_Type + type t_range 'idx = + | C_Range 'idx 'idx + + let function range_end (self : t_range 'idx) : 'idx = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Range _ a -> a + end + let function range_start (self : t_range 'idx) : 'idx = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Range a _ -> a + end +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Stub + type self + predicate into_iter_pre (self : self) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Interface + type self + predicate into_iter_pre (self : self) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre + type self + predicate into_iter_pre (self : self) = + true + val into_iter_pre (self : self) : bool + ensures { result = into_iter_pre self } + +end +module Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type + type self + type intoIter +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Stub + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Interface + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) + val into_iter_post (self : self) (res : IntoIter0.intoIter) : bool + ensures { result = into_iter_post self res } + +end +module CreusotContracts_Invariant_Invariant_Invariant_Stub + type self + predicate invariant' (self : self) +end +module CreusotContracts_Invariant_Invariant_Invariant_Interface + type self + predicate invariant' (self : self) +end +module CreusotContracts_Invariant_Invariant_Invariant + type self + predicate invariant' (self : self) + val invariant' (self : self) : bool + ensures { result = invariant' self } + +end +module Core_Iter_Traits_Collect_Impl0_IntoIter_Type + type i + type intoIter = + i +end +module Core_Iter_Traits_Collect_Impl0_IntoIter_Interface + type i + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter0 with + type i = i + clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with + type self = i + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Stub as IntoIterPost0 with + type self = i, + type IntoIter0.intoIter = IntoIter0.intoIter + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Stub as IntoIterPre0 with + type self = i + val into_iter [@cfg:stackify] (self : i) : i + requires {IntoIterPre0.into_iter_pre self} + ensures { IntoIterPost0.into_iter_post self result } + ensures { Invariant0.invariant' result } + +end +module Core_Iter_Traits_Collect_Impl0_IntoIter + type i + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter0 with + type i = i + clone CreusotContracts_Invariant_Invariant_Invariant_Interface as Invariant0 with + type self = i + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Interface as IntoIterPost0 with + type self = i, + type IntoIter0.intoIter = IntoIter0.intoIter + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Interface as IntoIterPre0 with + type self = i + val into_iter [@cfg:stackify] (self : i) : i + requires {IntoIterPre0.into_iter_pre self} + ensures { IntoIterPost0.into_iter_post self result } + ensures { Invariant0.invariant' result } + +end +module CreusotContracts_Std1_Ops_Impl3_Invariant_Stub + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) +end +module CreusotContracts_Std1_Ops_Impl3_Invariant_Interface + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) +end +module CreusotContracts_Std1_Ops_Impl3_Invariant + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) = + true + val invariant' (self : Core_Ops_Range_Range_Type.t_range idx) : bool + ensures { result = invariant' self } + +end +module CreusotContracts_Std1_Iter_Iterator_Completed_Stub + type self + use prelude.Borrow + predicate completed (self : borrowed self) +end +module CreusotContracts_Std1_Iter_Iterator_Completed_Interface + type self + use prelude.Borrow + predicate completed (self : borrowed self) +end +module CreusotContracts_Std1_Iter_Iterator_Completed + type self + use prelude.Borrow + predicate completed (self : borrowed self) + val completed (self : borrowed self) : bool + ensures { result = completed self } + +end +module Core_Iter_Traits_Iterator_Iterator_Item_Type + type self + type item +end +module CreusotContracts_Std1_Iter_Iterator_Produces_Stub + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) +end +module CreusotContracts_Std1_Iter_Iterator_Produces_Interface + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) +end +module CreusotContracts_Std1_Iter_Iterator_Produces + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) + val produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) : bool + ensures { result = produces self visited _3' } + +end +module Core_Iter_Range_Impl3_Item_Type + type a + type item = + a +end +module Core_Iter_Range_Impl3_Next_Interface + type a + use prelude.Borrow + use seq.Seq + clone Core_Iter_Range_Impl3_Item_Type as Item1 with + type a = a + use Core_Option_Option_Type as Core_Option_Option_Type + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Iterator_Produces_Stub as Produces0 with + type self = Core_Ops_Range_Range_Type.t_range a, + type Item0.item = Item1.item + clone CreusotContracts_Std1_Iter_Iterator_Completed_Stub as Completed0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = a + val next [@cfg:stackify] (self : borrowed (Core_Ops_Range_Range_Type.t_range a)) : Core_Option_Option_Type.t_option a + requires {Invariant0.invariant' ( * self)} + ensures { Invariant0.invariant' ( ^ self) } + ensures { match (result) with + | Core_Option_Option_Type.C_None -> Completed0.completed self + | Core_Option_Option_Type.C_Some v -> Produces0.produces ( * self) (Seq.singleton v) ( ^ self) + end } + +end +module Core_Iter_Range_Impl3_Next + type a + use prelude.Borrow + use seq.Seq + clone Core_Iter_Range_Impl3_Item_Type as Item1 with + type a = a + use Core_Option_Option_Type as Core_Option_Option_Type + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Iterator_Produces_Interface as Produces0 with + type self = Core_Ops_Range_Range_Type.t_range a, + type Item0.item = Item1.item + clone CreusotContracts_Std1_Iter_Iterator_Completed_Interface as Completed0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Interface as Invariant0 with + type idx = a + val next [@cfg:stackify] (self : borrowed (Core_Ops_Range_Range_Type.t_range a)) : Core_Option_Option_Type.t_option a + requires {Invariant0.invariant' ( * self)} + ensures { Invariant0.invariant' ( ^ self) } + ensures { match (result) with + | Core_Option_Option_Type.C_None -> Completed0.completed self + | Core_Option_Option_Type.C_Some v -> Produces0.produces ( * self) (Seq.singleton v) ( ^ self) + end } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = idx, + type DeepModelTy0.deepModelTy = int + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + + = + Core_Ops_Range_Range_Type.range_end self = Core_Ops_Range_Range_Type.range_end o /\ DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) <= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) /\ (Seq.length visited > 0 -> DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) <= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_end o)) /\ Seq.length visited = DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) - DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) /\ (forall i : int . 0 <= i /\ i < Seq.length visited -> DeepModel0.deep_model (Seq.get visited i) = DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) + i) + val produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) : bool + ensures { result = produces self visited o } + +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre_Stub + type i + predicate into_iter_pre (self : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre_Interface + type i + predicate into_iter_pre (self : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre + type i + clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with + type self = i + predicate into_iter_pre (self : i) = + Invariant0.invariant' self + val into_iter_pre (self : i) : bool + ensures { result = into_iter_pre self } + +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost_Stub + type i + predicate into_iter_post (self : i) (res : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost_Interface + type i + predicate into_iter_post (self : i) (res : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost + type i + predicate into_iter_post (self : i) (res : i) = + self = res + val into_iter_post (self : i) (res : i) : bool + ensures { result = into_iter_post self res } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () + axiom produces_refl_spec : forall a : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Produces0.produces a (Seq.empty ) a +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () = + () + val produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () + requires {Invariant0.invariant' a} + ensures { result = produces_refl a } + + axiom produces_refl_spec : forall a : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Produces0.produces a (Seq.empty ) a +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + + axiom produces_trans_spec : forall a : Core_Ops_Range_Range_Type.t_range idx, ab : Seq.seq idx, b : Core_Ops_Range_Range_Type.t_range idx, bc : Seq.seq idx, c : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Invariant0.invariant' b -> Invariant0.invariant' c -> Produces0.produces a ab b -> Produces0.produces b bc c -> Produces0.produces a (Seq.(++) ab bc) c +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + + = + () + val produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + requires {Invariant0.invariant' a} + requires {Invariant0.invariant' b} + requires {Invariant0.invariant' c} + requires {Produces0.produces a ab b} + requires {Produces0.produces b bc c} + ensures { result = produces_trans a ab b bc c } + + axiom produces_trans_spec : forall a : Core_Ops_Range_Range_Type.t_range idx, ab : Seq.seq idx, b : Core_Ops_Range_Range_Type.t_range idx, bc : Seq.seq idx, c : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Invariant0.invariant' b -> Invariant0.invariant' c -> Produces0.produces a ab b -> Produces0.produces b bc c -> Produces0.produces a (Seq.(++) ab bc) c +end +module CreusotContracts_Logic_Int_Impl18_DeepModel_Stub + use mach.int.Int + use prelude.UIntSize + function deep_model (self : usize) : int +end +module CreusotContracts_Logic_Int_Impl18_DeepModel_Interface + use mach.int.Int + use prelude.UIntSize + function deep_model (self : usize) : int +end +module CreusotContracts_Logic_Int_Impl18_DeepModel + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + function deep_model (self : usize) : int = + [#"../src/lib.rs" 301 10 301 29] UInt64.to_int self + val deep_model (self : usize) : int + ensures { result = deep_model self } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed_Stub + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed_Interface + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = idx, + type DeepModelTy0.deepModelTy = int + clone CreusotContracts_Resolve_Impl1_Resolve_Stub as Resolve0 with + type t = Core_Ops_Range_Range_Type.t_range idx + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) = + Resolve0.resolve self /\ DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start ( * self)) >= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_end ( * self)) + val completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) : bool + ensures { result = completed self } + +end +module VecmapCreusot_Impl1_EntryFromRef_Interface + type k + type v + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + clone VecmapCreusot_Impl6_Invariant_Stub as Invariant1 with + type k = k, + type v = v + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + use VecmapCreusot_Entry_Type as VecmapCreusot_Entry_Type + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone VecmapCreusot_Impl1_IsValidKeyrefLg_Stub as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + axiom . + val entry_from_ref [@cfg:stackify] [#"../src/lib.rs" 102 4 102 80] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key_hint : VecmapCreusot_KeyRef_Type.t_keyref k) (key : k) : VecmapCreusot_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 97 15 97 31] IsSorted0.is_sorted ( * self)} + requires {[#"../src/lib.rs" 98 15 98 48] IsValidKeyrefLg0.is_valid_keyref_lg ( * self) key_hint} + requires {[#"../src/lib.rs" 99 15 99 60] LeLog0.le_log (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key_hint)) (DeepModel0.deep_model key)} + ensures { [#"../src/lib.rs" 100 4 100 75] forall e : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v . result = VecmapCreusot_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 101 4 101 73] forall e : VecmapCreusot_VacantEntry_Type.t_vacantentry k v . result = VecmapCreusot_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + +end +module VecmapCreusot_Impl1_EntryFromRef + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.Ghost + use seq.Seq + use prelude.IntSize + use prelude.Int8 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + clone CreusotContracts_Logic_Int_Impl18_DeepModel as DeepModel5 + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with + type t = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Completed as Completed0 with + type idx = usize, + predicate Resolve0.resolve = Resolve3.resolve, + function DeepModel0.deep_model = DeepModel5.deep_model + clone Core_Iter_Range_Impl3_Item_Type as Item0 with + type a = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces as Produces0 with + type idx = usize, + function DeepModel0.deep_model = DeepModel5.deep_model + clone CreusotContracts_Std1_Ops_Impl3_Invariant as Invariant2 with + type idx = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans as ProducesTrans0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl as ProducesRefl0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter1 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPost as IntoIterPost0 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPre as IntoIterPre0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate Invariant0.invariant' = Invariant2.invariant' + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl10_DeepModel as DeepModel4 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel3 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone VecmapCreusot_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel4.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + clone VecmapCreusot_Impl10_DeepModelTy_Type as DeepModelTy1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = VecmapCreusot_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Core_Cmp_Ord_Cmp_Interface as Cmp0 with + type self = k, + function DeepModel0.deep_model = DeepModel0.deep_model, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve7 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + clone Core_Iter_Range_Impl3_Next_Interface as Next0 with + type a = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + type Item0.item = Item0.item, + predicate Completed0.completed = Completed0.completed, + predicate Produces0.produces = Produces0.produces + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Interface as IntoIter0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate IntoIterPre0.into_iter_pre = IntoIterPre0.into_iter_pre, + predicate IntoIterPost0.into_iter_post = IntoIterPost0.into_iter_post, + predicate Invariant0.invariant' = Invariant2.invariant' + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = VecmapCreusot_VecMap_Type.t_vecmap k v + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get0.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl1_IsValidKeyref_Interface as IsValidKeyref0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ToOwned0.to_owned = ToOwned0.to_owned, + predicate IsValidKeyrefLg0.is_valid_keyref_lg = IsValidKeyrefLg0.is_valid_keyref_lg, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel3.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function DeepModel1.deep_model = DeepModel2.deep_model, + function DeepModel2.deep_model = DeepModel4.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + function DeepModel3.deep_model = DeepModel0.deep_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + clone VecmapCreusot_Impl12_AsRef_Interface as AsRef0 with + type k = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + type DeepModelTy2.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + clone VecmapCreusot_Impl6_Invariant as Invariant1 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_Entry_Type as VecmapCreusot_Entry_Type + let rec cfg entry_from_ref [@cfg:stackify] [#"../src/lib.rs" 102 4 102 80] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key_hint : VecmapCreusot_KeyRef_Type.t_keyref k) (key : k) : VecmapCreusot_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 97 15 97 31] IsSorted0.is_sorted ( * self)} + requires {[#"../src/lib.rs" 98 15 98 48] IsValidKeyrefLg0.is_valid_keyref_lg ( * self) key_hint} + requires {[#"../src/lib.rs" 99 15 99 60] LeLog0.le_log (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key_hint)) (DeepModel0.deep_model key)} + ensures { [#"../src/lib.rs" 100 4 100 75] forall e : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v . result = VecmapCreusot_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 101 4 101 73] forall e : VecmapCreusot_VacantEntry_Type.t_vacantentry k v . result = VecmapCreusot_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_Entry_Type.t_entry k v; + var self_1 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var key_hint_2 : VecmapCreusot_KeyRef_Type.t_keyref k; + var key_3 : k; + var _9 : (); + var _10 : bool; + var _11 : (); + var _12 : bool; + var _13 : bool; + var _14 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _15 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _16 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _17 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _18 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _19 : (); + var min_idx_20 : usize; + var _21 : (); + var iter_22 : Core_Ops_Range_Range_Type.t_range usize; + var _23 : Core_Ops_Range_Range_Type.t_range usize; + var _24 : usize; + var _25 : usize; + var _26 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var iter_old_27 : Ghost.ghost_ty (Core_Ops_Range_Range_Type.t_range usize); + var _29 : (); + var produced_30 : Ghost.ghost_ty (Seq.seq usize); + var _33 : (); + var _37 : (); + var _38 : Core_Option_Option_Type.t_option usize; + var _39 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _40 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _41 : isize; + var i_42 : usize; + var _43 : Ghost.ghost_ty (Seq.seq usize); + var _45 : (); + var i_46 : usize; + var _47 : Core_Cmp_Ordering_Type.t_ordering; + var _48 : k; + var _49 : (k, v); + var _50 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _51 : usize; + var _52 : k; + var _53 : k; + var _54 : int8; + var _55 : (); + var _56 : VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v; + var _57 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var _58 : usize; + var _59 : k; + var _60 : (); + var _61 : (); + var _62 : bool; + var _63 : bool; + var _64 : usize; + var _65 : (); + var _66 : VecmapCreusot_VacantEntry_Type.t_vacantentry k v; + var _67 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var _68 : usize; + var _69 : k; + var _70 : (); + var i_71 : usize; + var _72 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _73 : VecmapCreusot_VacantEntry_Type.t_vacantentry k v; + var _74 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var _75 : usize; + var _76 : k; + { + self_1 <- self; + key_hint_2 <- key_hint; + key_3 <- key; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + _10 <- true; + switch (_10) + | False -> goto BB8 + | True -> goto BB3 + end + } + BB3 { + _14 <- * self_1; + _18 <- key_hint_2; + _17 <- ([#"../src/lib.rs" 103 44 103 61] AsRef0.as_ref _18); + goto BB4 + } + BB4 { + _16 <- _17; + assume { Resolve0.resolve _17 }; + _15 <- _16; + assume { Resolve1.resolve _16 }; + _13 <- ([#"../src/lib.rs" 103 22 103 62] IsValidKeyref0.is_valid_keyref _14 _15); + goto BB5 + } + BB5 { + _12 <- not _13; + switch (_12) + | False -> goto BB7 + | True -> goto BB6 + end + } + BB6 { + assume { Resolve2.resolve self_1 }; + absurd + } + BB7 { + _11 <- (); + _9 <- (); + goto BB9 + } + BB8 { + _9 <- (); + goto BB9 + } + BB9 { + min_idx_20 <- VecmapCreusot_KeyRef_Type.keyref_min_idx key_hint_2; + _24 <- min_idx_20; + _26 <- VecmapCreusot_VecMap_Type.vecmap_v ( * self_1); + _25 <- ([#"../src/lib.rs" 107 26 107 38] Len0.len _26); + goto BB10 + } + BB10 { + _23 <- Core_Ops_Range_Range_Type.C_Range _24 _25; + iter_22 <- ([#"../src/lib.rs" 106 8 106 29] IntoIter0.into_iter _23); + goto BB11 + } + BB11 { + _29 <- (); + iter_old_27 <- ([#"../src/lib.rs" 106 8 106 29] Ghost.new iter_22); + goto BB12 + } + BB12 { + _33 <- (); + produced_30 <- ([#"../src/lib.rs" 106 8 106 29] Ghost.new (Seq.empty )); + goto BB13 + } + BB13 { + goto BB14 + } + BB14 { + invariant type_invariant { [#"../src/lib.rs" 106 8 106 29] Invariant2.invariant' iter_22 }; + invariant structural { [#"../src/lib.rs" 106 8 106 29] Produces0.produces (Ghost.inner iter_old_27) (Ghost.inner produced_30) iter_22 }; + invariant t { [#"../src/lib.rs" 106 23 106 27] true }; + _40 <- borrow_mut iter_22; + iter_22 <- ^ _40; + _39 <- borrow_mut ( * _40); + _40 <- { _40 with current = ( ^ _39) }; + _38 <- ([#"../src/lib.rs" 106 8 106 29] Next0.next _39); + goto BB15 + } + BB15 { + assume { Resolve3.resolve _40 }; + switch (_38) + | Core_Option_Option_Type.C_None -> goto BB16 + | Core_Option_Option_Type.C_Some _ -> goto BB18 + end + } + BB16 { + _21 <- (); + _72 <- VecmapCreusot_VecMap_Type.vecmap_v ( * self_1); + i_71 <- ([#"../src/lib.rs" 117 16 117 28] Len0.len _72); + goto BB31 + } + BB17 { + assume { Resolve2.resolve self_1 }; + assume { Resolve4.resolve key_hint_2 }; + assume { Resolve5.resolve key_3 }; + absurd + } + BB18 { + i_42 <- Core_Option_Option_Type.some_0 _38; + _45 <- (); + _43 <- ([#"../src/lib.rs" 106 8 106 29] Ghost.new (Seq.(++) (Ghost.inner produced_30) (Seq.singleton i_42))); + goto BB19 + } + BB19 { + produced_30 <- _43; + _43 <- any Ghost.ghost_ty (Seq.seq usize); + i_46 <- i_42; + _50 <- VecmapCreusot_VecMap_Type.vecmap_v ( * self_1); + _51 <- i_46; + _49 <- ([#"../src/lib.rs" 108 18 108 27] Index0.index _50 _51); + goto BB20 + } + BB20 { + _48 <- (let (a, _) = _49 in a); + assume { Resolve6.resolve _49 }; + _53 <- key_3; + _52 <- _53; + assume { Resolve7.resolve _53 }; + _47 <- ([#"../src/lib.rs" 108 18 108 39] Cmp0.cmp _48 _52); + goto BB21 + } + BB21 { + switch (_47) + | Core_Cmp_Ordering_Type.C_Equal -> goto BB23 + | Core_Cmp_Ordering_Type.C_Greater -> goto BB26 + | _ -> goto BB22 + end + } + BB22 { + _37 <- (); + goto BB14 + } + BB23 { + _57 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _57) }; + assume { Resolve2.resolve self_1 }; + _58 <- i_46; + assume { Resolve5.resolve _59 }; + _59 <- key_3; + key_3 <- any k; + _56 <- VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry _57 _59 _58; + goto BB24 + } + BB24 { + _0 <- VecmapCreusot_Entry_Type.C_Occupied _56; + goto BB25 + } + BB25 { + goto BB35 + } + BB26 { + _64 <- i_46; + _63 <- ([#"../src/lib.rs" 111 28 111 34] _64 >= ([#"../src/lib.rs" 111 33 111 34] (1 : usize))); + _62 <- not _63; + switch (_62) + | False -> goto BB28 + | True -> goto BB27 + end + } + BB27 { + assume { Resolve2.resolve self_1 }; + absurd + } + BB28 { + _61 <- (); + _67 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _67) }; + assume { Resolve2.resolve self_1 }; + _68 <- i_46; + assume { Resolve5.resolve _69 }; + _69 <- key_3; + key_3 <- any k; + _66 <- VecmapCreusot_VacantEntry_Type.C_VacantEntry _67 _69 _68; + goto BB29 + } + BB29 { + _0 <- VecmapCreusot_Entry_Type.C_Vacant _66; + goto BB30 + } + BB30 { + goto BB35 + } + BB31 { + _74 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _74) }; + assume { Resolve2.resolve self_1 }; + _75 <- i_71; + assume { Resolve5.resolve _76 }; + _76 <- key_3; + key_3 <- any k; + _73 <- VecmapCreusot_VacantEntry_Type.C_VacantEntry _74 _76 _75; + goto BB32 + } + BB32 { + _0 <- VecmapCreusot_Entry_Type.C_Vacant _73; + goto BB33 + } + BB33 { + goto BB34 + } + BB34 { + goto BB37 + } + BB35 { + goto BB36 + } + BB36 { + goto BB37 + } + BB37 { + assume { Resolve4.resolve key_hint_2 }; + return _0 + } + +end +module Core_Cmp_Impls_Impl10_Ge_Interface + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val ge [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = GeLog0.ge_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_Impls_Impl10_Ge + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val ge [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = GeLog0.ge_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module VecmapCreusot_Impl1_FindRandomMappingAfter_Interface + type k + type v + use mach.int.Int + use seq.Seq + use prelude.Borrow + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val find_random_mapping_after [@cfg:stackify] [#"../src/lib.rs" 133 4 133 93] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (min_key_inclusive : k) : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 124 15 124 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 125 4 126 66] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive)) } + ensures { [#"../src/lib.rs" 127 4 128 66] forall i : int . forall mapping : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= 0 /\ i < UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 129 4 130 67] forall i : int . forall mapping : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 131 4 132 61] forall mapping : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping -> (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) (UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a))) in a) = (let (_, a) = mapping in a) } + +end +module VecmapCreusot_Impl1_FindRandomMappingAfter + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use prelude.Slice + use seq.Seq + use mach.int.UInt64 + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel2.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = v + clone Core_Cmp_Impls_Impl10_Ge_Interface as Ge0 with + type a = k, + type b = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + predicate GeLog0.ge_log = GeLog0.ge_log, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_Get_Interface as Get0 with + type t = (k, v), + type i = usize, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + type Output0.output = Output0.output, + predicate HasValue0.has_value = HasValue0.has_value + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + let rec cfg find_random_mapping_after [@cfg:stackify] [#"../src/lib.rs" 133 4 133 93] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (min_key_inclusive : k) : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 124 15 124 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 125 4 126 66] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive)) } + ensures { [#"../src/lib.rs" 127 4 128 66] forall i : int . forall mapping : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= 0 /\ i < UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 129 4 130 67] forall i : int . forall mapping : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 131 4 132 61] forall mapping : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping -> (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) (UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a))) in a) = (let (_, a) = mapping in a) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v); + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var min_key_inclusive_2 : k; + var _8 : Core_Result_Result_Type.t_result usize usize; + var _9 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _10 : k; + var _11 : k; + var _12 : isize; + var index_13 : usize; + var key_14 : k; + var value_15 : v; + var _16 : (k, v); + var _17 : (k, v); + var _18 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _19 : usize; + var _20 : (VecmapCreusot_KeyRef_Type.t_keyref k, v); + var _21 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _22 : k; + var _23 : usize; + var _24 : v; + var index_25 : usize; + var _26 : Core_Option_Option_Type.t_option (k, v); + var _27 : seq (k, v); + var _28 : seq (k, v); + var _29 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _30 : usize; + var _31 : isize; + var key_32 : k; + var value_33 : v; + var _34 : (); + var _35 : bool; + var _36 : bool; + var _37 : k; + var _38 : k; + var _39 : k; + var _40 : k; + var _41 : (); + var _42 : (VecmapCreusot_KeyRef_Type.t_keyref k, v); + var _43 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _44 : k; + var _45 : usize; + var _46 : v; + { + self_1 <- self; + min_key_inclusive_2 <- min_key_inclusive; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + _9 <- self_1; + _11 <- min_key_inclusive_2; + _10 <- _11; + assume { Resolve0.resolve _11 }; + _8 <- ([#"../src/lib.rs" 134 14 134 45] FindK0.find_k _9 _10); + goto BB4 + } + BB4 { + switch (_8) + | Core_Result_Result_Type.C_Ok _ -> goto BB7 + | Core_Result_Result_Type.C_Err _ -> goto BB5 + end + } + BB5 { + index_25 <- Core_Result_Result_Type.err_0 _8; + _29 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _28 <- ([#"../src/lib.rs" 139 32 139 49] Deref0.deref _29); + goto BB9 + } + BB6 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve min_key_inclusive_2 }; + absurd + } + BB7 { + index_13 <- Core_Result_Result_Type.ok_0 _8; + _18 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _19 <- index_13; + _17 <- ([#"../src/lib.rs" 136 36 136 49] Index0.index _18 _19); + goto BB8 + } + BB8 { + _16 <- _17; + assume { Resolve6.resolve _17 }; + key_14 <- (let (a, _) = _16 in a); + value_15 <- (let (_, a) = _16 in a); + assume { Resolve6.resolve _16 }; + _22 <- key_14; + assume { Resolve0.resolve key_14 }; + _23 <- index_13; + _21 <- VecmapCreusot_KeyRef_Type.C_KeyRef _22 _23; + _24 <- value_15; + assume { Resolve5.resolve value_15 }; + _20 <- (_21, _24); + _0 <- Core_Option_Option_Type.C_Some _20; + goto BB18 + } + BB9 { + _27 <- _28; + assume { Resolve3.resolve _28 }; + _30 <- index_25; + _26 <- ([#"../src/lib.rs" 139 32 139 49] Get0.get _27 _30); + goto BB10 + } + BB10 { + switch (_26) + | Core_Option_Option_Type.C_None -> goto BB11 + | Core_Option_Option_Type.C_Some _ -> goto BB13 + end + } + BB11 { + assume { Resolve4.resolve _26 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB17 + } + BB12 { + assume { Resolve2.resolve min_key_inclusive_2 }; + assume { Resolve4.resolve _26 }; + absurd + } + BB13 { + key_32 <- (let (a, _) = Core_Option_Option_Type.some_0 _26 in a); + value_33 <- (let (_, a) = Core_Option_Option_Type.some_0 _26 in a); + assume { Resolve4.resolve _26 }; + _37 <- key_32; + _40 <- min_key_inclusive_2; + _39 <- _40; + assume { Resolve0.resolve _40 }; + _38 <- _39; + assume { Resolve0.resolve _39 }; + _36 <- ([#"../src/lib.rs" 141 28 141 53] Ge0.ge _37 _38); + goto BB14 + } + BB14 { + _35 <- not _36; + switch (_35) + | False -> goto BB16 + | True -> goto BB15 + end + } + BB15 { + assume { Resolve0.resolve key_32 }; + assume { Resolve5.resolve value_33 }; + absurd + } + BB16 { + _34 <- (); + _44 <- key_32; + assume { Resolve0.resolve key_32 }; + _45 <- index_25; + _43 <- VecmapCreusot_KeyRef_Type.C_KeyRef _44 _45; + _46 <- value_33; + assume { Resolve5.resolve value_33 }; + _42 <- (_43, _46); + _0 <- Core_Option_Option_Type.C_Some _42; + goto BB17 + } + BB17 { + goto BB18 + } + BB18 { + goto BB19 + } + BB19 { + assume { Resolve2.resolve min_key_inclusive_2 }; + return _0 + } + +end +module CreusotContracts_Model_Impl3_ShallowModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl3_ShallowModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl3_ShallowModel + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + clone CreusotContracts_Model_ShallowModel_ShallowModel_Stub as ShallowModel0 with + type self = t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy = + ShallowModel0.shallow_model ( * self) + val shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module Alloc_Vec_Impl1_Insert_Interface + type t + type a + use prelude.Borrow + use seq.Seq + use mach.int.Int + use mach.int.UInt64 + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + val insert [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) (element : t) : () + ensures { Seq.length (ShallowModel0.shallow_model ( ^ self)) = Seq.length (ShallowModel1.shallow_model self) + 1 } + ensures { forall i : int . 0 <= i /\ i < UInt64.to_int index -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) i } + ensures { Seq.get (ShallowModel0.shallow_model ( ^ self)) (UInt64.to_int index) = element } + ensures { forall i : int . UInt64.to_int index < i /\ i < Seq.length (ShallowModel0.shallow_model ( ^ self)) -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) (i - 1) } + +end +module Alloc_Vec_Impl1_Insert + type t + type a + use prelude.Borrow + use seq.Seq + use mach.int.Int + use mach.int.UInt64 + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel0 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + val insert [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) (element : t) : () + ensures { Seq.length (ShallowModel0.shallow_model ( ^ self)) = Seq.length (ShallowModel1.shallow_model self) + 1 } + ensures { forall i : int . 0 <= i /\ i < UInt64.to_int index -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) i } + ensures { Seq.get (ShallowModel0.shallow_model ( ^ self)) (UInt64.to_int index) = element } + ensures { forall i : int . UInt64.to_int index < i /\ i < Seq.length (ShallowModel0.shallow_model ( ^ self)) -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) (i - 1) } + +end +module VecmapCreusot_Impl1_InsertInternal_Interface + type k + type v + use mach.int.UInt64 + use prelude.Borrow + use seq.Seq + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val insert_internal [@cfg:stackify] [#"../src/lib.rs" 365 4 365 63] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (idx : usize) (key : k) (value : v) : () + requires {[#"../src/lib.rs" 346 15 346 38] UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self)))} + ensures { [#"../src/lib.rs" 347 14 347 55] Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) = Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) + 1 } + ensures { [#"../src/lib.rs" 348 4 348 85] forall i : int . 0 <= i /\ i < UInt64.to_int idx -> Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) i } + ensures { [#"../src/lib.rs" 349 14 349 48] Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) (UInt64.to_int idx) = (key, value) } + ensures { [#"../src/lib.rs" 350 4 350 105] forall i : int . UInt64.to_int idx < i /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (i - 1) } + ensures { [#"../src/lib.rs" 351 4 351 80] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) = 0 -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 352 4 356 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx > 0 /\ UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 357 4 360 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = 0 /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 361 4 364 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + +end +module VecmapCreusot_Impl1_InsertInternal + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = VecmapCreusot_VecMap_Type.t_vecmap k v + clone Alloc_Vec_Impl1_Insert_Interface as Insert0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function ShallowModel1.shallow_model = ShallowModel1.shallow_model, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg insert_internal [@cfg:stackify] [#"../src/lib.rs" 365 4 365 63] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (idx : usize) (key : k) (value : v) : () + requires {[#"../src/lib.rs" 346 15 346 38] UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self)))} + ensures { [#"../src/lib.rs" 347 14 347 55] Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) = Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) + 1 } + ensures { [#"../src/lib.rs" 348 4 348 85] forall i : int . 0 <= i /\ i < UInt64.to_int idx -> Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) i } + ensures { [#"../src/lib.rs" 349 14 349 48] Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) (UInt64.to_int idx) = (key, value) } + ensures { [#"../src/lib.rs" 350 4 350 105] forall i : int . UInt64.to_int idx < i /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (i - 1) } + ensures { [#"../src/lib.rs" 351 4 351 80] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) = 0 -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 352 4 356 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx > 0 /\ UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 357 4 360 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = 0 /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 361 4 364 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var idx_2 : usize; + var key_3 : k; + var value_4 : v; + var _14 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _15 : usize; + var _16 : (k, v); + var _17 : k; + var _18 : v; + { + self_1 <- self; + idx_2 <- idx; + key_3 <- key; + value_4 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + goto BB4 + } + BB4 { + _14 <- borrow_mut (VecmapCreusot_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let VecmapCreusot_VecMap_Type.C_VecMap a = * self_1 in VecmapCreusot_VecMap_Type.C_VecMap ( ^ _14)) }; + _15 <- idx_2; + assume { Resolve0.resolve _17 }; + _17 <- key_3; + key_3 <- any k; + assume { Resolve1.resolve _18 }; + _18 <- value_4; + value_4 <- any v; + _16 <- (_17, _18); + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + _0 <- ([#"../src/lib.rs" 366 8 366 40] Insert0.insert _14 _15 _16); + goto BB7 + } + BB7 { + assume { Resolve2.resolve self_1 }; + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + return _0 + } + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Stub + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Interface + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + + val resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) : bool + ensures { result = resolve_elswhere self old' fin } + +end +module Alloc_Vec_Impl17_IndexMut_Interface + type t + type i + type a + use prelude.Borrow + use seq.Seq + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Stub as ResolveElswhere0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index_mut [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : i) : borrowed Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) ( * result) } + ensures { HasValue0.has_value index (ShallowModel1.shallow_model ( ^ self)) ( ^ result) } + ensures { ResolveElswhere0.resolve_elswhere index (ShallowModel0.shallow_model self) (ShallowModel1.shallow_model ( ^ self)) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) } + +end +module Alloc_Vec_Impl17_IndexMut + type t + type i + type a + use prelude.Borrow + use seq.Seq + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Interface as ResolveElswhere0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index_mut [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : i) : borrowed Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) ( * result) } + ensures { HasValue0.has_value index (ShallowModel1.shallow_model ( ^ self)) ( ^ result) } + ensures { ResolveElswhere0.resolve_elswhere index (ShallowModel0.shallow_model self) (ShallowModel1.shallow_model ( ^ self)) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) } + +end +module Core_Mem_Replace_Interface + type t + use prelude.Borrow + val replace [@cfg:stackify] (dest : borrowed t) (src : t) : t + ensures { ^ dest = src } + ensures { result = * dest } + +end +module Core_Mem_Replace + type t + use prelude.Borrow + val replace [@cfg:stackify] (dest : borrowed t) (src : t) : t + ensures { ^ dest = src } + ensures { result = * dest } + +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) = + forall i : int . 0 <= i /\ i <> UInt64.to_int self /\ i < Seq.length old' -> Seq.get old' i = Seq.get fin i + val resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) : bool + ensures { result = resolve_elswhere self old' fin } + +end +module VecmapCreusot_Impl1_Insert_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val insert [@cfg:stackify] [#"../src/lib.rs" 154 4 154 59] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key : k) (value : v) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 151 4 151 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 151 4 151 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 152 4 153 86] exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (KeySeq0.key_seq ( ^ self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) i in a) = value } + +end +module VecmapCreusot_Impl1_Insert + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve5 with + type t = v + clone Core_Mem_Replace_Interface as Replace0 with + type t = v + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve4 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_InsertInternal_Interface as InsertInternal0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = VecmapCreusot_VecMap_Type.t_vecmap k v + use Core_Result_Result_Type as Core_Result_Result_Type + clone VecmapCreusot_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg insert [@cfg:stackify] [#"../src/lib.rs" 154 4 154 59] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key : k) (value : v) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 151 4 151 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 151 4 151 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 152 4 153 86] exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (KeySeq0.key_seq ( ^ self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self))) i in a) = value } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var key_2 : k; + var value_3 : v; + var _7 : Core_Result_Result_Type.t_result usize usize; + var _8 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _9 : k; + var _10 : k; + var _11 : isize; + var index_12 : usize; + var _13 : v; + var _14 : borrowed v; + var _15 : borrowed v; + var _16 : borrowed (k, v); + var _17 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _18 : usize; + var _19 : v; + var index_20 : usize; + var _21 : (); + var _22 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var _23 : usize; + var _24 : k; + var _25 : v; + { + self_1 <- self; + key_2 <- key; + value_3 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + _8 <- * self_1; + _10 <- key_2; + _9 <- _10; + assume { Resolve0.resolve _10 }; + _7 <- ([#"../src/lib.rs" 155 14 155 31] FindK0.find_k _8 _9); + goto BB2 + } + BB2 { + switch (_7) + | Core_Result_Result_Type.C_Ok _ -> goto BB5 + | Core_Result_Result_Type.C_Err _ -> goto BB3 + end + } + BB3 { + index_20 <- Core_Result_Result_Type.err_0 _7; + _22 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _22) }; + _23 <- index_20; + assume { Resolve2.resolve _24 }; + _24 <- key_2; + key_2 <- any k; + assume { Resolve3.resolve _25 }; + _25 <- value_3; + value_3 <- any v; + _21 <- ([#"../src/lib.rs" 158 16 158 55] InsertInternal0.insert_internal _22 _23 _24 _25); + goto BB9 + } + BB4 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + assume { Resolve3.resolve value_3 }; + absurd + } + BB5 { + index_12 <- Core_Result_Result_Type.ok_0 _7; + _17 <- borrow_mut (VecmapCreusot_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let VecmapCreusot_VecMap_Type.C_VecMap a = * self_1 in VecmapCreusot_VecMap_Type.C_VecMap ( ^ _17)) }; + assume { Resolve1.resolve self_1 }; + _18 <- index_12; + _16 <- ([#"../src/lib.rs" 156 53 156 66] IndexMut0.index_mut _17 _18); + goto BB6 + } + BB6 { + _15 <- borrow_mut (let (_, a) = * _16 in a); + _16 <- { _16 with current = (let (a, b) = * _16 in (a, ^ _15)) }; + assume { Resolve4.resolve _16 }; + _14 <- borrow_mut ( * _15); + _15 <- { _15 with current = ( ^ _14) }; + assume { Resolve3.resolve _19 }; + _19 <- value_3; + value_3 <- any v; + _13 <- ([#"../src/lib.rs" 156 30 156 76] Replace0.replace _14 _19); + goto BB7 + } + BB7 { + assume { Resolve5.resolve _15 }; + _0 <- Core_Option_Option_Type.C_Some _13; + goto BB8 + } + BB8 { + goto BB10 + } + BB9 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB10 + } + BB10 { + goto BB11 + } + BB11 { + goto BB12 + } + BB12 { + return _0 + } + +end +module Alloc_Vec_Impl1_Remove_Interface + type t + type a + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + use seq_ext.SeqExt + use prelude.UIntSize + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val remove [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) : t + requires {UInt64.to_int index < Seq.length (ShallowModel0.shallow_model self)} + ensures { result = Seq.get (ShallowModel0.shallow_model self) (UInt64.to_int index) } + ensures { ShallowModel1.shallow_model ( ^ self) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model self) 0 (UInt64.to_int index)) (SeqExt.subsequence (ShallowModel0.shallow_model self) (UInt64.to_int index + 1) (Seq.length (ShallowModel0.shallow_model self))) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) - 1 } + +end +module Alloc_Vec_Impl1_Remove + type t + type a + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + use seq_ext.SeqExt + use prelude.UIntSize + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val remove [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) : t + requires {UInt64.to_int index < Seq.length (ShallowModel0.shallow_model self)} + ensures { result = Seq.get (ShallowModel0.shallow_model self) (UInt64.to_int index) } + ensures { ShallowModel1.shallow_model ( ^ self) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model self) 0 (UInt64.to_int index)) (SeqExt.subsequence (ShallowModel0.shallow_model self) (UInt64.to_int index + 1) (Seq.length (ShallowModel0.shallow_model self))) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) - 1 } + +end +module CreusotContracts_Resolve_Impl0_Resolve_Stub + type t1 + type t2 + predicate resolve (self : (t1, t2)) +end +module CreusotContracts_Resolve_Impl0_Resolve_Interface + type t1 + type t2 + predicate resolve (self : (t1, t2)) +end +module CreusotContracts_Resolve_Impl0_Resolve + type t1 + type t2 + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve1 with + type self = t2 + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve0 with + type self = t1 + predicate resolve (self : (t1, t2)) = + Resolve0.resolve (let (a, _) = self in a) /\ Resolve1.resolve (let (_, a) = self in a) + val resolve (self : (t1, t2)) : bool + ensures { result = resolve self } + +end +module VecmapCreusot_Impl1_Remove_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + use seq_ext.SeqExt + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val remove [@cfg:stackify] [#"../src/lib.rs" 176 4 176 50] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 166 4 166 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 166 4 166 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 167 4 169 30] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq ( * self)) (DeepModel0.deep_model key) /\ * self = ^ self } + ensures { [#"../src/lib.rs" 170 4 175 17] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) -> Seq.get (KeySeq0.key_seq ( * self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) i in a) = v /\ ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self)) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) 0 i) (SeqExt.subsequence (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (i + 1) (Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self)))))) } + +end +module VecmapCreusot_Impl1_Remove + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + use seq_ext.SeqExt + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = v + clone CreusotContracts_Resolve_Impl0_Resolve as Resolve3 with + type t1 = k, + type t2 = v, + predicate Resolve0.resolve = Resolve4.resolve, + predicate Resolve1.resolve = Resolve2.resolve + clone Alloc_Vec_Impl1_Remove_Interface as Remove0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = VecmapCreusot_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg remove [@cfg:stackify] [#"../src/lib.rs" 176 4 176 50] (self : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v)) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 166 4 166 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 166 4 166 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 167 4 169 30] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq ( * self)) (DeepModel0.deep_model key) /\ * self = ^ self } + ensures { [#"../src/lib.rs" 170 4 175 17] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) -> Seq.get (KeySeq0.key_seq ( * self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) i in a) = v /\ ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( ^ self)) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) 0 i) (SeqExt.subsequence (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self))) (i + 1) (Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * self)))))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var key_2 : k; + var _7 : Core_Result_Result_Type.t_result usize usize; + var _8 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _9 : k; + var _10 : isize; + var index_11 : usize; + var _12 : v; + var _13 : (k, v); + var _14 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _15 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _8 <- * self_1; + _9 <- key_2; + assume { Resolve0.resolve key_2 }; + _7 <- ([#"../src/lib.rs" 177 14 177 30] FindK0.find_k _8 _9); + goto BB1 + } + BB1 { + switch (_7) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB8 + } + BB3 { + assume { Resolve1.resolve self_1 }; + absurd + } + BB4 { + index_11 <- Core_Result_Result_Type.ok_0 _7; + _14 <- borrow_mut (VecmapCreusot_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let VecmapCreusot_VecMap_Type.C_VecMap a = * self_1 in VecmapCreusot_VecMap_Type.C_VecMap ( ^ _14)) }; + _15 <- index_11; + _13 <- ([#"../src/lib.rs" 178 30 178 50] Remove0.remove _14 _15); + goto BB5 + } + BB5 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve _12 }; + _12 <- (let (_, a) = _13 in a); + _13 <- (let (a, b) = _13 in (a, any v)); + _0 <- Core_Option_Option_Type.C_Some _12; + goto BB6 + } + BB6 { + goto BB7 + } + BB7 { + assume { Resolve3.resolve _13 }; + goto BB8 + } + BB8 { + return _0 + } + +end +module VecmapCreusot_Impl1_Get_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val get [@cfg:stackify] [#"../src/lib.rs" 189 4 189 44] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 184 15 184 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 185 4 185 77] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 186 4 188 77] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) i in a) = v) } + +end +module VecmapCreusot_Impl1_Get + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg get [@cfg:stackify] [#"../src/lib.rs" 189 4 189 44] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 184 15 184 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 185 4 185 77] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 186 4 188 77] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) i in a) = v) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var key_2 : k; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _8 : k; + var _9 : isize; + var index_10 : usize; + var _11 : v; + var _12 : v; + var _13 : (k, v); + var _14 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _15 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- self_1; + _8 <- key_2; + assume { Resolve0.resolve key_2 }; + _6 <- ([#"../src/lib.rs" 190 14 190 30] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + switch (_6) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB3 { + assume { Resolve1.resolve self_1 }; + absurd + } + BB4 { + index_10 <- Core_Result_Result_Type.ok_0 _6; + _14 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _15 <- index_10; + _13 <- ([#"../src/lib.rs" 191 31 191 44] Index0.index _14 _15); + goto BB5 + } + BB5 { + _12 <- (let (_, a) = _13 in a); + assume { Resolve2.resolve _13 }; + _11 <- _12; + assume { Resolve3.resolve _12 }; + _0 <- Core_Option_Option_Type.C_Some _11; + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Result_Impl0_IsOk_Interface + type t + type e + use prelude.Borrow + use Core_Result_Result_Type as Core_Result_Result_Type + val is_ok [@cfg:stackify] (self : Core_Result_Result_Type.t_result t e) : bool + ensures { result = (exists t : t . self = Core_Result_Result_Type.C_Ok t) } + +end +module Core_Result_Impl0_IsOk + type t + type e + use prelude.Borrow + use Core_Result_Result_Type as Core_Result_Result_Type + val is_ok [@cfg:stackify] (self : Core_Result_Result_Type.t_result t e) : bool + ensures { result = (exists t : t . self = Core_Result_Result_Type.C_Ok t) } + +end +module VecmapCreusot_Impl1_ContainsKey_Interface + type k + type v + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val contains_key [@cfg:stackify] [#"../src/lib.rs" 199 4 199 47] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : k) : bool + requires {[#"../src/lib.rs" 197 15 197 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 198 14 198 65] result = Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + +end +module VecmapCreusot_Impl1_ContainsKey + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Core_Result_Impl0_IsOk_Interface as IsOk0 with + type t = usize, + type e = usize + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + let rec cfg contains_key [@cfg:stackify] [#"../src/lib.rs" 199 4 199 47] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : k) : bool + requires {[#"../src/lib.rs" 197 15 197 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 198 14 198 65] result = Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : bool; + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var key_2 : k; + var _5 : Core_Result_Result_Type.t_result usize usize; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _8 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- self_1; + assume { Resolve0.resolve self_1 }; + _8 <- key_2; + assume { Resolve1.resolve key_2 }; + _6 <- ([#"../src/lib.rs" 200 8 200 24] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + _5 <- _6; + _0 <- ([#"../src/lib.rs" 200 8 200 32] IsOk0.is_ok _5); + goto BB2 + } + BB2 { + return _0 + } + +end +module Core_Cmp_PartialOrd_Gt_Interface + type self + type rhs + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = rhs, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val gt [@cfg:stackify] (self : self) (other : rhs) : bool + ensures { result = GtLog0.gt_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_PartialOrd_Gt + type self + type rhs + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = rhs, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val gt [@cfg:stackify] (self : self) (other : rhs) : bool + ensures { result = GtLog0.gt_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module VecmapCreusot_Impl1_NextMapping_Interface + type k + type v + use mach.int.Int + use seq.Seq + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val next_mapping [@cfg:stackify] [#"../src/lib.rs" 217 4 217 75] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 205 15 205 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 206 4 208 57] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key))) } + ensures { [#"../src/lib.rs" 209 4 216 57] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a)) /\ GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key)) /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) i in a) = (let (_, a) = entry in a) /\ (forall j : int . j >= 0 /\ j < i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a))) /\ LeLog0.le_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key)))) } + +end +module VecmapCreusot_Impl1_NextMapping + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.Ghost + use seq.Seq + use prelude.IntSize + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + clone CreusotContracts_Logic_Int_Impl18_DeepModel as DeepModel4 + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Completed as Completed0 with + type idx = usize, + predicate Resolve0.resolve = Resolve1.resolve, + function DeepModel0.deep_model = DeepModel4.deep_model + clone Core_Iter_Range_Impl3_Item_Type as Item0 with + type a = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces as Produces0 with + type idx = usize, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Std1_Ops_Impl3_Invariant as Invariant0 with + type idx = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans as ProducesTrans0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl as ProducesRefl0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter1 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPost as IntoIterPost0 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPre as IntoIterPre0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate Invariant0.invariant' = Invariant0.invariant' + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl10_DeepModel as DeepModel3 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get0.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = k + clone Core_Cmp_PartialOrd_Gt_Interface as Gt0 with + type self = k, + type rhs = k, + function DeepModel0.deep_model = DeepModel0.deep_model, + function DeepModel1.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + clone Core_Iter_Range_Impl3_Next_Interface as Next0 with + type a = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + type Item0.item = Item0.item, + predicate Completed0.completed = Completed0.completed, + predicate Produces0.produces = Produces0.produces + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Interface as IntoIter0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate IntoIterPre0.into_iter_pre = IntoIterPre0.into_iter_pre, + predicate IntoIterPost0.into_iter_post = IntoIterPost0.into_iter_post, + predicate Invariant0.invariant' = Invariant0.invariant' + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone VecmapCreusot_Impl1_IsValidKeyref_Interface as IsValidKeyref0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ToOwned0.to_owned = ToOwned0.to_owned, + predicate IsValidKeyrefLg0.is_valid_keyref_lg = IsValidKeyrefLg0.is_valid_keyref_lg, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function DeepModel1.deep_model = DeepModel2.deep_model, + function DeepModel2.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + function DeepModel3.deep_model = DeepModel1.deep_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + let rec cfg next_mapping [@cfg:stackify] [#"../src/lib.rs" 217 4 217 75] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) (key : VecmapCreusot_KeyRef_Type.t_keyref k) : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 205 15 205 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 206 4 208 57] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key))) } + ensures { [#"../src/lib.rs" 209 4 216 57] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a)) /\ GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key)) /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) i in a) = (let (_, a) = entry in a) /\ (forall j : int . j >= 0 /\ j < i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a))) /\ LeLog0.le_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key)))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v); + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var key_2 : VecmapCreusot_KeyRef_Type.t_keyref k; + var from_6 : usize; + var _7 : bool; + var _8 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _9 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _10 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _11 : (); + var iter_12 : Core_Ops_Range_Range_Type.t_range usize; + var _13 : Core_Ops_Range_Range_Type.t_range usize; + var _14 : usize; + var _15 : usize; + var _16 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var iter_old_17 : Ghost.ghost_ty (Core_Ops_Range_Range_Type.t_range usize); + var _19 : (); + var produced_20 : Ghost.ghost_ty (Seq.seq usize); + var _23 : (); + var _27 : (); + var _28 : Core_Option_Option_Type.t_option usize; + var _29 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _30 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _31 : isize; + var i_32 : usize; + var _33 : Ghost.ghost_ty (Seq.seq usize); + var _35 : (); + var idx_36 : usize; + var _37 : bool; + var _38 : k; + var _39 : (k, v); + var _40 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _41 : usize; + var _42 : k; + var _43 : (); + var key_44 : k; + var value_45 : v; + var _46 : (k, v); + var _47 : (k, v); + var _48 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _49 : usize; + var _50 : (VecmapCreusot_KeyRef_Type.t_keyref k, v); + var _51 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _52 : usize; + var _53 : k; + var _54 : v; + var _55 : (); + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _8 <- self_1; + _10 <- key_2; + _9 <- _10; + assume { Resolve0.resolve _10 }; + _7 <- ([#"../src/lib.rs" 218 22 218 48] IsValidKeyref0.is_valid_keyref _8 _9); + goto BB1 + } + BB1 { + switch (_7) + | False -> goto BB3 + | True -> goto BB2 + end + } + BB2 { + from_6 <- VecmapCreusot_KeyRef_Type.keyref_min_idx key_2; + goto BB4 + } + BB3 { + from_6 <- ([#"../src/lib.rs" 221 12 221 13] (0 : usize)); + goto BB4 + } + BB4 { + _14 <- from_6; + _16 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + _15 <- ([#"../src/lib.rs" 226 25 226 37] Len0.len _16); + goto BB5 + } + BB5 { + _13 <- Core_Ops_Range_Range_Type.C_Range _14 _15; + iter_12 <- ([#"../src/lib.rs" 224 8 225 63] IntoIter0.into_iter _13); + goto BB6 + } + BB6 { + _19 <- (); + iter_old_17 <- ([#"../src/lib.rs" 224 8 225 63] Ghost.new iter_12); + goto BB7 + } + BB7 { + _23 <- (); + produced_20 <- ([#"../src/lib.rs" 224 8 225 63] Ghost.new (Seq.empty )); + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + invariant type_invariant { [#"../src/lib.rs" 224 8 225 63] Invariant0.invariant' iter_12 }; + invariant structural { [#"../src/lib.rs" 224 8 225 63] Produces0.produces (Ghost.inner iter_old_17) (Ghost.inner produced_20) iter_12 }; + invariant prev_leq { [#"../src/lib.rs" 224 8 225 63] forall j : int . j >= 0 /\ j < Seq.length (Ghost.inner produced_20) + UInt64.to_int from_6 -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self_1) j) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key key_2)) }; + _30 <- borrow_mut iter_12; + iter_12 <- ^ _30; + _29 <- borrow_mut ( * _30); + _30 <- { _30 with current = ( ^ _29) }; + _28 <- ([#"../src/lib.rs" 224 8 225 63] Next0.next _29); + goto BB10 + } + BB10 { + assume { Resolve1.resolve _30 }; + switch (_28) + | Core_Option_Option_Type.C_None -> goto BB11 + | Core_Option_Option_Type.C_Some _ -> goto BB13 + end + } + BB11 { + assume { Resolve2.resolve self_1 }; + assume { Resolve3.resolve key_2 }; + _11 <- (); + _0 <- Core_Option_Option_Type.C_None; + goto BB20 + } + BB12 { + assume { Resolve2.resolve self_1 }; + assume { Resolve3.resolve key_2 }; + absurd + } + BB13 { + i_32 <- Core_Option_Option_Type.some_0 _28; + _35 <- (); + _33 <- ([#"../src/lib.rs" 224 8 225 63] Ghost.new (Seq.(++) (Ghost.inner produced_20) (Seq.singleton i_32))); + goto BB14 + } + BB14 { + produced_20 <- _33; + _33 <- any Ghost.ghost_ty (Seq.seq usize); + idx_36 <- i_32; + _40 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + _41 <- idx_36; + _39 <- ([#"../src/lib.rs" 227 15 227 26] Index0.index _40 _41); + goto BB15 + } + BB15 { + _38 <- (let (a, _) = _39 in a); + assume { Resolve4.resolve _39 }; + _42 <- VecmapCreusot_KeyRef_Type.keyref_key key_2; + _37 <- ([#"../src/lib.rs" 227 15 227 39] Gt0.gt _38 _42); + goto BB16 + } + BB16 { + switch (_37) + | False -> goto BB19 + | True -> goto BB17 + end + } + BB17 { + assume { Resolve3.resolve key_2 }; + _48 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve2.resolve self_1 }; + _49 <- idx_36; + _47 <- ([#"../src/lib.rs" 228 36 228 47] Index0.index _48 _49); + goto BB18 + } + BB18 { + _46 <- _47; + assume { Resolve4.resolve _47 }; + key_44 <- (let (a, _) = _46 in a); + value_45 <- (let (_, a) = _46 in a); + assume { Resolve4.resolve _46 }; + _52 <- idx_36; + _53 <- key_44; + assume { Resolve5.resolve key_44 }; + _51 <- VecmapCreusot_KeyRef_Type.C_KeyRef _53 _52; + _54 <- value_45; + assume { Resolve6.resolve value_45 }; + _50 <- (_51, _54); + _0 <- Core_Option_Option_Type.C_Some _50; + goto BB20 + } + BB19 { + _27 <- (); + goto BB9 + } + BB20 { + return _0 + } + +end +module Core_Slice_Impl0_First_Interface + type t + use seq.Seq + use prelude.Borrow + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val first [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) 0 = x } + +end +module Core_Slice_Impl0_First + type t + use seq.Seq + use prelude.Borrow + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val first [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) 0 = x } + +end +module VecmapCreusot_Impl1_MinEntry_Interface + type k + type v + use seq.Seq + use prelude.Borrow + use mach.int.UInt64 + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + use Core_Option_Option_Type as Core_Option_Option_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val min_entry [@cfg:stackify] [#"../src/lib.rs" 274 4 274 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 267 15 267 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 268 4 268 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 269 4 269 101] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) 0 = (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a), let (_, a) = entry in a) } + ensures { [#"../src/lib.rs" 270 4 270 80] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = entry in a)) = 0 } + ensures { [#"../src/lib.rs" 271 4 273 6] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a)))) } + +end +module VecmapCreusot_Impl1_MinEntry + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.IntSize + use mach.int.UInt64 + use prelude.UIntSize + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_First_Interface as First0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + let rec cfg min_entry [@cfg:stackify] [#"../src/lib.rs" 274 4 274 55] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 267 15 267 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 268 4 268 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 269 4 269 101] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) 0 = (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a), let (_, a) = entry in a) } + ensures { [#"../src/lib.rs" 270 4 270 80] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> UInt64.to_int (VecmapCreusot_KeyRef_Type.keyref_min_idx (let (a, _) = entry in a)) = 0 } + ensures { [#"../src/lib.rs" 271 4 273 6] forall entry : (VecmapCreusot_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (VecmapCreusot_KeyRef_Type.keyref_key (let (a, _) = entry in a)))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (VecmapCreusot_KeyRef_Type.t_keyref k, v); + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _7 : Core_Option_Option_Type.t_option (k, v); + var _8 : seq (k, v); + var _9 : seq (k, v); + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _11 : isize; + var key_12 : k; + var value_13 : v; + var _14 : (VecmapCreusot_KeyRef_Type.t_keyref k, v); + var _15 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _16 : k; + var _17 : v; + { + self_1 <- self; + goto BB0 + } + BB0 { + _10 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _9 <- ([#"../src/lib.rs" 276 14 276 28] Deref0.deref _10); + goto BB1 + } + BB1 { + _8 <- _9; + assume { Resolve1.resolve _9 }; + _7 <- ([#"../src/lib.rs" 276 14 276 28] First0.first _8); + goto BB2 + } + BB2 { + switch (_7) + | Core_Option_Option_Type.C_None -> goto BB3 + | Core_Option_Option_Type.C_Some _ -> goto BB5 + end + } + BB3 { + assume { Resolve2.resolve _7 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB4 { + assume { Resolve2.resolve _7 }; + absurd + } + BB5 { + key_12 <- (let (a, _) = Core_Option_Option_Type.some_0 _7 in a); + value_13 <- (let (_, a) = Core_Option_Option_Type.some_0 _7 in a); + assume { Resolve2.resolve _7 }; + _16 <- key_12; + assume { Resolve3.resolve key_12 }; + _15 <- VecmapCreusot_KeyRef_Type.C_KeyRef _16 ([#"../src/lib.rs" 277 63 277 64] (0 : usize)); + _17 <- value_13; + assume { Resolve4.resolve value_13 }; + _14 <- (_15, _17); + _0 <- Core_Option_Option_Type.C_Some _14; + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Slice_Impl0_Last_Interface + type t + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val last [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) (Seq.length (ShallowModel0.shallow_model self) - 1) = x } + +end +module Core_Slice_Impl0_Last + type t + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val last [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) (Seq.length (ShallowModel0.shallow_model self) - 1) = x } + +end +module VecmapCreusot_Impl1_MaxKey_Interface + type k + type v + use seq.Seq + use prelude.Borrow + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val max_key [@cfg:stackify] [#"../src/lib.rs" 289 4 289 39] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option k + requires {[#"../src/lib.rs" 283 15 283 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 284 4 284 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 285 4 288 6] forall k : k . result = Core_Option_Option_Type.C_Some k -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model k)) } + +end +module VecmapCreusot_Impl1_MaxKey + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.IntSize + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = (k, v) + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_Last_Interface as Last0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg max_key [@cfg:stackify] [#"../src/lib.rs" 289 4 289 39] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option k + requires {[#"../src/lib.rs" 283 15 283 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 284 4 284 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 285 4 288 6] forall k : k . result = Core_Option_Option_Type.C_Some k -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model k)) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option k; + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _5 : Core_Option_Option_Type.t_option (k, v); + var _6 : seq (k, v); + var _7 : seq (k, v); + var _8 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _9 : isize; + var e_10 : (k, v); + var _11 : k; + var _12 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _8 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _7 <- ([#"../src/lib.rs" 290 14 290 27] Deref0.deref _8); + goto BB1 + } + BB1 { + _6 <- _7; + assume { Resolve1.resolve _7 }; + _5 <- ([#"../src/lib.rs" 290 14 290 27] Last0.last _6); + goto BB2 + } + BB2 { + switch (_5) + | Core_Option_Option_Type.C_None -> goto BB3 + | Core_Option_Option_Type.C_Some _ -> goto BB5 + end + } + BB3 { + assume { Resolve2.resolve _5 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB4 { + assume { Resolve2.resolve _5 }; + absurd + } + BB5 { + assume { Resolve3.resolve e_10 }; + e_10 <- Core_Option_Option_Type.some_0 _5; + assume { Resolve2.resolve _5 }; + _12 <- (let (a, _) = e_10 in a); + assume { Resolve3.resolve e_10 }; + _11 <- _12; + assume { Resolve4.resolve _12 }; + _0 <- Core_Option_Option_Type.C_Some _11; + goto BB6 + } + BB6 { + return _0 + } + +end +module Alloc_Vec_Impl14_Clone_Interface + type t + type a + use prelude.Borrow + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + val clone' [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : Alloc_Vec_Vec_Type.t_vec t a + ensures { result = self } + +end +module Alloc_Vec_Impl14_Clone + type t + type a + use prelude.Borrow + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + val clone' [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : Alloc_Vec_Vec_Type.t_vec t a + ensures { result = self } + +end +module VecmapCreusot_Impl2_Clone_Interface + type k + type v + use prelude.Borrow + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + val clone' [@cfg:stackify] [#"../src/lib.rs" 372 4 372 27] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : VecmapCreusot_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 371 14 371 29] result = self } + +end +module VecmapCreusot_Impl2_Clone + type k + type v + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Alloc_Vec_Impl14_Clone_Interface as Clone0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v + let rec cfg clone' [@cfg:stackify] [#"../src/lib.rs" 372 4 372 27] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : VecmapCreusot_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 371 14 371 29] result = self } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var self_1 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _3 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _4 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + self_1 <- self; + goto BB0 + } + BB0 { + _4 <- VecmapCreusot_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _3 <- ([#"../src/lib.rs" 373 20 373 34] Clone0.clone' _4); + goto BB1 + } + BB1 { + _0 <- VecmapCreusot_VecMap_Type.C_VecMap _3; + goto BB2 + } + BB2 { + return _0 + } + +end +module VecmapCreusot_Impl4_IsDefault_Stub + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + predicate is_default [#"../src/lib.rs" 396 4 396 31] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) +end +module VecmapCreusot_Impl4_IsDefault_Interface + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + predicate is_default [#"../src/lib.rs" 396 4 396 31] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) +end +module VecmapCreusot_Impl4_IsDefault + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + predicate is_default [#"../src/lib.rs" 396 4 396 31] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) = + [#"../src/lib.rs" 397 20 397 40] Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v self)) = 0 + val is_default [#"../src/lib.rs" 396 4 396 31] (self : VecmapCreusot_VecMap_Type.t_vecmap k v) : bool + ensures { result = is_default self } + +end +module VecmapCreusot_Impl3_Default_Interface + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl4_IsDefault_Stub as IsDefault0 with + type k = k, + type v = v + val default [@cfg:stackify] [#"../src/lib.rs" 386 4 386 24] (_1' : ()) : VecmapCreusot_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 385 14 385 33] IsDefault0.is_default result } + +end +module VecmapCreusot_Impl3_Default + type k + type v + clone Core_Num_Impl12_Max as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Alloc_Vec_Impl0_New_Interface as New0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl4_IsDefault as IsDefault0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + let rec cfg default [@cfg:stackify] [#"../src/lib.rs" 386 4 386 24] (_1' : ()) : VecmapCreusot_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 385 14 385 33] IsDefault0.is_default result } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_VecMap_Type.t_vecmap k v; + var _2 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + goto BB0 + } + BB0 { + _2 <- ([#"../src/lib.rs" 387 18 387 28] New0.new ()); + goto BB1 + } + BB1 { + _0 <- VecmapCreusot_VecMap_Type.C_VecMap _2; + goto BB2 + } + BB2 { + return _0 + } + +end +module VecmapCreusot_Impl5_Keyref_Interface + type k + type v + use prelude.Borrow + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + use VecmapCreusot_Entry_Type as VecmapCreusot_Entry_Type + val keyref [@cfg:stackify] [#"../src/lib.rs" 442 4 442 38] (self : VecmapCreusot_Entry_Type.t_entry k v) : VecmapCreusot_KeyRef_Type.t_keyref k + requires {[#"../src/lib.rs" 438 15 441 5] match (self) with + | VecmapCreusot_Entry_Type.C_Vacant (VecmapCreusot_VacantEntry_Type.C_VacantEntry map _ _) -> IsSorted0.is_sorted ( * map) + | VecmapCreusot_Entry_Type.C_Occupied (VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry map _ _) -> IsSorted0.is_sorted ( * map) + end} + +end +module VecmapCreusot_Impl5_Keyref + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.IntSize + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + use VecmapCreusot_Entry_Type as VecmapCreusot_Entry_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_Entry_Type.t_entry k v + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + let rec cfg keyref [@cfg:stackify] [#"../src/lib.rs" 442 4 442 38] (self : VecmapCreusot_Entry_Type.t_entry k v) : VecmapCreusot_KeyRef_Type.t_keyref k + requires {[#"../src/lib.rs" 438 15 441 5] match (self) with + | VecmapCreusot_Entry_Type.C_Vacant (VecmapCreusot_VacantEntry_Type.C_VacantEntry map _ _) -> IsSorted0.is_sorted ( * map) + | VecmapCreusot_Entry_Type.C_Occupied (VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry map _ _) -> IsSorted0.is_sorted ( * map) + end} + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_KeyRef_Type.t_keyref k; + var self_1 : VecmapCreusot_Entry_Type.t_entry k v; + var _3 : isize; + var key_4 : k; + var index_5 : usize; + var _6 : usize; + var _7 : k; + var key_8 : k; + var index_9 : usize; + var _10 : usize; + var _11 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + switch (self_1) + | VecmapCreusot_Entry_Type.C_Vacant _ -> goto BB3 + | VecmapCreusot_Entry_Type.C_Occupied _ -> goto BB1 + end + } + BB1 { + key_8 <- VecmapCreusot_OccupiedEntry_Type.occupiedentry_key (VecmapCreusot_Entry_Type.occupied_0 self_1); + index_9 <- VecmapCreusot_OccupiedEntry_Type.occupiedentry_index (VecmapCreusot_Entry_Type.occupied_0 self_1); + assume { Resolve0.resolve self_1 }; + _10 <- index_9; + _11 <- key_8; + assume { Resolve1.resolve key_8 }; + _0 <- VecmapCreusot_KeyRef_Type.C_KeyRef _11 _10; + goto BB4 + } + BB2 { + assume { Resolve0.resolve self_1 }; + absurd + } + BB3 { + key_4 <- VecmapCreusot_VacantEntry_Type.vacantentry_key (VecmapCreusot_Entry_Type.vacant_0 self_1); + index_5 <- VecmapCreusot_VacantEntry_Type.vacantentry_index (VecmapCreusot_Entry_Type.vacant_0 self_1); + assume { Resolve0.resolve self_1 }; + _6 <- index_5; + _7 <- key_4; + assume { Resolve1.resolve key_4 }; + _0 <- VecmapCreusot_KeyRef_Type.C_KeyRef _7 _6; + goto BB4 + } + BB4 { + return _0 + } + +end +module VecmapCreusot_Impl15_Resolve_Stub + type k + type v + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + predicate resolve [#"../src/lib.rs" 456 4 456 28] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) +end +module VecmapCreusot_Impl15_Resolve_Interface + type k + type v + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + predicate resolve [#"../src/lib.rs" 456 4 456 28] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) +end +module VecmapCreusot_Impl15_Resolve + type k + type v + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve_Stub as Resolve0 with + type t = VecmapCreusot_VecMap_Type.t_vecmap k v + predicate resolve [#"../src/lib.rs" 456 4 456 28] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) = + [#"../src/lib.rs" 455 4 455 16] Resolve0.resolve (VecmapCreusot_VacantEntry_Type.vacantentry_map self) /\ Resolve1.resolve (VecmapCreusot_VacantEntry_Type.vacantentry_key self) + val resolve [#"../src/lib.rs" 456 4 456 28] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) : bool + ensures { result = resolve self } + +end +module VecmapCreusot_Impl7_Insert_Interface + type k + type v + use mach.int.Int + use mach.int.UInt64 + use prelude.Borrow + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + clone VecmapCreusot_Impl6_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val insert [@cfg:stackify] [#"../src/lib.rs" 486 4 486 33] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) (value : v) : () + requires {[#"../src/lib.rs" 480 15 480 31] Invariant0.invariant' self} + requires {[#"../src/lib.rs" 481 4 482 62] forall i : int . i >= 0 /\ i < UInt64.to_int (VecmapCreusot_VacantEntry_Type.vacantentry_index self) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (VecmapCreusot_VacantEntry_Type.vacantentry_key self))} + requires {[#"../src/lib.rs" 483 4 484 62] forall i : int . i >= UInt64.to_int (VecmapCreusot_VacantEntry_Type.vacantentry_index self) /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self))) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (VecmapCreusot_VacantEntry_Type.vacantentry_key self))} + ensures { [#"../src/lib.rs" 485 14 485 37] IsSorted0.is_sorted ( ^ VecmapCreusot_VacantEntry_Type.vacantentry_map self) } + +end +module VecmapCreusot_Impl7_Insert + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with + type t = VecmapCreusot_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use VecmapCreusot_VacantEntry_Type as VecmapCreusot_VacantEntry_Type + clone VecmapCreusot_Impl15_Resolve as Resolve2 with + type k = k, + type v = v, + predicate Resolve0.resolve = Resolve3.resolve, + predicate Resolve1.resolve = Resolve0.resolve + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone VecmapCreusot_Impl1_InsertInternal_Interface as InsertInternal0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = v + clone VecmapCreusot_Impl6_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + let rec cfg insert [@cfg:stackify] [#"../src/lib.rs" 486 4 486 33] (self : VecmapCreusot_VacantEntry_Type.t_vacantentry k v) (value : v) : () + requires {[#"../src/lib.rs" 480 15 480 31] Invariant0.invariant' self} + requires {[#"../src/lib.rs" 481 4 482 62] forall i : int . i >= 0 /\ i < UInt64.to_int (VecmapCreusot_VacantEntry_Type.vacantentry_index self) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (VecmapCreusot_VacantEntry_Type.vacantentry_key self))} + requires {[#"../src/lib.rs" 483 4 484 62] forall i : int . i >= UInt64.to_int (VecmapCreusot_VacantEntry_Type.vacantentry_index self) /\ i < Seq.length (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self))) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (VecmapCreusot_VacantEntry_Type.vacantentry_key self))} + ensures { [#"../src/lib.rs" 485 14 485 37] IsSorted0.is_sorted ( ^ VecmapCreusot_VacantEntry_Type.vacantentry_map self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : VecmapCreusot_VacantEntry_Type.t_vacantentry k v; + var value_2 : v; + var _7 : (); + var _8 : borrowed (VecmapCreusot_VecMap_Type.t_vecmap k v); + var _9 : usize; + var _10 : k; + var _11 : v; + var _12 : (); + { + self_1 <- self; + value_2 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + _8 <- borrow_mut ( * VecmapCreusot_VacantEntry_Type.vacantentry_map self_1); + self_1 <- (let VecmapCreusot_VacantEntry_Type.C_VacantEntry a b c = self_1 in VecmapCreusot_VacantEntry_Type.C_VacantEntry ({ (VecmapCreusot_VacantEntry_Type.vacantentry_map self_1) with current = ( ^ _8) }) b c); + _9 <- VecmapCreusot_VacantEntry_Type.vacantentry_index self_1; + assume { Resolve0.resolve _10 }; + _10 <- VecmapCreusot_VacantEntry_Type.vacantentry_key self_1; + self_1 <- (let VecmapCreusot_VacantEntry_Type.C_VacantEntry a b c = self_1 in VecmapCreusot_VacantEntry_Type.C_VacantEntry a (any k) c); + assume { Resolve1.resolve _11 }; + _11 <- value_2; + value_2 <- any v; + _7 <- ([#"../src/lib.rs" 487 8 487 61] InsertInternal0.insert_internal _8 _9 _10 _11); + goto BB4 + } + BB4 { + assert { [#"../src/lib.rs" 488 22 488 38] Invariant0.invariant' self_1 }; + goto BB5 + } + BB5 { + _12 <- (); + _0 <- (); + goto BB6 + } + BB6 { + goto BB7 + } + BB7 { + assume { Resolve2.resolve self_1 }; + return _0 + } + +end +module VecmapCreusot_Impl9_Replace_Interface + type k + type v + use prelude.Borrow + use mach.int.UInt64 + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val replace [@cfg:stackify] [#"../src/lib.rs" 515 4 515 39] (self : borrowed (VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v)) (value : v) : () + requires {[#"../src/lib.rs" 513 4 513 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 513 4 513 40] Invariant0.invariant' ( ^ self) } + ensures { [#"../src/lib.rs" 514 14 514 54] (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( ^ self)))) (UInt64.to_int (VecmapCreusot_OccupiedEntry_Type.occupiedentry_index ( * self))) in a) = value } + +end +module VecmapCreusot_Impl9_Replace + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = v + clone VecmapCreusot_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg replace [@cfg:stackify] [#"../src/lib.rs" 515 4 515 39] (self : borrowed (VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v)) (value : v) : () + requires {[#"../src/lib.rs" 513 4 513 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 513 4 513 40] Invariant0.invariant' ( ^ self) } + ensures { [#"../src/lib.rs" 514 14 514 54] (let (_, a) = Seq.get (ShallowModel0.shallow_model (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( ^ self)))) (UInt64.to_int (VecmapCreusot_OccupiedEntry_Type.occupiedentry_index ( * self))) in a) = value } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : borrowed (VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v); + var value_2 : v; + var _6 : v; + var _7 : borrowed (k, v); + var _8 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _9 : usize; + { + self_1 <- self; + value_2 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + assume { Resolve0.resolve _6 }; + _6 <- value_2; + value_2 <- any v; + _8 <- borrow_mut (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( * self_1))); + self_1 <- { self_1 with current = (let VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry a b c = * self_1 in VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry ({ (VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( * self_1)) with current = (let VecmapCreusot_VecMap_Type.C_VecMap a = * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( * self_1) in VecmapCreusot_VecMap_Type.C_VecMap ( ^ _8)) }) b c) }; + _9 <- VecmapCreusot_OccupiedEntry_Type.occupiedentry_index ( * self_1); + assume { Resolve1.resolve self_1 }; + _7 <- ([#"../src/lib.rs" 516 8 516 30] IndexMut0.index_mut _8 _9); + goto BB2 + } + BB2 { + assume { Resolve0.resolve (let (_, a) = * _7 in a) }; + _7 <- { _7 with current = (let (a, b) = * _7 in (a, _6)) }; + goto BB3 + } + BB3 { + assume { Resolve2.resolve _7 }; + goto BB4 + } + BB4 { + _0 <- (); + goto BB5 + } + BB5 { + return _0 + } + +end +module VecmapCreusot_Impl9_GetMut_Interface + type k + type v + use prelude.Borrow + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone VecmapCreusot_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val get_mut [@cfg:stackify] [#"../src/lib.rs" 521 4 521 39] (self : borrowed (VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v)) : borrowed v + requires {[#"../src/lib.rs" 520 4 520 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 520 4 520 40] Invariant0.invariant' ( ^ self) } + +end +module VecmapCreusot_Impl9_GetMut + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone VecmapCreusot_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = v + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use VecmapCreusot_OccupiedEntry_Type as VecmapCreusot_OccupiedEntry_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with + type t = VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v + clone VecmapCreusot_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg get_mut [@cfg:stackify] [#"../src/lib.rs" 521 4 521 39] (self : borrowed (VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v)) : borrowed v + requires {[#"../src/lib.rs" 520 4 520 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 520 4 520 40] Invariant0.invariant' ( ^ self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : borrowed v; + var self_1 : borrowed (VecmapCreusot_OccupiedEntry_Type.t_occupiedentry k v); + var _2 : borrowed v; + var _5 : borrowed v; + var _6 : borrowed (k, v); + var _7 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _8 : usize; + { + self_1 <- self; + goto BB0 + } + BB0 { + _7 <- borrow_mut (VecmapCreusot_VecMap_Type.vecmap_v ( * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( * self_1))); + self_1 <- { self_1 with current = (let VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry a b c = * self_1 in VecmapCreusot_OccupiedEntry_Type.C_OccupiedEntry ({ (VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( * self_1)) with current = (let VecmapCreusot_VecMap_Type.C_VecMap a = * VecmapCreusot_OccupiedEntry_Type.occupiedentry_map ( * self_1) in VecmapCreusot_VecMap_Type.C_VecMap ( ^ _7)) }) b c) }; + _8 <- VecmapCreusot_OccupiedEntry_Type.occupiedentry_index ( * self_1); + assume { Resolve0.resolve self_1 }; + _6 <- ([#"../src/lib.rs" 522 13 522 35] IndexMut0.index_mut _7 _8); + goto BB1 + } + BB1 { + _5 <- borrow_mut (let (_, a) = * _6 in a); + _6 <- { _6 with current = (let (a, b) = * _6 in (a, ^ _5)) }; + assume { Resolve1.resolve _6 }; + _2 <- borrow_mut ( * _5); + _5 <- { _5 with current = ( ^ _2) }; + assume { Resolve2.resolve _5 }; + _0 <- borrow_mut ( * _2); + _2 <- { _2 with current = ( ^ _0) }; + assume { Resolve2.resolve _2 }; + return _0 + } + +end +module Core_Clone_Clone_Clone_Interface + type self + use prelude.Borrow + val clone' [@cfg:stackify] (self : self) : self + ensures { result = self } + +end +module Core_Clone_Clone_Clone + type self + use prelude.Borrow + val clone' [@cfg:stackify] (self : self) : self + ensures { result = self } + +end +module Core_Clone_Impls_Impl5_Clone_Interface + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + val clone' [@cfg:stackify] (self : usize) : usize + ensures { result = self } + +end +module Core_Clone_Impls_Impl5_Clone + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + val clone' [@cfg:stackify] (self : usize) : usize + ensures { result = self } + +end +module VecmapCreusot_Impl17_Clone_Interface + type k + use prelude.Borrow + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + val clone' [@cfg:stackify] [#"../src/lib.rs" 529 15 529 20] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 529 15 529 20] result = self } + +end +module VecmapCreusot_Impl17_Clone + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone Core_Clone_Impls_Impl5_Clone_Interface as Clone1 + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + clone Core_Clone_Clone_Clone_Interface as Clone0 with + type self = k + let rec cfg clone' [@cfg:stackify] [#"../src/lib.rs" 529 15 529 20] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 529 15 529 20] result = self } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_KeyRef_Type.t_keyref k; + var self_1 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _3 : k; + var _4 : k; + var _5 : usize; + var _6 : usize; + { + self_1 <- self; + goto BB0 + } + BB0 { + _4 <- VecmapCreusot_KeyRef_Type.keyref_key self_1; + _3 <- ([#"../src/lib.rs" 531 4 531 14] Clone0.clone' _4); + goto BB1 + } + BB1 { + _6 <- VecmapCreusot_KeyRef_Type.keyref_min_idx self_1; + assume { Resolve0.resolve self_1 }; + _5 <- ([#"../src/lib.rs" 532 4 534 18] Clone1.clone' _6); + goto BB2 + } + BB2 { + _0 <- VecmapCreusot_KeyRef_Type.C_KeyRef _3 _5; + goto BB3 + } + BB3 { + return _0 + } + +end +module VecmapCreusot_Impl11_Cloned_Interface + type k + use prelude.Borrow + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + val cloned [@cfg:stackify] [#"../src/lib.rs" 548 4 548 36] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + +end +module VecmapCreusot_Impl11_Cloned + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone Core_Clone_Clone_Clone_Interface as Clone0 with + type self = k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k + let rec cfg cloned [@cfg:stackify] [#"../src/lib.rs" 548 4 548 36] (self : VecmapCreusot_KeyRef_Type.t_keyref k) : VecmapCreusot_KeyRef_Type.t_keyref k + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_KeyRef_Type.t_keyref k; + var self_1 : VecmapCreusot_KeyRef_Type.t_keyref k; + var _2 : usize; + var _3 : k; + var _4 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _2 <- VecmapCreusot_KeyRef_Type.keyref_min_idx self_1; + _4 <- VecmapCreusot_KeyRef_Type.keyref_key self_1; + assume { Resolve0.resolve self_1 }; + _3 <- ([#"../src/lib.rs" 549 45 549 61] Clone0.clone' _4); + goto BB1 + } + BB1 { + _0 <- VecmapCreusot_KeyRef_Type.C_KeyRef _3 _2; + goto BB2 + } + BB2 { + return _0 + } + +end +module VecmapCreusot_Impl14_From_Interface + type k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + val from [@cfg:stackify] [#"../src/lib.rs" 577 4 577 27] (key : k) : VecmapCreusot_KeyRef_Type.t_keyref k +end +module VecmapCreusot_Impl14_From + type k + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + let rec cfg from [@cfg:stackify] [#"../src/lib.rs" 577 4 577 27] (key : k) : VecmapCreusot_KeyRef_Type.t_keyref k + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : VecmapCreusot_KeyRef_Type.t_keyref k; + var key_1 : k; + var _2 : k; + { + key_1 <- key; + goto BB0 + } + BB0 { + assume { Resolve0.resolve _2 }; + _2 <- key_1; + key_1 <- any k; + _0 <- VecmapCreusot_KeyRef_Type.C_KeyRef _2 ([#"../src/lib.rs" 578 29 578 30] (0 : usize)); + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + return _0 + } + +end +module VecmapCreusot_Impl2 + type k + type v + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl2_Clone_Interface as Clone0 with + type k = k, + type v = v + clone Core_Clone_Clone_Clone_Interface as Clone1 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v, + val clone' = Clone0.clone' +end +module VecmapCreusot_Impl17 + type k + use VecmapCreusot_KeyRef_Type as VecmapCreusot_KeyRef_Type + clone VecmapCreusot_Impl17_Clone_Interface as Clone0 with + type k = k + clone Core_Clone_Clone_Clone_Interface as Clone1 with + type self = VecmapCreusot_KeyRef_Type.t_keyref k, + val clone' = Clone0.clone' +end +module CreusotContracts_Std1_Default_Default_IsDefault_Stub + type self + predicate is_default (self : self) +end +module CreusotContracts_Std1_Default_Default_IsDefault_Interface + type self + predicate is_default (self : self) +end +module CreusotContracts_Std1_Default_Default_IsDefault + type self + predicate is_default (self : self) + val is_default (self : self) : bool + ensures { result = is_default self } + +end +module Core_Default_Default_Default_Interface + type self + clone CreusotContracts_Std1_Default_Default_IsDefault_Stub as IsDefault0 with + type self = self + val default [@cfg:stackify] (_1' : ()) : self + ensures { IsDefault0.is_default result } + +end +module Core_Default_Default_Default + type self + clone CreusotContracts_Std1_Default_Default_IsDefault_Interface as IsDefault0 with + type self = self + val default [@cfg:stackify] (_1' : ()) : self + ensures { IsDefault0.is_default result } + +end +module VecmapCreusot_Impl3 + type k + type v + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use VecmapCreusot_VecMap_Type as VecmapCreusot_VecMap_Type + clone VecmapCreusot_Impl4_IsDefault as IsDefault0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + clone VecmapCreusot_Impl3_Default_Interface as Default0 with + type k = k, + type v = v, + predicate IsDefault0.is_default = IsDefault0.is_default + clone Core_Default_Default_Default_Interface as Default1 with + type self = VecmapCreusot_VecMap_Type.t_vecmap k v, + val default = Default0.default, + predicate IsDefault0.is_default = IsDefault0.is_default +end +module VecmapCreusot_Impl4 + type k + type v +end +module VecmapCreusot_Impl15 + type k + type v +end +module VecmapCreusot_Impl6 + type k + type v +end +module VecmapCreusot_Impl8 + type k + type v +end +module VecmapCreusot_Impl16 + type k +end +module VecmapCreusot_Impl10 + type k +end +module VecmapCreusot_Impl14 + type k +end diff --git a/vecmap/creusot/vecmap_creusot-rlib/why3session.xml b/vecmap/creusot/vecmap_creusot-rlib/why3session.xml new file mode 100644 index 00000000..17fecc54 --- /dev/null +++ b/vecmap/creusot/vecmap_creusot-rlib/why3session.xml @@ -0,0 +1,424 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vecmap/creusot/vecmap_creusot-rlib/why3shapes.gz b/vecmap/creusot/vecmap_creusot-rlib/why3shapes.gz new file mode 100644 index 00000000..b773dccc Binary files /dev/null and b/vecmap/creusot/vecmap_creusot-rlib/why3shapes.gz differ diff --git a/vecmap/src/lib.rs b/vecmap/src/lib.rs new file mode 100644 index 00000000..916fe11f --- /dev/null +++ b/vecmap/src/lib.rs @@ -0,0 +1,337 @@ +/* + * Copyright (c) 2021, TU Dresden. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +//! This is a formally verified implementation of a sparse map that uses [Vec] underneath. +//! Entries are retained in sorted order by key to facilitate fast search. + +use ::std::cmp::Ordering; +use ::std::fmt::{Debug, Display, Formatter}; + +/// A sparse map representation over a totally ordered key type. +pub struct VecMap +where + K: Eq + Ord, +{ + v: Vec<(K, V)>, +} + +impl VecMap +where + K: Eq + Ord, +{ + pub fn new() -> Self { + Self { v: Vec::new() } + } + + /// Find an entry with assumption that the key is random access. + /// Logarithmic complexity. + pub fn entry(&mut self, key: K) -> Entry { + match self.find_k(&key) { + Ok(index) => Entry::Occupied(OccupiedEntry { map: self, index, key }), + Err(index) => Entry::Vacant(VacantEntry { map: self, index, key }), + } + } + + /// Find the entry matching `key`. Use `key_hint` to accelerate search. + /// The function will use the provided hint to skip items before it.\ + /// **Note**: This function makes two assumptions about your input: + /// - `key_hint` is valid, i.e. the underlying key is in the map and since extracting + /// the reference, no item has been removed from the map + /// - `key_hint.key <= key` + /// + /// If either of these assumptions is violated, you might obtain an entry which allows + /// destroying the well-kept order of the items. + pub fn entry_from_ref(&mut self, key_hint: KeyRef, key: K) -> Entry { + debug_assert!(self.is_valid_keyref(&key_hint.as_ref())); + let KeyRef { min_idx, .. } = key_hint; + + for i in min_idx..self.v.len() { + match self.v[i].0.cmp(&key) { + Ordering::Equal => return Entry::Occupied(OccupiedEntry { map: self, index: i, key }), + Ordering::Greater => { + assert!(i >= 1); // otherwise min_idx + return Entry::Vacant(VacantEntry { map: self, index: i, key }); + } + _ => {} + } + } + let i = self.v.len(); + Entry::Vacant(VacantEntry { map: self, index: i, key }) + } + + /// Finds entry reference, either directly associated with `min_key_inclusive`, or the entry with the + /// closest key (in terms of sorting order) greater than `min_key_inclusive`. Returns `None` if + /// map does not contain entry with key greater or equal to `min_key_inclusive`. + pub fn find_random_mapping_after(&self, min_key_inclusive: K) -> Option<(KeyRef<&K>, &V)> { + match self.find_k(&min_key_inclusive) { + Ok(index) => { + let (key, value) = &self.v[index]; + Some((KeyRef { key, min_idx: index }, value)) + } + Err(index) => match self.v.get(index) { + Some((key, value)) => { + assert!(key >= &min_key_inclusive); + Some((KeyRef { key, min_idx: index }, value)) + } + None => None, + }, + } + } + + /// Insert `value` for `key` in the map. If `key` is already contained, the function + /// replaces the previously held value and returns it. + pub fn insert(&mut self, key: K, value: V) -> Option { + match self.find_k(&key) { + Ok(index) => Some(std::mem::replace(&mut self.v[index].1, value)), + Err(index) => { + self.insert_internal(index, key, value); + None + } + } + } + + /// Removes the item with `key` and returns its value. If no such item exists, + /// it does nothing. + pub fn remove(&mut self, key: &K) -> Option { + match self.find_k(key) { + Ok(index) => Some(self.v.remove(index).1), + Err(_) => None, + } + } + + /// Get the value associated with `key`, if it exists. + pub fn get(&self, key: &K) -> Option<&V> { + match self.find_k(key) { + Ok(index) => Some(&self.v[index].1), + Err(_) => None, + } + } + + /// Checks if `key` is contained in the map. + pub fn contains_key(&self, key: &K) -> bool { + self.find_k(key).is_ok() + } + + /// Produces the first mapping that follows the given key + /// in the ascending order of keys. + pub fn next_mapping(&self, key: KeyRef<&K>) -> Option<(KeyRef<&K>, &V)> { + let from = if self.is_valid_keyref(&key) { + key.min_idx + } else { + 0 // it's not, maybe it was produced by another vecmap + }; + + for idx in from..self.v.len() { + if self.v[idx].0 > *key.key { + let (key, value) = &self.v[idx]; + return Some((KeyRef { min_idx: idx, key }, value)); + } + } + None + } + + fn is_valid_keyref(&self, key: &KeyRef<&K>) -> bool { + match self.v.get(key.min_idx) { + Some((k, _)) => k <= key.key, + _ => false, + } + } + + /// Iterate over all key-value paris in the map. + pub fn iter(&self) -> impl Iterator + '_ { + self.v.iter() + } + + /// Obtain keyref-value pair of the item with the smallest key, unless the map is empty. + pub fn min_entry(&self) -> Option<(KeyRef<&K>, &V)> { + #[allow(clippy::manual_map)] + match self.v.first() { + Some((key, value)) => Some((KeyRef { key, min_idx: 0 }, value)), + None => None, + } + } + + /// Obtain the key of the item with the greatest key, unless the map is empty. + pub fn max_key(&self) -> Option<&K> { + match self.v.last() { + Some(e) => Some(&e.0), + None => None, + } + } + + /// Attempts to find the given `key`. If found, it returns `Ok` with the index of the key in the + /// underlying `Vec`. Otherwise it returns `Err` with the index where a matching element could be + /// inserted while maintaining sorted order. + fn find_k(&self, key: &K) -> Result { + let mut size = self.v.len(); + let mut left = 0; + let mut right = size; + let mut mid; + + while left < right { + mid = left + size / 2; + + let cmp = self.v[mid].0.cmp(key); + + match cmp { + Ordering::Less => left = mid + 1, + Ordering::Greater => right = mid, + Ordering::Equal => return Ok(mid), + } + + size = right - left; + } + Err(left) + } + + /// Directly insert into the underlying `Vec`. This does not maintain the sorting of elements + /// by itself. + fn insert_internal(&mut self, idx: usize, key: K, value: V) { + self.v.insert(idx, (key, value)) + } +} + +impl Clone for VecMap { + fn clone(&self) -> Self { + VecMap { v: self.v.clone() } + } +} + +impl Debug for VecMap { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + self.v.iter().collect::>().fmt(f) + } +} + +impl ::std::default::Default for VecMap { + fn default() -> Self { + Self { v: Vec::new() } + } +} + +/// A view into a single entry in a map, which may either be vacant or occupied. +pub enum Entry<'a, K, V> +where + K: Ord + Eq, +{ + /// A vacant Entry + Vacant(VacantEntry<'a, K, V>), + + /// An occupied Entry + Occupied(OccupiedEntry<'a, K, V>), +} + +/// A vacant Entry. +pub struct VacantEntry<'a, K, V> +where + K: Ord + Eq, +{ + map: &'a mut VecMap, + key: K, + index: usize, +} + +/// An occupied Entry. +pub struct OccupiedEntry<'a, K, V> +where + K: Ord + Eq, +{ + map: &'a mut VecMap, + key: K, + index: usize, +} + +impl Entry<'_, K, V> +where + K: Ord + Eq, +{ + pub fn keyref(&self) -> KeyRef<&K> { + match self { + Entry::Vacant(VacantEntry { key, index, .. }) => KeyRef { min_idx: *index, key }, + Entry::Occupied(OccupiedEntry { key, index, .. }) => KeyRef { min_idx: *index, key }, + } + } +} + +impl VacantEntry<'_, K, V> +where + K: Ord + Eq, +{ + /// Sets the value of the entry with the VacantEntry's key. + pub fn insert(self, value: V) { + self.map.insert_internal(self.index, self.key, value) + } +} + +impl OccupiedEntry<'_, K, V> +where + K: Ord + Eq, +{ + /// Replaces the entry's value with `value`. + pub fn replace(&mut self, value: V) { + self.map.v[self.index].1 = value; + } + + /// Gets the mutable ref to the entry's value. + pub fn get_mut(&mut self) -> &mut V { + &mut self.map.v[self.index].1 + } +} + +/// A key zipped with its internal index in this map. +/// For some operations, like manually implemented iteration, +/// the index can be used for optimisation. +#[derive(Copy, Clone)] +pub struct KeyRef { + pub key: K, + /// This is a lower bound on the actual index of key K, + /// it doesn't need to be the index (though it usually will be). + min_idx: usize, +} + +impl KeyRef<&K> { + #[inline] + pub fn cloned(self) -> KeyRef { + KeyRef { min_idx: self.min_idx, key: self.key.clone() } + } +} + +impl KeyRef { + #[inline] + pub fn as_ref(&self) -> KeyRef<&K> { + KeyRef { min_idx: self.min_idx, key: &self.key } + } +} + +impl Display for KeyRef { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.key) + } +} + +impl From for KeyRef { + fn from(key: K) -> Self { + Self { key, min_idx: 0 } + } +} diff --git a/vecmap/vecmap-rlib.mlcfg b/vecmap/vecmap-rlib.mlcfg new file mode 100644 index 00000000..45e45f1e --- /dev/null +++ b/vecmap/vecmap-rlib.mlcfg @@ -0,0 +1,8131 @@ + +module Core_Ptr_NonNull_NonNull_Type + use prelude.Opaque + type t_nonnull 't = + | C_NonNull opaque_ptr + +end +module Core_Marker_PhantomData_Type + type t_phantomdata 't = + | C_PhantomData + +end +module Core_Ptr_Unique_Unique_Type + use Core_Marker_PhantomData_Type as Core_Marker_PhantomData_Type + use Core_Ptr_NonNull_NonNull_Type as Core_Ptr_NonNull_NonNull_Type + type t_unique 't = + | C_Unique (Core_Ptr_NonNull_NonNull_Type.t_nonnull 't) (Core_Marker_PhantomData_Type.t_phantomdata 't) + +end +module Alloc_RawVec_RawVec_Type + use mach.int.Int + use prelude.UIntSize + use Core_Ptr_Unique_Unique_Type as Core_Ptr_Unique_Unique_Type + type t_rawvec 't 'a = + | C_RawVec (Core_Ptr_Unique_Unique_Type.t_unique 't) usize 'a + +end +module Alloc_Vec_Vec_Type + use mach.int.Int + use prelude.UIntSize + use Alloc_RawVec_RawVec_Type as Alloc_RawVec_RawVec_Type + type t_vec 't 'a = + | C_Vec (Alloc_RawVec_RawVec_Type.t_rawvec 't 'a) usize + +end +module Alloc_Alloc_Global_Type + type t_global = + | C_Global + +end +module Vecmap_VecMap_Type + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + type t_vecmap 'k 'v = + | C_VecMap (Alloc_Vec_Vec_Type.t_vec ('k, 'v) (Alloc_Alloc_Global_Type.t_global)) + + let function vecmap_v (self : t_vecmap 'k 'v) : Alloc_Vec_Vec_Type.t_vec ('k, 'v) (Alloc_Alloc_Global_Type.t_global) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VecMap a -> a + end +end +module Core_Num_Impl12_Max_Stub + use mach.int.Int + use prelude.UIntSize + val constant mAX' : usize +end +module Core_Num_Impl12_Max + use mach.int.Int + use prelude.UIntSize + let constant mAX' : usize = [@vc:do_not_keep_trace] [@vc:sp] + (18446744073709551615 : usize) +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + axiom shallow_model_spec : forall self : Alloc_Vec_Vec_Type.t_vec t a . Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModel + type t + type a + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + val shallow_model (self : Alloc_Vec_Vec_Type.t_vec t a) : Seq.seq t + ensures { result = shallow_model self } + + axiom shallow_model_spec : forall self : Alloc_Vec_Vec_Type.t_vec t a . Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Model_DeepModel_DeepModelTy_Type + type self + type deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel_Stub + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel_Interface + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_DeepModel_DeepModel + type self + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + function deep_model (self : self) : DeepModelTy0.deepModelTy + val deep_model (self : self) : DeepModelTy0.deepModelTy + ensures { result = deep_model self } + +end +module Vecmap_Impl0_KeySeq_Stub + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + function key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + +end +module Vecmap_Impl0_KeySeq_Interface + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + function key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + + axiom key_seq_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v . [#"../src/lib.rs" 52 4 54 56] Seq.length (key_seq self) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (key_seq self) i = DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a)) +end +module Vecmap_Impl0_KeySeq + type k + type v + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + function key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + + val key_seq [#"../src/lib.rs" 55 4 55 43] (self : Vecmap_VecMap_Type.t_vecmap k v) : Seq.seq DeepModelTy0.deepModelTy + ensures { result = key_seq self } + + axiom key_seq_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v . [#"../src/lib.rs" 52 4 54 56] Seq.length (key_seq self) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (key_seq self) i = DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a)) +end +module Core_Cmp_Ordering_Type + type t_ordering = + | C_Less + | C_Equal + | C_Greater + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + function cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering + val cmp_log (self : self) (_2' : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = cmp_log self _2' } + +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub + type self + predicate lt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface + type self + predicate lt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate lt_log (self : self) (o : self) = + [#"../src/lib.rs" 395 14 396 12] CmpLog0.cmp_log self o = Core_Cmp_Ordering_Type.C_Less + val lt_log (self : self) (o : self) : bool + ensures { result = lt_log self o } + +end +module Vecmap_Impl0_IsSorted_Stub + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl0_IsSorted_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl0_IsSorted + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use mach.int.Int + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + predicate is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) = + [#"../src/lib.rs" 61 8 64 9] forall n : int . forall m : int . m >= 0 /\ n >= 0 /\ m < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ n < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) /\ m < n -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) m) (Seq.get (KeySeq0.key_seq self) n) + val is_sorted [#"../src/lib.rs" 60 4 60 30] (self : Vecmap_VecMap_Type.t_vecmap k v) : bool + ensures { result = is_sorted self } + +end +module Alloc_Vec_Impl0_New_Interface + type t + use seq.Seq + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = t, + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val new [@cfg:stackify] (_1' : ()) : Alloc_Vec_Vec_Type.t_vec t (Alloc_Alloc_Global_Type.t_global) + ensures { Seq.length (ShallowModel0.shallow_model result) = 0 } + +end +module Alloc_Vec_Impl0_New + type t + use seq.Seq + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel0 with + type t = t, + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val new [@cfg:stackify] (_1' : ()) : Alloc_Vec_Vec_Type.t_vec t (Alloc_Alloc_Global_Type.t_global) + ensures { Seq.length (ShallowModel0.shallow_model result) = 0 } + +end +module Vecmap_Impl1_New_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + val new [@cfg:stackify] [#"../src/lib.rs" 73 4 73 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v +end +module Vecmap_Impl1_New + type k + type v + clone Core_Num_Impl12_Max as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Alloc_Vec_Impl0_New_Interface as New0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + let rec cfg new [@cfg:stackify] [#"../src/lib.rs" 73 4 73 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_VecMap_Type.t_vecmap k v; + var _1 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + goto BB0 + } + BB0 { + _1 <- ([#"../src/lib.rs" 74 18 74 28] New0.new ()); + goto BB1 + } + BB1 { + _0 <- Vecmap_VecMap_Type.C_VecMap _1; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_OccupiedEntry_Type + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + type t_occupiedentry 'k 'v = + | C_OccupiedEntry (borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v)) 'k usize + + let function occupiedentry_map (self : t_occupiedentry 'k 'v) : borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry a _ _ -> a + end + let function occupiedentry_index (self : t_occupiedentry 'k 'v) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry _ _ a -> a + end + let function occupiedentry_key (self : t_occupiedentry 'k 'v) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_OccupiedEntry _ a _ -> a + end +end +module Vecmap_VacantEntry_Type + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + type t_vacantentry 'k 'v = + | C_VacantEntry (borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v)) 'k usize + + let function vacantentry_map (self : t_vacantentry 'k 'v) : borrowed (Vecmap_VecMap_Type.t_vecmap 'k 'v) + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry a _ _ -> a + end + let function vacantentry_index (self : t_vacantentry 'k 'v) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry _ _ a -> a + end + let function vacantentry_key (self : t_vacantentry 'k 'v) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_VacantEntry _ a _ -> a + end +end +module Vecmap_Entry_Type + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + type t_entry 'k 'v = + | C_Vacant (Vecmap_VacantEntry_Type.t_vacantentry 'k 'v) + | C_Occupied (Vecmap_OccupiedEntry_Type.t_occupiedentry 'k 'v) + + let function occupied_0 (self : t_entry 'k 'v) : Vecmap_OccupiedEntry_Type.t_occupiedentry 'k 'v + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Vacant _ -> any Vecmap_OccupiedEntry_Type.t_occupiedentry 'k 'v + | C_Occupied a -> a + end + let function vacant_0 (self : t_entry 'k 'v) : Vecmap_VacantEntry_Type.t_vacantentry 'k 'v + = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Vacant a -> a + | C_Occupied _ -> any Vecmap_VacantEntry_Type.t_vacantentry 'k 'v + end +end +module Vecmap_Impl8_Invariant_Stub + type k + type v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + predicate invariant' [#"../src/lib.rs" 521 4 521 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) +end +module Vecmap_Impl8_Invariant_Interface + type k + type v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + predicate invariant' [#"../src/lib.rs" 521 4 521 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) +end +module Vecmap_Impl8_Invariant + type k + type v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + use prelude.Borrow + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate invariant' [#"../src/lib.rs" 521 4 521 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) = + [#"../src/lib.rs" 522 8 526 9] IsSorted0.is_sorted ( * Vecmap_OccupiedEntry_Type.occupiedentry_map self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map self))) > UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index self) /\ Seq.get (KeySeq0.key_seq ( * Vecmap_OccupiedEntry_Type.occupiedentry_map self)) (UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index self)) = DeepModel0.deep_model (Vecmap_OccupiedEntry_Type.occupiedentry_key self) + val invariant' [#"../src/lib.rs" 521 4 521 30] (self : Vecmap_OccupiedEntry_Type.t_occupiedentry k v) : bool + ensures { result = invariant' self } + +end +module Vecmap_Impl6_Invariant_Stub + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate invariant' [#"../src/lib.rs" 491 4 491 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl6_Invariant_Interface + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate invariant' [#"../src/lib.rs" 491 4 491 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl6_Invariant + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use prelude.Borrow + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate invariant' [#"../src/lib.rs" 491 4 491 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) = + [#"../src/lib.rs" 492 8 494 9] IsSorted0.is_sorted ( * Vecmap_VacantEntry_Type.vacantentry_map self) /\ UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_VacantEntry_Type.vacantentry_map self))) + val invariant' [#"../src/lib.rs" 491 4 491 30] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) : bool + ensures { result = invariant' self } + +end +module Core_Result_Result_Type + type t_result 't 'e = + | C_Ok 't + | C_Err 'e + + let function err_0 (self : t_result 't 'e) : 'e = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Ok _ -> any 'e + | C_Err a -> a + end + let function ok_0 (self : t_result 't 'e) : 't = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Ok a -> a + | C_Err _ -> any 't + end +end +module CreusotContracts_Model_Impl0_DeepModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + function deep_model (self : t) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_Impl0_DeepModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + function deep_model (self : t) : DeepModelTy0.deepModelTy +end +module CreusotContracts_Model_Impl0_DeepModel + type t + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = t, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function deep_model (self : t) : DeepModelTy0.deepModelTy = + DeepModel0.deep_model self + val deep_model (self : t) : DeepModelTy0.deepModelTy + ensures { result = deep_model self } + +end +module CreusotContracts_Logic_Seq_Impl0_Contains_Stub + type t + use seq.Seq + predicate contains (self : Seq.seq t) (e : t) +end +module CreusotContracts_Logic_Seq_Impl0_Contains_Interface + type t + use seq.Seq + predicate contains (self : Seq.seq t) (e : t) +end +module CreusotContracts_Logic_Seq_Impl0_Contains + type t + use seq.Seq + use mach.int.Int + predicate contains (self : Seq.seq t) (e : t) = + exists i : int . 0 <= i /\ i < Seq.length self /\ Seq.get self i = e + val contains (self : Seq.seq t) (e : t) : bool + ensures { result = contains self e } + +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub + type self + predicate gt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface + type self + predicate gt_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate gt_log (self : self) (o : self) = + [#"../src/lib.rs" 413 3 414 22] CmpLog0.cmp_log self o = Core_Cmp_Ordering_Type.C_Greater + val gt_log (self : self) (o : self) : bool + ensures { result = gt_log self o } + +end +module CreusotContracts_Model_ShallowModel_ShallowModelTy_Type + type self + type shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel_Stub + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel_Interface + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_ShallowModel_ShallowModel + type self + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = self + function shallow_model (self : self) : ShallowModelTy0.shallowModelTy + val shallow_model (self : self) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module CreusotContracts_Model_Impl1_ShallowModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl1_ShallowModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl1_ShallowModel + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + clone CreusotContracts_Model_ShallowModel_ShallowModel_Stub as ShallowModel0 with + type self = t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + function shallow_model (self : t) : ShallowModelTy0.shallowModelTy = + ShallowModel0.shallow_model self + val shallow_model (self : t) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type + type t + type a + use seq.Seq + type shallowModelTy = + Seq.seq t +end +module Alloc_Vec_Impl1_Len_Interface + type t + type a + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val len [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : usize + ensures { UInt64.to_int result = Seq.length (ShallowModel0.shallow_model self) } + +end +module Alloc_Vec_Impl1_Len + type t + type a + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val len [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : usize + ensures { UInt64.to_int result = Seq.length (ShallowModel0.shallow_model self) } + +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) +end +module CreusotContracts_Std1_Slice_SliceIndex_InBounds + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) + val in_bounds (self : self) (seq : ShallowModelTy0.shallowModelTy) : bool + ensures { result = in_bounds self seq } + +end +module Core_Slice_Index_SliceIndex_Output_Type + type self + type t + type output +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) +end +module CreusotContracts_Std1_Slice_SliceIndex_HasValue + type self + type t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = self, + type t = t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) + val has_value (self : self) (seq : ShallowModelTy0.shallowModelTy) (out : Output0.output) : bool + ensures { result = has_value self seq out } + +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type + type t + use seq.Seq + type shallowModelTy = + Seq.seq t +end +module Alloc_Vec_Impl16_Index_Interface + type t + type i + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) (index : i) : Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) result } + +end +module Alloc_Vec_Impl16_Index + type t + type i + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) (index : i) : Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) result } + +end +module Core_Cmp_Ord_Cmp_Interface + type self + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val cmp [@cfg:stackify] (self : self) (other : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = CmpLog0.cmp_log (DeepModel0.deep_model self) (DeepModel0.deep_model other) } + +end +module Core_Cmp_Ord_Cmp + type self + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val cmp [@cfg:stackify] (self : self) (other : self) : Core_Cmp_Ordering_Type.t_ordering + ensures { result = CmpLog0.cmp_log (DeepModel0.deep_model self) (DeepModel0.deep_model other) } + +end +module CreusotContracts_Resolve_Resolve_Resolve_Stub + type self + predicate resolve (self : self) +end +module CreusotContracts_Resolve_Resolve_Resolve_Interface + type self + predicate resolve (self : self) +end +module CreusotContracts_Resolve_Resolve_Resolve + type self + predicate resolve (self : self) + val resolve (self : self) : bool + ensures { result = resolve self } + +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub + type self + predicate le_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface + type self + predicate le_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_LeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate le_log (self : self) (o : self) = + [#"../src/lib.rs" 383 61 384 31] CmpLog0.cmp_log self o <> Core_Cmp_Ordering_Type.C_Greater + val le_log (self : self) (o : self) : bool + ensures { result = le_log self o } + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () + axiom cmp_le_log_spec : forall x : self, y : self . [#"../src/lib.rs" 388 16 389 5] LeLog0.le_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = self + function cmp_le_log (x : self) (y : self) : () + val cmp_le_log (x : self) (y : self) : () + ensures { result = cmp_le_log x y } + + axiom cmp_le_log_spec : forall x : self, y : self . [#"../src/lib.rs" 388 16 389 5] LeLog0.le_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () + axiom cmp_lt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 396 47 397 33] LtLog0.lt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = self + function cmp_lt_log (x : self) (y : self) : () + val cmp_lt_log (x : self) (y : self) : () + ensures { result = cmp_lt_log x y } + + axiom cmp_lt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 396 47 397 33] LtLog0.lt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub + type self + predicate ge_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface + type self + predicate ge_log (self : self) (o : self) +end +module CreusotContracts_Logic_Ord_OrdLogic_GeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + predicate ge_log (self : self) (o : self) = + [#"../src/lib.rs" 402 13 402 46] CmpLog0.cmp_log self o <> Core_Cmp_Ordering_Type.C_Less + val ge_log (self : self) (o : self) : bool + ensures { result = ge_log self o } + +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () + axiom cmp_ge_log_spec : forall x : self, y : self . [#"../src/lib.rs" 403 17 405 1] GeLog0.ge_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = self + function cmp_ge_log (x : self) (y : self) : () + val cmp_ge_log (x : self) (y : self) : () + ensures { result = cmp_ge_log x y } + + axiom cmp_ge_log_spec : forall x : self, y : self . [#"../src/lib.rs" 403 17 405 1] GeLog0.ge_log x y = (CmpLog0.cmp_log x y <> Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () + axiom cmp_gt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 415 23 419 21] GtLog0.gt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = self + function cmp_gt_log (x : self) (y : self) : () + val cmp_gt_log (x : self) (y : self) : () + ensures { result = cmp_gt_log x y } + + axiom cmp_gt_log_spec : forall x : self, y : self . [#"../src/lib.rs" 415 23 419 21] GtLog0.gt_log x y = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () + axiom refl_spec : forall x : self . [#"../src/lib.rs" 420 6 422 6] CmpLog0.cmp_log x x = Core_Cmp_Ordering_Type.C_Equal +end +module CreusotContracts_Logic_Ord_OrdLogic_Refl + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function refl (x : self) : () + val refl (x : self) : () + ensures { result = refl x } + + axiom refl_spec : forall x : self . [#"../src/lib.rs" 420 6 422 6] CmpLog0.cmp_log x x = Core_Cmp_Ordering_Type.C_Equal +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + axiom trans_spec : forall x : self, y : self, z : self, o : Core_Cmp_Ordering_Type.t_ordering . ([#"../src/lib.rs" 425 16 425 33] CmpLog0.cmp_log x y = o) -> ([#"../src/lib.rs" 427 15 428 6] CmpLog0.cmp_log y z = o) -> ([#"../src/lib.rs" 428 23 429 1] CmpLog0.cmp_log x z = o) +end +module CreusotContracts_Logic_Ord_OrdLogic_Trans + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + val trans (x : self) (y : self) (z : self) (o : Core_Cmp_Ordering_Type.t_ordering) : () + requires {[#"../src/lib.rs" 425 16 425 33] CmpLog0.cmp_log x y = o} + requires {[#"../src/lib.rs" 427 15 428 6] CmpLog0.cmp_log y z = o} + ensures { result = trans x y z o } + + axiom trans_spec : forall x : self, y : self, z : self, o : Core_Cmp_Ordering_Type.t_ordering . ([#"../src/lib.rs" 425 16 425 33] CmpLog0.cmp_log x y = o) -> ([#"../src/lib.rs" 427 15 428 6] CmpLog0.cmp_log y z = o) -> ([#"../src/lib.rs" 428 23 429 1] CmpLog0.cmp_log x z = o) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () + axiom antisym1_spec : forall x : self, y : self . ([#"../src/lib.rs" 436 4 437 3] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) -> ([#"../src/lib.rs" 438 8 441 20] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym1 + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym1 (x : self) (y : self) : () + val antisym1 (x : self) (y : self) : () + requires {[#"../src/lib.rs" 436 4 437 3] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less} + ensures { result = antisym1 x y } + + axiom antisym1_spec : forall x : self, y : self . ([#"../src/lib.rs" 436 4 437 3] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Less) -> ([#"../src/lib.rs" 438 8 441 20] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Greater) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () + axiom antisym2_spec : forall x : self, y : self . ([#"../src/lib.rs" 446 2 447 4] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) -> ([#"../src/lib.rs" 448 9 451 18] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_Antisym2 + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function antisym2 (x : self) (y : self) : () + val antisym2 (x : self) (y : self) : () + requires {[#"../src/lib.rs" 446 2 447 4] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater} + ensures { result = antisym2 x y } + + axiom antisym2_spec : forall x : self, y : self . ([#"../src/lib.rs" 446 2 447 4] CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Greater) -> ([#"../src/lib.rs" 448 9 451 18] CmpLog0.cmp_log y x = Core_Cmp_Ordering_Type.C_Less) +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Stub + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () + axiom eq_cmp_spec : forall x : self, y : self . [#"../src/lib.rs" 454 20 457 5] (x = y) = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Equal) +end +module CreusotContracts_Logic_Ord_OrdLogic_EqCmp + type self + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Stub as CmpLog0 with + type self = self + function eq_cmp (x : self) (y : self) : () + val eq_cmp (x : self) (y : self) : () + ensures { result = eq_cmp x y } + + axiom eq_cmp_spec : forall x : self, y : self . [#"../src/lib.rs" 454 20 457 5] (x = y) = (CmpLog0.cmp_log x y = Core_Cmp_Ordering_Type.C_Equal) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_InBounds + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) = + UInt64.to_int self < Seq.length seq + val in_bounds [@inline:trivial] (self : usize) (seq : Seq.seq t) : bool + ensures { result = in_bounds self seq } + +end +module CreusotContracts_Std1_Slice_Impl5_HasValue_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) +end +module CreusotContracts_Std1_Slice_Impl5_HasValue_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) +end +module CreusotContracts_Std1_Slice_Impl5_HasValue + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) = + Seq.get seq (UInt64.to_int self) = out + val has_value [@inline:trivial] (self : usize) (seq : Seq.seq t) (out : t) : bool + ensures { result = has_value self seq out } + +end +module Core_Slice_Index_Impl2_Output_Type + type t + type output = + t +end +module Vecmap_Impl1_FindK_Interface + type k + type v + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val find_k [@cfg:stackify] [#"../src/lib.rs" 331 4 331 53] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Result_Result_Type.t_result usize usize + requires {[#"../src/lib.rs" 317 15 317 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 318 14 321 5] match (result) with + | Core_Result_Result_Type.C_Ok _ -> Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + | Core_Result_Result_Type.C_Err _ -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + end } + ensures { [#"../src/lib.rs" 322 4 322 91] forall i : usize . result = Core_Result_Result_Type.C_Ok i -> Seq.get (KeySeq0.key_seq self) (UInt64.to_int i) = DeepModel0.deep_model key } + ensures { [#"../src/lib.rs" 323 4 324 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i -> j >= UInt64.to_int i /\ j < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 325 4 326 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i /\ j >= 0 /\ j < UInt64.to_int i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 327 14 330 5] match (result) with + | Core_Result_Result_Type.C_Ok idx -> UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + | Core_Result_Result_Type.C_Err idx -> UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + end } + +end +module Vecmap_Impl1_FindK + type k + type v + use mach.int.Int + use prelude.UIntSize + use prelude.Borrow + use prelude.Int8 + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Core_Cmp_Ord_Cmp_Interface as Cmp0 with + type self = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Core_Result_Result_Type as Core_Result_Result_Type + let rec cfg find_k [@cfg:stackify] [#"../src/lib.rs" 331 4 331 53] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Result_Result_Type.t_result usize usize + requires {[#"../src/lib.rs" 317 15 317 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 318 14 321 5] match (result) with + | Core_Result_Result_Type.C_Ok _ -> Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + | Core_Result_Result_Type.C_Err _ -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) + end } + ensures { [#"../src/lib.rs" 322 4 322 91] forall i : usize . result = Core_Result_Result_Type.C_Ok i -> Seq.get (KeySeq0.key_seq self) (UInt64.to_int i) = DeepModel0.deep_model key } + ensures { [#"../src/lib.rs" 323 4 324 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i -> j >= UInt64.to_int i /\ j < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 325 4 326 52] forall j : int . forall i : usize . result = Core_Result_Result_Type.C_Err i /\ j >= 0 /\ j < UInt64.to_int i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 327 14 330 5] match (result) with + | Core_Result_Result_Type.C_Ok idx -> UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + | Core_Result_Result_Type.C_Err idx -> UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) + end } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Result_Result_Type.t_result usize usize; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : k; + var size_9 : usize; + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var left_11 : usize; + var right_12 : usize; + var mid_13 : usize; + var _14 : (); + var _22 : (); + var _23 : bool; + var _24 : usize; + var _25 : usize; + var _26 : usize; + var _27 : usize; + var _28 : usize; + var _29 : bool; + var cmp_30 : Core_Cmp_Ordering_Type.t_ordering; + var _31 : k; + var _32 : (k, v); + var _33 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _34 : usize; + var _35 : k; + var _36 : (); + var _37 : int8; + var _38 : usize; + var _39 : usize; + var _40 : (); + var _41 : usize; + var _42 : usize; + var _43 : usize; + var _44 : (); + var _45 : (); + var _46 : (); + var _47 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _10 <- Vecmap_VecMap_Type.vecmap_v self_1; + size_9 <- ([#"../src/lib.rs" 332 23 332 35] Len0.len _10); + goto BB1 + } + BB1 { + left_11 <- ([#"../src/lib.rs" 333 23 333 24] (0 : usize)); + right_12 <- size_9; + goto BB2 + } + BB2 { + invariant size_bounds { [#"../src/lib.rs" 337 33 337 71] UInt64.to_int size_9 >= 0 /\ UInt64.to_int size_9 <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant left_bounds { [#"../src/lib.rs" 338 33 338 71] UInt64.to_int left_11 >= 0 /\ UInt64.to_int left_11 <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant right_bounds { [#"../src/lib.rs" 339 34 339 74] UInt64.to_int right_12 >= 0 /\ UInt64.to_int right_12 <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant mid_bounds { [#"../src/lib.rs" 337 8 337 73] UInt64.to_int left_11 < UInt64.to_int right_12 -> UInt64.to_int left_11 + div (UInt64.to_int size_9) 2 < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) }; + invariant right_gt_mid { [#"../src/lib.rs" 337 8 337 73] UInt64.to_int left_11 < UInt64.to_int right_12 -> UInt64.to_int right_12 > UInt64.to_int left_11 + div (UInt64.to_int size_9) 2 }; + invariant right_geq_key { [#"../src/lib.rs" 337 8 337 73] forall i : int . i >= UInt64.to_int right_12 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self_1)) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq self_1) i) (DeepModel0.deep_model key_2) }; + invariant left_lt_key { [#"../src/lib.rs" 337 8 337 73] forall i : int . i >= 0 /\ i < UInt64.to_int left_11 -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self_1) i) (DeepModel0.deep_model key_2) }; + _24 <- left_11; + _25 <- right_12; + _23 <- ([#"../src/lib.rs" 346 14 346 26] _24 < _25); + switch (_23) + | False -> goto BB12 + | True -> goto BB3 + end + } + BB3 { + _26 <- left_11; + _28 <- size_9; + _29 <- ([#"../src/lib.rs" 347 25 347 33] ([#"../src/lib.rs" 347 32 347 33] (2 : usize)) = ([#"../src/lib.rs" 347 25 347 33] (0 : usize))); + assert { [#"../src/lib.rs" 347 25 347 33] not _29 }; + goto BB4 + } + BB4 { + _27 <- ([#"../src/lib.rs" 347 25 347 33] _28 / ([#"../src/lib.rs" 347 32 347 33] (2 : usize))); + mid_13 <- ([#"../src/lib.rs" 347 12 347 33] _26 + _27); + _33 <- Vecmap_VecMap_Type.vecmap_v self_1; + _34 <- mid_13; + _32 <- ([#"../src/lib.rs" 349 22 349 33] Index0.index _33 _34); + goto BB5 + } + BB5 { + _31 <- (let (a, _) = _32 in a); + assume { Resolve0.resolve _32 }; + _35 <- key_2; + cmp_30 <- ([#"../src/lib.rs" 349 22 349 44] Cmp0.cmp _31 _35); + goto BB6 + } + BB6 { + switch (cmp_30) + | Core_Cmp_Ordering_Type.C_Less -> goto BB9 + | Core_Cmp_Ordering_Type.C_Equal -> goto BB7 + | Core_Cmp_Ordering_Type.C_Greater -> goto BB10 + end + } + BB7 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + _41 <- mid_13; + _0 <- Core_Result_Result_Type.C_Ok _41; + goto BB13 + } + BB8 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + absurd + } + BB9 { + _38 <- mid_13; + left_11 <- ([#"../src/lib.rs" 352 34 352 48] _38 + ([#"../src/lib.rs" 352 47 352 48] (1 : usize))); + _36 <- (); + goto BB11 + } + BB10 { + _39 <- mid_13; + right_12 <- _39; + _39 <- any usize; + _36 <- (); + goto BB11 + } + BB11 { + _42 <- right_12; + _43 <- left_11; + size_9 <- ([#"../src/lib.rs" 357 12 357 31] _42 - _43); + _22 <- (); + goto BB2 + } + BB12 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + _14 <- (); + _47 <- left_11; + _0 <- Core_Result_Result_Type.C_Err _47; + goto BB13 + } + BB13 { + return _0 + } + +end +module CreusotContracts_Resolve_Impl1_Resolve_Stub + type t + use prelude.Borrow + predicate resolve (self : borrowed t) +end +module CreusotContracts_Resolve_Impl1_Resolve_Interface + type t + use prelude.Borrow + predicate resolve (self : borrowed t) +end +module CreusotContracts_Resolve_Impl1_Resolve + type t + use prelude.Borrow + predicate resolve (self : borrowed t) = + ^ self = * self + val resolve (self : borrowed t) : bool + ensures { result = resolve self } + +end +module Vecmap_Impl1_Entry_Interface + type k + type v + use prelude.Borrow + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant_Stub as Invariant1 with + type k = k, + type v = v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + use Vecmap_Entry_Type as Vecmap_Entry_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val entry [@cfg:stackify] [#"../src/lib.rs" 82 4 82 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 79 15 79 31] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 80 4 80 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 81 4 81 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + +end +module Vecmap_Impl1_Entry + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_VecMap_Type.t_vecmap k v + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant as Invariant1 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_Entry_Type as Vecmap_Entry_Type + let rec cfg entry [@cfg:stackify] [#"../src/lib.rs" 82 4 82 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 79 15 79 31] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 80 4 80 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 81 4 81 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_Entry_Type.t_entry k v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_2 : k; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : Vecmap_VecMap_Type.t_vecmap k v; + var _8 : k; + var _9 : k; + var _10 : isize; + var index_11 : usize; + var _12 : Vecmap_OccupiedEntry_Type.t_occupiedentry k v; + var _13 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _14 : usize; + var _15 : k; + var index_16 : usize; + var _17 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var _18 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _19 : usize; + var _20 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- * self_1; + _9 <- key_2; + _8 <- _9; + assume { Resolve0.resolve _9 }; + _6 <- ([#"../src/lib.rs" 83 14 83 31] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + switch (_6) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + index_16 <- Core_Result_Result_Type.err_0 _6; + _18 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _18) }; + assume { Resolve1.resolve self_1 }; + _19 <- index_16; + assume { Resolve2.resolve _20 }; + _20 <- key_2; + key_2 <- any k; + _17 <- Vecmap_VacantEntry_Type.C_VacantEntry _18 _20 _19; + goto BB7 + } + BB3 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + absurd + } + BB4 { + index_11 <- Core_Result_Result_Type.ok_0 _6; + _13 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _13) }; + assume { Resolve1.resolve self_1 }; + _14 <- index_11; + assume { Resolve2.resolve _15 }; + _15 <- key_2; + key_2 <- any k; + _12 <- Vecmap_OccupiedEntry_Type.C_OccupiedEntry _13 _15 _14; + goto BB5 + } + BB5 { + _0 <- Vecmap_Entry_Type.C_Occupied _12; + goto BB6 + } + BB6 { + goto BB9 + } + BB7 { + _0 <- Vecmap_Entry_Type.C_Vacant _17; + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + goto BB10 + } + BB10 { + return _0 + } + +end +module Vecmap_KeyRef_Type + use mach.int.Int + use prelude.UIntSize + type t_keyref 'k = + | C_KeyRef 'k usize + + let function keyref_key (self : t_keyref 'k) : 'k = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_KeyRef a _ -> a + end + let function keyref_min_idx (self : t_keyref 'k) : usize = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_KeyRef _ a -> a + end +end +module Core_Option_Option_Type + type t_option 't = + | C_None + | C_Some 't + + let function some_0 (self : t_option 't) : 't = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_None -> any 't + | C_Some a -> a + end +end +module CreusotContracts_Logic_Seq_Impl0_Get_Stub + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t +end +module CreusotContracts_Logic_Seq_Impl0_Get_Interface + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t +end +module CreusotContracts_Logic_Seq_Impl0_Get + type t + use seq.Seq + use mach.int.Int + use Core_Option_Option_Type as Core_Option_Option_Type + function get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t = + if ix < Seq.length self then Core_Option_Option_Type.C_Some (Seq.get self ix) else Core_Option_Option_Type.C_None + val get (self : Seq.seq t) (ix : int) : Core_Option_Option_Type.t_option t + ensures { result = get self ix } + +end +module Vecmap_Impl1_IsValidKeyrefLg_Stub + type k + type v + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate is_valid_keyref_lg [#"../src/lib.rs" 271 4 271 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + +end +module Vecmap_Impl1_IsValidKeyrefLg_Interface + type k + type v + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + predicate is_valid_keyref_lg [#"../src/lib.rs" 271 4 271 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + + axiom is_valid_keyref_lg_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v, key : Vecmap_KeyRef_Type.t_keyref k . ([#"../src/lib.rs" 270 15 270 31] IsSorted0.is_sorted self) -> true +end +module Vecmap_Impl1_IsValidKeyrefLg + type k + type v + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + use mach.int.UInt64 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get_Stub as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + predicate is_valid_keyref_lg [#"../src/lib.rs" 271 4 271 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + + = + [#"../src/lib.rs" 273 12 278 13] match (Get0.get (KeySeq0.key_seq self) (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key))) with + | Core_Option_Option_Type.C_Some k -> LeLog0.le_log k (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)) + | _ -> false + end + val is_valid_keyref_lg [#"../src/lib.rs" 271 4 271 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 270 15 270 31] IsSorted0.is_sorted self} + ensures { result = is_valid_keyref_lg self key } + + axiom is_valid_keyref_lg_spec : forall self : Vecmap_VecMap_Type.t_vecmap k v, key : Vecmap_KeyRef_Type.t_keyref k . ([#"../src/lib.rs" 270 15 270 31] IsSorted0.is_sorted self) -> true +end +module Vecmap_Impl1_IsValidKeyrefLg_Impl + type k + type v + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec ghost predicate is_valid_keyref_lg [#"../src/lib.rs" 271 4 271 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) + requires {[#"../src/lib.rs" 270 15 270 31] IsSorted0.is_sorted self} + + = [@vc:do_not_keep_trace] [@vc:sp] + [#"../src/lib.rs" 273 12 278 13] match (let a' = KeySeq0.key_seq self in Get0.get a' (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key))) with + | Core_Option_Option_Type.C_Some k -> let b' = DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key) in LeLog0.le_log k b' + | _ -> false + end +end +module Vecmap_Impl10_DeepModel_Stub + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + function deep_model [#"../src/lib.rs" 562 4 562 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + +end +module Vecmap_Impl10_DeepModel_Interface + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + function deep_model [#"../src/lib.rs" 562 4 562 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + +end +module Vecmap_Impl10_DeepModel + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function deep_model [#"../src/lib.rs" 562 4 562 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + + = + [#"../src/lib.rs" 563 19 563 57] (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key self), UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx self)) + val deep_model [#"../src/lib.rs" 562 4 562 44] (self : Vecmap_KeyRef_Type.t_keyref k) : (DeepModelTy0.deepModelTy, int) + ensures { result = deep_model self } + +end +module Vecmap_Impl10_DeepModelTy_Type + type k + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + type deepModelTy = + (DeepModelTy0.deepModelTy, int) +end +module CreusotContracts_Model_Impl0_DeepModelTy_Type + type t + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = t + type deepModelTy = + DeepModelTy0.deepModelTy +end +module Vecmap_Impl12_AsRef_Interface + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy2 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone Vecmap_Impl10_DeepModelTy_Type as DeepModelTy0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = Vecmap_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val as_ref [@cfg:stackify] [#"../src/lib.rs" 580 4 580 38] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 579 14 579 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + +end +module Vecmap_Impl12_AsRef + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy2 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel4 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel3 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone Vecmap_Impl10_DeepModelTy_Type as DeepModelTy0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Vecmap_Impl10_DeepModel as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = Vecmap_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel2.deep_model + let rec cfg as_ref [@cfg:stackify] [#"../src/lib.rs" 580 4 580 38] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 579 14 579 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_KeyRef_Type.t_keyref k; + var _3 : usize; + var _4 : k; + var _5 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _3 <- Vecmap_KeyRef_Type.keyref_min_idx self_1; + _5 <- Vecmap_KeyRef_Type.keyref_key self_1; + assume { Resolve0.resolve self_1 }; + _4 <- _5; + assume { Resolve1.resolve _5 }; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _4 _3; + return _0 + } + +end +module Vecmap_Impl13_ToOwned_Stub + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 591 4 591 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + +end +module Vecmap_Impl13_ToOwned_Interface + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 591 4 591 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + + axiom to_owned_spec : forall self : Vecmap_KeyRef_Type.t_keyref k . [#"../src/lib.rs" 590 14 590 54] DeepModel0.deep_model self = DeepModel1.deep_model (to_owned self) +end +module Vecmap_Impl13_ToOwned + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + function to_owned [#"../src/lib.rs" 591 4 591 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + + = + [#"../src/lib.rs" 592 8 595 9] Vecmap_KeyRef_Type.C_KeyRef (Vecmap_KeyRef_Type.keyref_key self) (Vecmap_KeyRef_Type.keyref_min_idx self) + val to_owned [#"../src/lib.rs" 591 4 591 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { result = to_owned self } + + axiom to_owned_spec : forall self : Vecmap_KeyRef_Type.t_keyref k . [#"../src/lib.rs" 590 14 590 54] DeepModel0.deep_model self = DeepModel1.deep_model (to_owned self) +end +module Vecmap_Impl13_ToOwned_Impl + type k + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel3 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone Vecmap_Impl10_DeepModel as DeepModel0 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel2.deep_model + let rec ghost function to_owned [#"../src/lib.rs" 591 4 591 34] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 590 14 590 54] DeepModel0.deep_model self = DeepModel1.deep_model result } + + = [@vc:do_not_keep_trace] [@vc:sp] + [#"../src/lib.rs" 592 8 595 9] Vecmap_KeyRef_Type.C_KeyRef (Vecmap_KeyRef_Type.keyref_key self) (Vecmap_KeyRef_Type.keyref_min_idx self) +end +module Alloc_Vec_Impl10_Deref_Interface + type t + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t, + type a = a + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val deref [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : seq t + ensures { ShallowModel0.shallow_model result = ShallowModel1.shallow_model self } + +end +module Alloc_Vec_Impl10_Deref + type t + type a + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t, + type a = a + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val deref [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : seq t + ensures { ShallowModel0.shallow_model result = ShallowModel1.shallow_model self } + +end +module Core_Slice_Impl0_Get_Interface + type t + type i + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + type Output0.output = Output0.output + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val get [@cfg:stackify] (self : seq t) (index : i) : Core_Option_Option_Type.t_option Output0.output + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) -> (exists r : Output0.output . result = Core_Option_Option_Type.C_Some r /\ HasValue0.has_value index (ShallowModel0.shallow_model self) r) } + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) \/ result = Core_Option_Option_Type.C_None } + +end +module Core_Slice_Impl0_Get + type t + type i + use prelude.Borrow + use prelude.Slice + use seq.Seq + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + type Output0.output = Output0.output + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val get [@cfg:stackify] (self : seq t) (index : i) : Core_Option_Option_Type.t_option Output0.output + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) -> (exists r : Output0.output . result = Core_Option_Option_Type.C_Some r /\ HasValue0.has_value index (ShallowModel0.shallow_model self) r) } + ensures { InBounds0.in_bounds index (ShallowModel0.shallow_model self) \/ result = Core_Option_Option_Type.C_None } + +end +module Core_Cmp_Impls_Impl10_Le_Interface + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val le [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = LeLog0.le_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_Impls_Impl10_Le + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val le [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = LeLog0.le_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel_Stub + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel_Interface + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t + axiom shallow_model_spec : forall self : seq t . shallow_model self = Slice.id self && Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module CreusotContracts_Std1_Slice_Impl0_ShallowModel + type t + use seq.Seq + use mach.int.UInt64 + use mach.int.Int + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + function shallow_model (self : seq t) : Seq.seq t + val shallow_model (self : seq t) : Seq.seq t + ensures { result = shallow_model self } + + axiom shallow_model_spec : forall self : seq t . shallow_model self = Slice.id self && Seq.length (shallow_model self) <= UInt64.to_int Max0.mAX' +end +module Vecmap_Impl1_IsValidKeyref_Interface + type k + type v + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy1 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel3 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel_Stub as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone Vecmap_Impl10_DeepModel_Stub as DeepModel1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy1.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel3.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone Vecmap_Impl1_IsValidKeyrefLg_Stub as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + axiom . + clone Vecmap_Impl13_ToOwned_Stub as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy1.deepModelTy, + axiom . + val is_valid_keyref [@cfg:stackify] [#"../src/lib.rs" 262 4 262 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 257 15 257 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 258 14 258 66] result = IsValidKeyrefLg0.is_valid_keyref_lg self (ToOwned0.to_owned key) } + ensures { [#"../src/lib.rs" 259 4 259 57] result -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) } + ensures { [#"../src/lib.rs" 260 4 261 57] result -> (forall i : int . i >= 0 /\ i <= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + +end +module Vecmap_Impl1_IsValidKeyref + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use mach.int.UInt64 + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel4 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get1 with + type t = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel3 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone Core_Cmp_Impls_Impl10_Le_Interface as Le0 with + type a = k, + type b = k, + function DeepModel0.deep_model = DeepModel4.deep_model, + function DeepModel1.deep_model = DeepModel4.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = Core_Option_Option_Type.t_option (k, v) + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Core_Slice_Impl0_Get_Interface as Get0 with + type t = (k, v), + type i = usize, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + type Output0.output = Output0.output, + predicate HasValue0.has_value = HasValue0.has_value + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get1.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + let rec cfg is_valid_keyref [@cfg:stackify] [#"../src/lib.rs" 262 4 262 55] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : bool + requires {[#"../src/lib.rs" 257 15 257 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 258 14 258 66] result = IsValidKeyrefLg0.is_valid_keyref_lg self (ToOwned0.to_owned key) } + ensures { [#"../src/lib.rs" 259 4 259 57] result -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) } + ensures { [#"../src/lib.rs" 260 4 261 57] result -> (forall i : int . i >= 0 /\ i <= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx key) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : bool; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : Vecmap_KeyRef_Type.t_keyref k; + var _7 : Core_Option_Option_Type.t_option (k, v); + var _8 : seq (k, v); + var _9 : seq (k, v); + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _11 : usize; + var _12 : isize; + var k_13 : k; + var _14 : k; + var _15 : k; + var _16 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _10 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _9 <- ([#"../src/lib.rs" 263 14 263 37] Deref0.deref _10); + goto BB1 + } + BB1 { + _8 <- _9; + assume { Resolve1.resolve _9 }; + _11 <- Vecmap_KeyRef_Type.keyref_min_idx key_2; + _7 <- ([#"../src/lib.rs" 263 14 263 37] Get0.get _8 _11); + goto BB2 + } + BB2 { + switch (_7) + | Core_Option_Option_Type.C_Some _ -> goto BB4 + | _ -> goto BB3 + end + } + BB3 { + assume { Resolve2.resolve key_2 }; + assume { Resolve3.resolve _7 }; + _0 <- ([#"../src/lib.rs" 265 17 265 22] false); + goto BB6 + } + BB4 { + k_13 <- (let (a, _) = Core_Option_Option_Type.some_0 _7 in a); + assume { Resolve3.resolve _7 }; + _14 <- k_13; + assume { Resolve4.resolve k_13 }; + _16 <- Vecmap_KeyRef_Type.keyref_key key_2; + assume { Resolve2.resolve key_2 }; + _15 <- _16; + assume { Resolve4.resolve _16 }; + _0 <- ([#"../src/lib.rs" 264 28 264 40] Le0.le _14 _15); + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Ops_Range_Range_Type + type t_range 'idx = + | C_Range 'idx 'idx + + let function range_end (self : t_range 'idx) : 'idx = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Range _ a -> a + end + let function range_start (self : t_range 'idx) : 'idx = [@vc:do_not_keep_trace] [@vc:sp] + match (self) with + | C_Range a _ -> a + end +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Stub + type self + predicate into_iter_pre (self : self) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Interface + type self + predicate into_iter_pre (self : self) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre + type self + predicate into_iter_pre (self : self) = + true + val into_iter_pre (self : self) : bool + ensures { result = into_iter_pre self } + +end +module Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type + type self + type intoIter +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Stub + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Interface + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) +end +module CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost + type self + clone Core_Iter_Traits_Collect_IntoIterator_IntoIter_Type as IntoIter0 with + type self = self + predicate into_iter_post (self : self) (res : IntoIter0.intoIter) + val into_iter_post (self : self) (res : IntoIter0.intoIter) : bool + ensures { result = into_iter_post self res } + +end +module CreusotContracts_Invariant_Invariant_Invariant_Stub + type self + predicate invariant' (self : self) +end +module CreusotContracts_Invariant_Invariant_Invariant_Interface + type self + predicate invariant' (self : self) +end +module CreusotContracts_Invariant_Invariant_Invariant + type self + predicate invariant' (self : self) + val invariant' (self : self) : bool + ensures { result = invariant' self } + +end +module Core_Iter_Traits_Collect_Impl0_IntoIter_Type + type i + type intoIter = + i +end +module Core_Iter_Traits_Collect_Impl0_IntoIter_Interface + type i + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter0 with + type i = i + clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with + type self = i + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Stub as IntoIterPost0 with + type self = i, + type IntoIter0.intoIter = IntoIter0.intoIter + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Stub as IntoIterPre0 with + type self = i + val into_iter [@cfg:stackify] (self : i) : i + requires {IntoIterPre0.into_iter_pre self} + ensures { IntoIterPost0.into_iter_post self result } + ensures { Invariant0.invariant' result } + +end +module Core_Iter_Traits_Collect_Impl0_IntoIter + type i + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter0 with + type i = i + clone CreusotContracts_Invariant_Invariant_Invariant_Interface as Invariant0 with + type self = i + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPost_Interface as IntoIterPost0 with + type self = i, + type IntoIter0.intoIter = IntoIter0.intoIter + clone CreusotContracts_Std1_Iter_IntoIterator_IntoIterPre_Interface as IntoIterPre0 with + type self = i + val into_iter [@cfg:stackify] (self : i) : i + requires {IntoIterPre0.into_iter_pre self} + ensures { IntoIterPost0.into_iter_post self result } + ensures { Invariant0.invariant' result } + +end +module CreusotContracts_Std1_Ops_Impl3_Invariant_Stub + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) +end +module CreusotContracts_Std1_Ops_Impl3_Invariant_Interface + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) +end +module CreusotContracts_Std1_Ops_Impl3_Invariant + type idx + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate invariant' (self : Core_Ops_Range_Range_Type.t_range idx) = + true + val invariant' (self : Core_Ops_Range_Range_Type.t_range idx) : bool + ensures { result = invariant' self } + +end +module CreusotContracts_Std1_Iter_Iterator_Completed_Stub + type self + use prelude.Borrow + predicate completed (self : borrowed self) +end +module CreusotContracts_Std1_Iter_Iterator_Completed_Interface + type self + use prelude.Borrow + predicate completed (self : borrowed self) +end +module CreusotContracts_Std1_Iter_Iterator_Completed + type self + use prelude.Borrow + predicate completed (self : borrowed self) + val completed (self : borrowed self) : bool + ensures { result = completed self } + +end +module Core_Iter_Traits_Iterator_Iterator_Item_Type + type self + type item +end +module CreusotContracts_Std1_Iter_Iterator_Produces_Stub + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) +end +module CreusotContracts_Std1_Iter_Iterator_Produces_Interface + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) +end +module CreusotContracts_Std1_Iter_Iterator_Produces + type self + use seq.Seq + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = self + predicate produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) + val produces (self : self) (visited : Seq.seq Item0.item) (_3' : self) : bool + ensures { result = produces self visited _3' } + +end +module Core_Iter_Range_Impl3_Item_Type + type a + type item = + a +end +module Core_Iter_Range_Impl3_Next_Interface + type a + use prelude.Borrow + use seq.Seq + clone Core_Iter_Range_Impl3_Item_Type as Item1 with + type a = a + use Core_Option_Option_Type as Core_Option_Option_Type + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Iterator_Produces_Stub as Produces0 with + type self = Core_Ops_Range_Range_Type.t_range a, + type Item0.item = Item1.item + clone CreusotContracts_Std1_Iter_Iterator_Completed_Stub as Completed0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = a + val next [@cfg:stackify] (self : borrowed (Core_Ops_Range_Range_Type.t_range a)) : Core_Option_Option_Type.t_option a + requires {Invariant0.invariant' ( * self)} + ensures { Invariant0.invariant' ( ^ self) } + ensures { match (result) with + | Core_Option_Option_Type.C_None -> Completed0.completed self + | Core_Option_Option_Type.C_Some v -> Produces0.produces ( * self) (Seq.singleton v) ( ^ self) + end } + +end +module Core_Iter_Range_Impl3_Next + type a + use prelude.Borrow + use seq.Seq + clone Core_Iter_Range_Impl3_Item_Type as Item1 with + type a = a + use Core_Option_Option_Type as Core_Option_Option_Type + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Iterator_Produces_Interface as Produces0 with + type self = Core_Ops_Range_Range_Type.t_range a, + type Item0.item = Item1.item + clone CreusotContracts_Std1_Iter_Iterator_Completed_Interface as Completed0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone Core_Iter_Traits_Iterator_Iterator_Item_Type as Item0 with + type self = Core_Ops_Range_Range_Type.t_range a + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Interface as Invariant0 with + type idx = a + val next [@cfg:stackify] (self : borrowed (Core_Ops_Range_Range_Type.t_range a)) : Core_Option_Option_Type.t_option a + requires {Invariant0.invariant' ( * self)} + ensures { Invariant0.invariant' ( ^ self) } + ensures { match (result) with + | Core_Option_Option_Type.C_None -> Completed0.completed self + | Core_Option_Option_Type.C_Some v -> Produces0.produces ( * self) (Seq.singleton v) ( ^ self) + end } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Produces + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = idx, + type DeepModelTy0.deepModelTy = int + predicate produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) + + = + Core_Ops_Range_Range_Type.range_end self = Core_Ops_Range_Range_Type.range_end o /\ DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) <= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) /\ (Seq.length visited > 0 -> DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) <= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_end o)) /\ Seq.length visited = DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start o) - DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) /\ (forall i : int . 0 <= i /\ i < Seq.length visited -> DeepModel0.deep_model (Seq.get visited i) = DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start self) + i) + val produces (self : Core_Ops_Range_Range_Type.t_range idx) (visited : Seq.seq idx) (o : Core_Ops_Range_Range_Type.t_range idx) : bool + ensures { result = produces self visited o } + +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre_Stub + type i + predicate into_iter_pre (self : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre_Interface + type i + predicate into_iter_pre (self : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPre + type i + clone CreusotContracts_Invariant_Invariant_Invariant_Stub as Invariant0 with + type self = i + predicate into_iter_pre (self : i) = + Invariant0.invariant' self + val into_iter_pre (self : i) : bool + ensures { result = into_iter_pre self } + +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost_Stub + type i + predicate into_iter_post (self : i) (res : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost_Interface + type i + predicate into_iter_post (self : i) (res : i) +end +module CreusotContracts_Std1_Iter_Impl0_IntoIterPost + type i + predicate into_iter_post (self : i) (res : i) = + self = res + val into_iter_post (self : i) (res : i) : bool + ensures { result = into_iter_post self res } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () + axiom produces_refl_spec : forall a : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Produces0.produces a (Seq.empty ) a +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () = + () + val produces_refl (a : Core_Ops_Range_Range_Type.t_range idx) : () + requires {Invariant0.invariant' a} + ensures { result = produces_refl a } + + axiom produces_refl_spec : forall a : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Produces0.produces a (Seq.empty ) a +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans_Stub + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans_Interface + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + + axiom produces_trans_spec : forall a : Core_Ops_Range_Range_Type.t_range idx, ab : Seq.seq idx, b : Core_Ops_Range_Range_Type.t_range idx, bc : Seq.seq idx, c : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Invariant0.invariant' b -> Invariant0.invariant' c -> Produces0.produces a ab b -> Produces0.produces b bc c -> Produces0.produces a (Seq.(++) ab bc) c +end +module CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans + type idx + use seq.Seq + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces_Stub as Produces0 with + type idx = idx + clone CreusotContracts_Std1_Ops_Impl3_Invariant_Stub as Invariant0 with + type idx = idx + function produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + + = + () + val produces_trans (a : Core_Ops_Range_Range_Type.t_range idx) (ab : Seq.seq idx) (b : Core_Ops_Range_Range_Type.t_range idx) (bc : Seq.seq idx) (c : Core_Ops_Range_Range_Type.t_range idx) : () + requires {Invariant0.invariant' a} + requires {Invariant0.invariant' b} + requires {Invariant0.invariant' c} + requires {Produces0.produces a ab b} + requires {Produces0.produces b bc c} + ensures { result = produces_trans a ab b bc c } + + axiom produces_trans_spec : forall a : Core_Ops_Range_Range_Type.t_range idx, ab : Seq.seq idx, b : Core_Ops_Range_Range_Type.t_range idx, bc : Seq.seq idx, c : Core_Ops_Range_Range_Type.t_range idx . Invariant0.invariant' a -> Invariant0.invariant' b -> Invariant0.invariant' c -> Produces0.produces a ab b -> Produces0.produces b bc c -> Produces0.produces a (Seq.(++) ab bc) c +end +module CreusotContracts_Logic_Int_Impl18_DeepModel_Stub + use mach.int.Int + use prelude.UIntSize + function deep_model (self : usize) : int +end +module CreusotContracts_Logic_Int_Impl18_DeepModel_Interface + use mach.int.Int + use prelude.UIntSize + function deep_model (self : usize) : int +end +module CreusotContracts_Logic_Int_Impl18_DeepModel + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + function deep_model (self : usize) : int = + [#"../src/lib.rs" 326 50 327 16] UInt64.to_int self + val deep_model (self : usize) : int + ensures { result = deep_model self } + +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed_Stub + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed_Interface + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) +end +module CreusotContracts_Std1_Iter_Range_Impl0_Completed + type idx + use prelude.Borrow + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = idx, + type DeepModelTy0.deepModelTy = int + clone CreusotContracts_Resolve_Impl1_Resolve_Stub as Resolve0 with + type t = Core_Ops_Range_Range_Type.t_range idx + predicate completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) = + Resolve0.resolve self /\ DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_start ( * self)) >= DeepModel0.deep_model (Core_Ops_Range_Range_Type.range_end ( * self)) + val completed (self : borrowed (Core_Ops_Range_Range_Type.t_range idx)) : bool + ensures { result = completed self } + +end +module Vecmap_Impl1_EntryFromRef_Interface + type k + type v + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant_Stub as Invariant1 with + type k = k, + type v = v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + use Vecmap_Entry_Type as Vecmap_Entry_Type + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone Vecmap_Impl1_IsValidKeyrefLg_Stub as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + axiom . + val entry_from_ref [@cfg:stackify] [#"../src/lib.rs" 102 4 102 80] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key_hint : Vecmap_KeyRef_Type.t_keyref k) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 97 15 97 31] IsSorted0.is_sorted ( * self)} + requires {[#"../src/lib.rs" 98 15 98 48] IsValidKeyrefLg0.is_valid_keyref_lg ( * self) key_hint} + requires {[#"../src/lib.rs" 99 15 99 60] LeLog0.le_log (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key_hint)) (DeepModel0.deep_model key)} + ensures { [#"../src/lib.rs" 100 4 100 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 101 4 101 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + +end +module Vecmap_Impl1_EntryFromRef + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.Ghost + use seq.Seq + use prelude.IntSize + use prelude.Int8 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + clone CreusotContracts_Logic_Int_Impl18_DeepModel as DeepModel5 + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with + type t = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Completed as Completed0 with + type idx = usize, + predicate Resolve0.resolve = Resolve3.resolve, + function DeepModel0.deep_model = DeepModel5.deep_model + clone Core_Iter_Range_Impl3_Item_Type as Item0 with + type a = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces as Produces0 with + type idx = usize, + function DeepModel0.deep_model = DeepModel5.deep_model + clone CreusotContracts_Std1_Ops_Impl3_Invariant as Invariant2 with + type idx = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans as ProducesTrans0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl as ProducesRefl0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter1 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPost as IntoIterPost0 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPre as IntoIterPre0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate Invariant0.invariant' = Invariant2.invariant' + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl10_DeepModel as DeepModel4 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel3 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy2.deepModelTy, + function DeepModel0.deep_model = DeepModel3.deep_model + clone Vecmap_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel4.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + clone Vecmap_Impl10_DeepModelTy_Type as DeepModelTy1 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = Vecmap_KeyRef_Type.t_keyref k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Core_Cmp_Ord_Cmp_Interface as Cmp0 with + type self = k, + function DeepModel0.deep_model = DeepModel0.deep_model, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve7 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Core_Iter_Range_Impl3_Next_Interface as Next0 with + type a = usize, + predicate Invariant0.invariant' = Invariant2.invariant', + type Item0.item = Item0.item, + predicate Completed0.completed = Completed0.completed, + predicate Produces0.produces = Produces0.produces + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Interface as IntoIter0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate IntoIterPre0.into_iter_pre = IntoIterPre0.into_iter_pre, + predicate IntoIterPost0.into_iter_post = IntoIterPost0.into_iter_post, + predicate Invariant0.invariant' = Invariant2.invariant' + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get0.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl1_IsValidKeyref_Interface as IsValidKeyref0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ToOwned0.to_owned = ToOwned0.to_owned, + predicate IsValidKeyrefLg0.is_valid_keyref_lg = IsValidKeyrefLg0.is_valid_keyref_lg, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel3.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function DeepModel1.deep_model = DeepModel2.deep_model, + function DeepModel2.deep_model = DeepModel4.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + function DeepModel3.deep_model = DeepModel0.deep_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Vecmap_Impl12_AsRef_Interface as AsRef0 with + type k = k, + function DeepModel0.deep_model = DeepModel1.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + type DeepModelTy2.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant as Invariant1 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_Entry_Type as Vecmap_Entry_Type + let rec cfg entry_from_ref [@cfg:stackify] [#"../src/lib.rs" 102 4 102 80] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key_hint : Vecmap_KeyRef_Type.t_keyref k) (key : k) : Vecmap_Entry_Type.t_entry k v + requires {[#"../src/lib.rs" 97 15 97 31] IsSorted0.is_sorted ( * self)} + requires {[#"../src/lib.rs" 98 15 98 48] IsValidKeyrefLg0.is_valid_keyref_lg ( * self) key_hint} + requires {[#"../src/lib.rs" 99 15 99 60] LeLog0.le_log (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key_hint)) (DeepModel0.deep_model key)} + ensures { [#"../src/lib.rs" 100 4 100 75] forall e : Vecmap_OccupiedEntry_Type.t_occupiedentry k v . result = Vecmap_Entry_Type.C_Occupied e -> Invariant0.invariant' e } + ensures { [#"../src/lib.rs" 101 4 101 73] forall e : Vecmap_VacantEntry_Type.t_vacantentry k v . result = Vecmap_Entry_Type.C_Vacant e -> Invariant1.invariant' e } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_Entry_Type.t_entry k v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_hint_2 : Vecmap_KeyRef_Type.t_keyref k; + var key_3 : k; + var _9 : (); + var _10 : bool; + var _11 : (); + var _12 : bool; + var _13 : bool; + var _14 : Vecmap_VecMap_Type.t_vecmap k v; + var _15 : Vecmap_KeyRef_Type.t_keyref k; + var _16 : Vecmap_KeyRef_Type.t_keyref k; + var _17 : Vecmap_KeyRef_Type.t_keyref k; + var _18 : Vecmap_KeyRef_Type.t_keyref k; + var _19 : (); + var min_idx_20 : usize; + var _21 : (); + var iter_22 : Core_Ops_Range_Range_Type.t_range usize; + var _23 : Core_Ops_Range_Range_Type.t_range usize; + var _24 : usize; + var _25 : usize; + var _26 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var iter_old_27 : Ghost.ghost_ty (Core_Ops_Range_Range_Type.t_range usize); + var _29 : (); + var produced_30 : Ghost.ghost_ty (Seq.seq usize); + var _33 : (); + var _37 : (); + var _38 : Core_Option_Option_Type.t_option usize; + var _39 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _40 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _41 : isize; + var i_42 : usize; + var _43 : Ghost.ghost_ty (Seq.seq usize); + var _45 : (); + var i_46 : usize; + var _47 : Core_Cmp_Ordering_Type.t_ordering; + var _48 : k; + var _49 : (k, v); + var _50 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _51 : usize; + var _52 : k; + var _53 : k; + var _54 : int8; + var _55 : (); + var _56 : Vecmap_OccupiedEntry_Type.t_occupiedentry k v; + var _57 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _58 : usize; + var _59 : k; + var _60 : (); + var _61 : (); + var _62 : bool; + var _63 : bool; + var _64 : usize; + var _65 : (); + var _66 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var _67 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _68 : usize; + var _69 : k; + var _70 : (); + var i_71 : usize; + var _72 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _73 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var _74 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _75 : usize; + var _76 : k; + { + self_1 <- self; + key_hint_2 <- key_hint; + key_3 <- key; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + _10 <- true; + switch (_10) + | False -> goto BB8 + | True -> goto BB3 + end + } + BB3 { + _14 <- * self_1; + _18 <- key_hint_2; + _17 <- ([#"../src/lib.rs" 103 44 103 61] AsRef0.as_ref _18); + goto BB4 + } + BB4 { + _16 <- _17; + assume { Resolve0.resolve _17 }; + _15 <- _16; + assume { Resolve1.resolve _16 }; + _13 <- ([#"../src/lib.rs" 103 22 103 62] IsValidKeyref0.is_valid_keyref _14 _15); + goto BB5 + } + BB5 { + _12 <- not _13; + switch (_12) + | False -> goto BB7 + | True -> goto BB6 + end + } + BB6 { + assume { Resolve2.resolve self_1 }; + absurd + } + BB7 { + _11 <- (); + _9 <- (); + goto BB9 + } + BB8 { + _9 <- (); + goto BB9 + } + BB9 { + min_idx_20 <- Vecmap_KeyRef_Type.keyref_min_idx key_hint_2; + _24 <- min_idx_20; + _26 <- Vecmap_VecMap_Type.vecmap_v ( * self_1); + _25 <- ([#"../src/lib.rs" 107 26 107 38] Len0.len _26); + goto BB10 + } + BB10 { + _23 <- Core_Ops_Range_Range_Type.C_Range _24 _25; + iter_22 <- ([#"../src/lib.rs" 106 8 106 29] IntoIter0.into_iter _23); + goto BB11 + } + BB11 { + _29 <- (); + iter_old_27 <- ([#"../src/lib.rs" 106 8 106 29] Ghost.new iter_22); + goto BB12 + } + BB12 { + _33 <- (); + produced_30 <- ([#"../src/lib.rs" 106 8 106 29] Ghost.new (Seq.empty )); + goto BB13 + } + BB13 { + goto BB14 + } + BB14 { + invariant type_invariant { [#"../src/lib.rs" 106 8 106 29] Invariant2.invariant' iter_22 }; + invariant structural { [#"../src/lib.rs" 106 8 106 29] Produces0.produces (Ghost.inner iter_old_27) (Ghost.inner produced_30) iter_22 }; + invariant t { [#"../src/lib.rs" 106 23 106 27] true }; + _40 <- borrow_mut iter_22; + iter_22 <- ^ _40; + _39 <- borrow_mut ( * _40); + _40 <- { _40 with current = ( ^ _39) }; + _38 <- ([#"../src/lib.rs" 106 8 106 29] Next0.next _39); + goto BB15 + } + BB15 { + assume { Resolve3.resolve _40 }; + switch (_38) + | Core_Option_Option_Type.C_None -> goto BB16 + | Core_Option_Option_Type.C_Some _ -> goto BB18 + end + } + BB16 { + _21 <- (); + _72 <- Vecmap_VecMap_Type.vecmap_v ( * self_1); + i_71 <- ([#"../src/lib.rs" 128 16 128 28] Len0.len _72); + goto BB31 + } + BB17 { + assume { Resolve2.resolve self_1 }; + assume { Resolve4.resolve key_hint_2 }; + assume { Resolve5.resolve key_3 }; + absurd + } + BB18 { + i_42 <- Core_Option_Option_Type.some_0 _38; + _45 <- (); + _43 <- ([#"../src/lib.rs" 106 8 106 29] Ghost.new (Seq.(++) (Ghost.inner produced_30) (Seq.singleton i_42))); + goto BB19 + } + BB19 { + produced_30 <- _43; + _43 <- any Ghost.ghost_ty (Seq.seq usize); + i_46 <- i_42; + _50 <- Vecmap_VecMap_Type.vecmap_v ( * self_1); + _51 <- i_46; + _49 <- ([#"../src/lib.rs" 108 18 108 27] Index0.index _50 _51); + goto BB20 + } + BB20 { + _48 <- (let (a, _) = _49 in a); + assume { Resolve6.resolve _49 }; + _53 <- key_3; + _52 <- _53; + assume { Resolve7.resolve _53 }; + _47 <- ([#"../src/lib.rs" 108 18 108 39] Cmp0.cmp _48 _52); + goto BB21 + } + BB21 { + switch (_47) + | Core_Cmp_Ordering_Type.C_Equal -> goto BB23 + | Core_Cmp_Ordering_Type.C_Greater -> goto BB26 + | _ -> goto BB22 + end + } + BB22 { + _37 <- (); + goto BB14 + } + BB23 { + _57 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _57) }; + assume { Resolve2.resolve self_1 }; + _58 <- i_46; + assume { Resolve5.resolve _59 }; + _59 <- key_3; + key_3 <- any k; + _56 <- Vecmap_OccupiedEntry_Type.C_OccupiedEntry _57 _59 _58; + goto BB24 + } + BB24 { + _0 <- Vecmap_Entry_Type.C_Occupied _56; + goto BB25 + } + BB25 { + goto BB35 + } + BB26 { + _64 <- i_46; + _63 <- ([#"../src/lib.rs" 118 28 118 34] _64 >= ([#"../src/lib.rs" 118 33 118 34] (1 : usize))); + _62 <- not _63; + switch (_62) + | False -> goto BB28 + | True -> goto BB27 + end + } + BB27 { + assume { Resolve2.resolve self_1 }; + absurd + } + BB28 { + _61 <- (); + _67 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _67) }; + assume { Resolve2.resolve self_1 }; + _68 <- i_46; + assume { Resolve5.resolve _69 }; + _69 <- key_3; + key_3 <- any k; + _66 <- Vecmap_VacantEntry_Type.C_VacantEntry _67 _69 _68; + goto BB29 + } + BB29 { + _0 <- Vecmap_Entry_Type.C_Vacant _66; + goto BB30 + } + BB30 { + goto BB35 + } + BB31 { + _74 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _74) }; + assume { Resolve2.resolve self_1 }; + _75 <- i_71; + assume { Resolve5.resolve _76 }; + _76 <- key_3; + key_3 <- any k; + _73 <- Vecmap_VacantEntry_Type.C_VacantEntry _74 _76 _75; + goto BB32 + } + BB32 { + _0 <- Vecmap_Entry_Type.C_Vacant _73; + goto BB33 + } + BB33 { + goto BB34 + } + BB34 { + goto BB37 + } + BB35 { + goto BB36 + } + BB36 { + goto BB37 + } + BB37 { + assume { Resolve4.resolve key_hint_2 }; + return _0 + } + +end +module Core_Cmp_Impls_Impl10_Ge_Interface + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val ge [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = GeLog0.ge_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_Impls_Impl10_Ge + type a + type b + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = a + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = b, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = a, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val ge [@cfg:stackify] (self : a) (other : b) : bool + ensures { result = GeLog0.ge_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Vecmap_Impl1_FindRandomMappingAfter_Interface + type k + type v + use mach.int.Int + use seq.Seq + use prelude.Borrow + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val find_random_mapping_after [@cfg:stackify] [#"../src/lib.rs" 148 4 148 93] (self : Vecmap_VecMap_Type.t_vecmap k v) (min_key_inclusive : k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 139 15 139 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 140 4 141 66] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive)) } + ensures { [#"../src/lib.rs" 142 4 143 66] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= 0 /\ i < UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 144 4 145 67] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 146 4 147 61] forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping -> (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a))) in a) = (let (_, a) = mapping in a) } + +end +module Vecmap_Impl1_FindRandomMappingAfter + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use prelude.Slice + use seq.Seq + use mach.int.UInt64 + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel2 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel2.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = v + clone Core_Cmp_Impls_Impl10_Ge_Interface as Ge0 with + type a = k, + type b = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel2.deep_model, + predicate GeLog0.ge_log = GeLog0.ge_log, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_Get_Interface as Get0 with + type t = (k, v), + type i = usize, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + type Output0.output = Output0.output, + predicate HasValue0.has_value = HasValue0.has_value + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg find_random_mapping_after [@cfg:stackify] [#"../src/lib.rs" 148 4 148 93] (self : Vecmap_VecMap_Type.t_vecmap k v) (min_key_inclusive : k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 139 15 139 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 140 4 141 66] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive)) } + ensures { [#"../src/lib.rs" 142 4 143 66] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= 0 /\ i < UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 144 4 145 67] forall i : int . forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping /\ i >= UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a)) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model min_key_inclusive) } + ensures { [#"../src/lib.rs" 146 4 147 61] forall mapping : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some mapping -> (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) (UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = mapping in a))) in a) = (let (_, a) = mapping in a) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v); + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var min_key_inclusive_2 : k; + var _8 : Core_Result_Result_Type.t_result usize usize; + var _9 : Vecmap_VecMap_Type.t_vecmap k v; + var _10 : k; + var _11 : k; + var _12 : isize; + var index_13 : usize; + var key_14 : k; + var value_15 : v; + var _16 : (k, v); + var _17 : (k, v); + var _18 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _19 : usize; + var _20 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _21 : Vecmap_KeyRef_Type.t_keyref k; + var _22 : k; + var _23 : usize; + var _24 : v; + var index_25 : usize; + var _26 : Core_Option_Option_Type.t_option (k, v); + var _27 : seq (k, v); + var _28 : seq (k, v); + var _29 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _30 : usize; + var _31 : isize; + var key_32 : k; + var value_33 : v; + var _34 : (); + var _35 : bool; + var _36 : bool; + var _37 : k; + var _38 : k; + var _39 : k; + var _40 : k; + var _41 : (); + var _42 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _43 : Vecmap_KeyRef_Type.t_keyref k; + var _44 : k; + var _45 : usize; + var _46 : v; + { + self_1 <- self; + min_key_inclusive_2 <- min_key_inclusive; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + _9 <- self_1; + _11 <- min_key_inclusive_2; + _10 <- _11; + assume { Resolve0.resolve _11 }; + _8 <- ([#"../src/lib.rs" 149 14 149 45] FindK0.find_k _9 _10); + goto BB4 + } + BB4 { + switch (_8) + | Core_Result_Result_Type.C_Ok _ -> goto BB7 + | Core_Result_Result_Type.C_Err _ -> goto BB5 + end + } + BB5 { + index_25 <- Core_Result_Result_Type.err_0 _8; + _29 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _28 <- ([#"../src/lib.rs" 160 32 160 49] Deref0.deref _29); + goto BB9 + } + BB6 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve min_key_inclusive_2 }; + absurd + } + BB7 { + index_13 <- Core_Result_Result_Type.ok_0 _8; + _18 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _19 <- index_13; + _17 <- ([#"../src/lib.rs" 151 36 151 49] Index0.index _18 _19); + goto BB8 + } + BB8 { + _16 <- _17; + assume { Resolve6.resolve _17 }; + key_14 <- (let (a, _) = _16 in a); + value_15 <- (let (_, a) = _16 in a); + assume { Resolve6.resolve _16 }; + _22 <- key_14; + assume { Resolve0.resolve key_14 }; + _23 <- index_13; + _21 <- Vecmap_KeyRef_Type.C_KeyRef _22 _23; + _24 <- value_15; + assume { Resolve5.resolve value_15 }; + _20 <- (_21, _24); + _0 <- Core_Option_Option_Type.C_Some _20; + goto BB18 + } + BB9 { + _27 <- _28; + assume { Resolve3.resolve _28 }; + _30 <- index_25; + _26 <- ([#"../src/lib.rs" 160 32 160 49] Get0.get _27 _30); + goto BB10 + } + BB10 { + switch (_26) + | Core_Option_Option_Type.C_None -> goto BB11 + | Core_Option_Option_Type.C_Some _ -> goto BB13 + end + } + BB11 { + assume { Resolve4.resolve _26 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB17 + } + BB12 { + assume { Resolve2.resolve min_key_inclusive_2 }; + assume { Resolve4.resolve _26 }; + absurd + } + BB13 { + key_32 <- (let (a, _) = Core_Option_Option_Type.some_0 _26 in a); + value_33 <- (let (_, a) = Core_Option_Option_Type.some_0 _26 in a); + assume { Resolve4.resolve _26 }; + _37 <- key_32; + _40 <- min_key_inclusive_2; + _39 <- _40; + assume { Resolve0.resolve _40 }; + _38 <- _39; + assume { Resolve0.resolve _39 }; + _36 <- ([#"../src/lib.rs" 162 28 162 53] Ge0.ge _37 _38); + goto BB14 + } + BB14 { + _35 <- not _36; + switch (_35) + | False -> goto BB16 + | True -> goto BB15 + end + } + BB15 { + assume { Resolve0.resolve key_32 }; + assume { Resolve5.resolve value_33 }; + absurd + } + BB16 { + _34 <- (); + _44 <- key_32; + assume { Resolve0.resolve key_32 }; + _45 <- index_25; + _43 <- Vecmap_KeyRef_Type.C_KeyRef _44 _45; + _46 <- value_33; + assume { Resolve5.resolve value_33 }; + _42 <- (_43, _46); + _0 <- Core_Option_Option_Type.C_Some _42; + goto BB17 + } + BB17 { + goto BB18 + } + BB18 { + goto BB19 + } + BB19 { + assume { Resolve2.resolve min_key_inclusive_2 }; + return _0 + } + +end +module CreusotContracts_Model_Impl3_ShallowModel_Stub + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl3_ShallowModel_Interface + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy +end +module CreusotContracts_Model_Impl3_ShallowModel + type t + use prelude.Borrow + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + clone CreusotContracts_Model_ShallowModel_ShallowModel_Stub as ShallowModel0 with + type self = t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + function shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy = + ShallowModel0.shallow_model ( * self) + val shallow_model (self : borrowed t) : ShallowModelTy0.shallowModelTy + ensures { result = shallow_model self } + +end +module Alloc_Vec_Impl1_Insert_Interface + type t + type a + use prelude.Borrow + use seq.Seq + use mach.int.Int + use mach.int.UInt64 + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + val insert [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) (element : t) : () + ensures { Seq.length (ShallowModel0.shallow_model ( ^ self)) = Seq.length (ShallowModel1.shallow_model self) + 1 } + ensures { forall i : int . 0 <= i /\ i < UInt64.to_int index -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) i } + ensures { Seq.get (ShallowModel0.shallow_model ( ^ self)) (UInt64.to_int index) = element } + ensures { forall i : int . UInt64.to_int index < i /\ i < Seq.length (ShallowModel0.shallow_model ( ^ self)) -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) (i - 1) } + +end +module Alloc_Vec_Impl1_Insert + type t + type a + use prelude.Borrow + use seq.Seq + use mach.int.Int + use mach.int.UInt64 + use prelude.UIntSize + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Num_Impl12_Max_Stub as Max0 + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel0 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + val insert [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) (element : t) : () + ensures { Seq.length (ShallowModel0.shallow_model ( ^ self)) = Seq.length (ShallowModel1.shallow_model self) + 1 } + ensures { forall i : int . 0 <= i /\ i < UInt64.to_int index -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) i } + ensures { Seq.get (ShallowModel0.shallow_model ( ^ self)) (UInt64.to_int index) = element } + ensures { forall i : int . UInt64.to_int index < i /\ i < Seq.length (ShallowModel0.shallow_model ( ^ self)) -> Seq.get (ShallowModel0.shallow_model ( ^ self)) i = Seq.get (ShallowModel1.shallow_model self) (i - 1) } + +end +module Vecmap_Impl1_InsertInternal_Interface + type k + type v + use mach.int.UInt64 + use prelude.Borrow + use seq.Seq + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + val insert_internal [@cfg:stackify] [#"../src/lib.rs" 383 4 383 63] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (idx : usize) (key : k) (value : v) : () + requires {[#"../src/lib.rs" 364 15 364 38] UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))} + ensures { [#"../src/lib.rs" 365 14 365 55] Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) + 1 } + ensures { [#"../src/lib.rs" 366 4 366 85] forall i : int . 0 <= i /\ i < UInt64.to_int idx -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i } + ensures { [#"../src/lib.rs" 367 14 367 48] Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) (UInt64.to_int idx) = (key, value) } + ensures { [#"../src/lib.rs" 368 4 368 105] forall i : int . UInt64.to_int idx < i /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i - 1) } + ensures { [#"../src/lib.rs" 369 4 369 80] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) = 0 -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 370 4 374 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx > 0 /\ UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 375 4 378 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = 0 /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 379 4 382 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + +end +module Vecmap_Impl1_InsertInternal + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone Alloc_Vec_Impl1_Insert_Interface as Insert0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function ShallowModel1.shallow_model = ShallowModel1.shallow_model, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg insert_internal [@cfg:stackify] [#"../src/lib.rs" 383 4 383 63] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (idx : usize) (key : k) (value : v) : () + requires {[#"../src/lib.rs" 364 15 364 38] UInt64.to_int idx <= Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))} + ensures { [#"../src/lib.rs" 365 14 365 55] Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) + 1 } + ensures { [#"../src/lib.rs" 366 4 366 85] forall i : int . 0 <= i /\ i < UInt64.to_int idx -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i } + ensures { [#"../src/lib.rs" 367 14 367 48] Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) (UInt64.to_int idx) = (key, value) } + ensures { [#"../src/lib.rs" 368 4 368 105] forall i : int . UInt64.to_int idx < i /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i - 1) } + ensures { [#"../src/lib.rs" 369 4 369 80] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) = 0 -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 370 4 374 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx > 0 /\ UInt64.to_int idx < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 375 4 378 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = 0 /\ GtLog0.gt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 379 4 382 6] IsSorted0.is_sorted ( * self) /\ Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) > 0 /\ UInt64.to_int idx = Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) /\ LtLog0.lt_log (DeepModel0.deep_model (let (a, _) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (UInt64.to_int idx - 1) in a)) (DeepModel0.deep_model key) -> IsSorted0.is_sorted ( ^ self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var idx_2 : usize; + var key_3 : k; + var value_4 : v; + var _14 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _15 : usize; + var _16 : (k, v); + var _17 : k; + var _18 : v; + { + self_1 <- self; + idx_2 <- idx; + key_3 <- key; + value_4 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + goto BB4 + } + BB4 { + _14 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let Vecmap_VecMap_Type.C_VecMap a = * self_1 in Vecmap_VecMap_Type.C_VecMap ( ^ _14)) }; + _15 <- idx_2; + assume { Resolve0.resolve _17 }; + _17 <- key_3; + key_3 <- any k; + assume { Resolve1.resolve _18 }; + _18 <- value_4; + value_4 <- any v; + _16 <- (_17, _18); + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + _0 <- ([#"../src/lib.rs" 384 8 384 40] Insert0.insert _14 _15 _16); + goto BB7 + } + BB7 { + assume { Resolve2.resolve self_1 }; + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + return _0 + } + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Stub + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Interface + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + +end +module CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere + type self + type t + clone CreusotContracts_Model_ShallowModel_ShallowModelTy_Type as ShallowModelTy0 with + type self = t + predicate resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) + + val resolve_elswhere (self : self) (old' : ShallowModelTy0.shallowModelTy) (fin : ShallowModelTy0.shallowModelTy) : bool + ensures { result = resolve_elswhere self old' fin } + +end +module Alloc_Vec_Impl17_IndexMut_Interface + type t + type i + type a + use prelude.Borrow + use seq.Seq + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Stub as ResolveElswhere0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Stub as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Stub as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index_mut [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : i) : borrowed Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) ( * result) } + ensures { HasValue0.has_value index (ShallowModel1.shallow_model ( ^ self)) ( ^ result) } + ensures { ResolveElswhere0.resolve_elswhere index (ShallowModel0.shallow_model self) (ShallowModel1.shallow_model ( ^ self)) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) } + +end +module Alloc_Vec_Impl17_IndexMut + type t + type i + type a + use prelude.Borrow + use seq.Seq + use prelude.Slice + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = t + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + clone Core_Slice_Index_SliceIndex_Output_Type as Output0 with + type self = i, + type t = seq t + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Slice_SliceIndex_ResolveElswhere_Interface as ResolveElswhere0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Std1_Slice_SliceIndex_HasValue_Interface as HasValue0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + type Output0.output = Output0.output + clone CreusotContracts_Std1_Slice_SliceIndex_InBounds_Interface as InBounds0 with + type self = i, + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val index_mut [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : i) : borrowed Output0.output + requires {InBounds0.in_bounds index (ShallowModel0.shallow_model self)} + ensures { HasValue0.has_value index (ShallowModel0.shallow_model self) ( * result) } + ensures { HasValue0.has_value index (ShallowModel1.shallow_model ( ^ self)) ( ^ result) } + ensures { ResolveElswhere0.resolve_elswhere index (ShallowModel0.shallow_model self) (ShallowModel1.shallow_model ( ^ self)) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) } + +end +module Core_Mem_Replace_Interface + type t + use prelude.Borrow + val replace [@cfg:stackify] (dest : borrowed t) (src : t) : t + ensures { ^ dest = src } + ensures { result = * dest } + +end +module Core_Mem_Replace + type t + use prelude.Borrow + val replace [@cfg:stackify] (dest : borrowed t) (src : t) : t + ensures { ^ dest = src } + ensures { result = * dest } + +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere_Stub + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere_Interface + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) +end +module CreusotContracts_Std1_Slice_Impl5_ResolveElswhere + type t + use mach.int.Int + use prelude.UIntSize + use seq.Seq + use mach.int.UInt64 + predicate resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) = + forall i : int . 0 <= i /\ i <> UInt64.to_int self /\ i < Seq.length old' -> Seq.get old' i = Seq.get fin i + val resolve_elswhere [@inline:trivial] (self : usize) (old' : Seq.seq t) (fin : Seq.seq t) : bool + ensures { result = resolve_elswhere self old' fin } + +end +module Vecmap_Impl1_Insert_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val insert [@cfg:stackify] [#"../src/lib.rs" 179 4 179 59] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) (value : v) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 176 4 176 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 176 4 176 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 177 4 178 86] exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (KeySeq0.key_seq ( ^ self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i in a) = value } + +end +module Vecmap_Impl1_Insert + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve5 with + type t = v + clone Core_Mem_Replace_Interface as Replace0 with + type t = v + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve4 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_InsertInternal_Interface as InsertInternal0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_VecMap_Type.t_vecmap k v + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg insert [@cfg:stackify] [#"../src/lib.rs" 179 4 179 59] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) (value : v) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 176 4 176 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 176 4 176 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 177 4 178 86] exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) -> Seq.get (KeySeq0.key_seq ( ^ self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self))) i in a) = value } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_2 : k; + var value_3 : v; + var _7 : Core_Result_Result_Type.t_result usize usize; + var _8 : Vecmap_VecMap_Type.t_vecmap k v; + var _9 : k; + var _10 : k; + var _11 : isize; + var index_12 : usize; + var _13 : v; + var _14 : borrowed v; + var _15 : borrowed v; + var _16 : borrowed (k, v); + var _17 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _18 : usize; + var _19 : v; + var index_20 : usize; + var _21 : (); + var _22 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _23 : usize; + var _24 : k; + var _25 : v; + { + self_1 <- self; + key_2 <- key; + value_3 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + _8 <- * self_1; + _10 <- key_2; + _9 <- _10; + assume { Resolve0.resolve _10 }; + _7 <- ([#"../src/lib.rs" 180 14 180 31] FindK0.find_k _8 _9); + goto BB2 + } + BB2 { + switch (_7) + | Core_Result_Result_Type.C_Ok _ -> goto BB5 + | Core_Result_Result_Type.C_Err _ -> goto BB3 + end + } + BB3 { + index_20 <- Core_Result_Result_Type.err_0 _7; + _22 <- borrow_mut ( * self_1); + self_1 <- { self_1 with current = ( ^ _22) }; + _23 <- index_20; + assume { Resolve2.resolve _24 }; + _24 <- key_2; + key_2 <- any k; + assume { Resolve3.resolve _25 }; + _25 <- value_3; + value_3 <- any v; + _21 <- ([#"../src/lib.rs" 183 16 183 55] InsertInternal0.insert_internal _22 _23 _24 _25); + goto BB9 + } + BB4 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve key_2 }; + assume { Resolve3.resolve value_3 }; + absurd + } + BB5 { + index_12 <- Core_Result_Result_Type.ok_0 _7; + _17 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let Vecmap_VecMap_Type.C_VecMap a = * self_1 in Vecmap_VecMap_Type.C_VecMap ( ^ _17)) }; + assume { Resolve1.resolve self_1 }; + _18 <- index_12; + _16 <- ([#"../src/lib.rs" 181 53 181 66] IndexMut0.index_mut _17 _18); + goto BB6 + } + BB6 { + _15 <- borrow_mut (let (_, a) = * _16 in a); + _16 <- { _16 with current = (let (a, b) = * _16 in (a, ^ _15)) }; + assume { Resolve4.resolve _16 }; + _14 <- borrow_mut ( * _15); + _15 <- { _15 with current = ( ^ _14) }; + assume { Resolve3.resolve _19 }; + _19 <- value_3; + value_3 <- any v; + _13 <- ([#"../src/lib.rs" 181 30 181 76] Replace0.replace _14 _19); + goto BB7 + } + BB7 { + assume { Resolve5.resolve _15 }; + _0 <- Core_Option_Option_Type.C_Some _13; + goto BB8 + } + BB8 { + goto BB10 + } + BB9 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB10 + } + BB10 { + goto BB11 + } + BB11 { + goto BB12 + } + BB12 { + return _0 + } + +end +module Alloc_Vec_Impl1_Remove_Interface + type t + type a + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + use seq_ext.SeqExt + use prelude.UIntSize + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel_Stub as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val remove [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) : t + requires {UInt64.to_int index < Seq.length (ShallowModel0.shallow_model self)} + ensures { result = Seq.get (ShallowModel0.shallow_model self) (UInt64.to_int index) } + ensures { ShallowModel1.shallow_model ( ^ self) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model self) 0 (UInt64.to_int index)) (SeqExt.subsequence (ShallowModel0.shallow_model self) (UInt64.to_int index + 1) (Seq.length (ShallowModel0.shallow_model self))) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) - 1 } + +end +module Alloc_Vec_Impl1_Remove + type t + type a + use mach.int.UInt64 + use seq.Seq + use mach.int.Int + use prelude.Borrow + use seq_ext.SeqExt + use prelude.UIntSize + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t, + type a = a + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Interface as ShallowModel1 with + type t = t, + type a = a, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel_Interface as ShallowModel0 with + type t = Alloc_Vec_Vec_Type.t_vec t a, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + val remove [@cfg:stackify] (self : borrowed (Alloc_Vec_Vec_Type.t_vec t a)) (index : usize) : t + requires {UInt64.to_int index < Seq.length (ShallowModel0.shallow_model self)} + ensures { result = Seq.get (ShallowModel0.shallow_model self) (UInt64.to_int index) } + ensures { ShallowModel1.shallow_model ( ^ self) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model self) 0 (UInt64.to_int index)) (SeqExt.subsequence (ShallowModel0.shallow_model self) (UInt64.to_int index + 1) (Seq.length (ShallowModel0.shallow_model self))) } + ensures { Seq.length (ShallowModel1.shallow_model ( ^ self)) = Seq.length (ShallowModel0.shallow_model self) - 1 } + +end +module CreusotContracts_Resolve_Impl0_Resolve_Stub + type t1 + type t2 + predicate resolve (self : (t1, t2)) +end +module CreusotContracts_Resolve_Impl0_Resolve_Interface + type t1 + type t2 + predicate resolve (self : (t1, t2)) +end +module CreusotContracts_Resolve_Impl0_Resolve + type t1 + type t2 + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve1 with + type self = t2 + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve0 with + type self = t1 + predicate resolve (self : (t1, t2)) = + Resolve0.resolve (let (a, _) = self in a) /\ Resolve1.resolve (let (_, a) = self in a) + val resolve (self : (t1, t2)) : bool + ensures { result = resolve self } + +end +module Vecmap_Impl1_Remove_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + use seq_ext.SeqExt + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val remove [@cfg:stackify] [#"../src/lib.rs" 199 4 199 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 189 4 189 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 189 4 189 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 190 4 192 30] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq ( * self)) (DeepModel0.deep_model key) /\ * self = ^ self } + ensures { [#"../src/lib.rs" 193 4 198 17] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) -> Seq.get (KeySeq0.key_seq ( * self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i in a) = v /\ ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self)) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) 0 i) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i + 1) (Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))))) } + +end +module Vecmap_Impl1_Remove + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + use seq_ext.SeqExt + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = v + clone CreusotContracts_Resolve_Impl0_Resolve as Resolve3 with + type t1 = k, + type t2 = v, + predicate Resolve0.resolve = Resolve4.resolve, + predicate Resolve1.resolve = Resolve2.resolve + clone Alloc_Vec_Impl1_Remove_Interface as Remove0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg remove [@cfg:stackify] [#"../src/lib.rs" 199 4 199 50] (self : borrowed (Vecmap_VecMap_Type.t_vecmap k v)) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 189 4 189 40] IsSorted0.is_sorted ( * self)} + ensures { [#"../src/lib.rs" 189 4 189 40] IsSorted0.is_sorted ( ^ self) } + ensures { [#"../src/lib.rs" 190 4 192 30] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq ( * self)) (DeepModel0.deep_model key) /\ * self = ^ self } + ensures { [#"../src/lib.rs" 193 4 198 17] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) -> Seq.get (KeySeq0.key_seq ( * self)) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) i in a) = v /\ ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( ^ self)) = Seq.(++) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) 0 i) (SeqExt.subsequence (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self))) (i + 1) (Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * self)))))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var key_2 : k; + var _7 : Core_Result_Result_Type.t_result usize usize; + var _8 : Vecmap_VecMap_Type.t_vecmap k v; + var _9 : k; + var _10 : isize; + var index_11 : usize; + var _12 : v; + var _13 : (k, v); + var _14 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _15 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _8 <- * self_1; + _9 <- key_2; + assume { Resolve0.resolve key_2 }; + _7 <- ([#"../src/lib.rs" 200 14 200 30] FindK0.find_k _8 _9); + goto BB1 + } + BB1 { + switch (_7) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB8 + } + BB3 { + assume { Resolve1.resolve self_1 }; + absurd + } + BB4 { + index_11 <- Core_Result_Result_Type.ok_0 _7; + _14 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * self_1)); + self_1 <- { self_1 with current = (let Vecmap_VecMap_Type.C_VecMap a = * self_1 in Vecmap_VecMap_Type.C_VecMap ( ^ _14)) }; + _15 <- index_11; + _13 <- ([#"../src/lib.rs" 201 30 201 50] Remove0.remove _14 _15); + goto BB5 + } + BB5 { + assume { Resolve1.resolve self_1 }; + assume { Resolve2.resolve _12 }; + _12 <- (let (_, a) = _13 in a); + _13 <- (let (a, b) = _13 in (a, any v)); + _0 <- Core_Option_Option_Type.C_Some _12; + goto BB6 + } + BB6 { + goto BB7 + } + BB7 { + assume { Resolve3.resolve _13 }; + goto BB8 + } + BB8 { + return _0 + } + +end +module Vecmap_Impl1_Get_Interface + type k + type v + use prelude.Borrow + use mach.int.Int + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val get [@cfg:stackify] [#"../src/lib.rs" 211 4 211 44] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 206 15 206 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 207 4 207 77] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 208 4 210 77] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = v) } + +end +module Vecmap_Impl1_Get + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.IntSize + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + let rec cfg get [@cfg:stackify] [#"../src/lib.rs" 211 4 211 44] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : Core_Option_Option_Type.t_option v + requires {[#"../src/lib.rs" 206 15 206 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 207 4 207 77] result = Core_Option_Option_Type.C_None -> not Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + ensures { [#"../src/lib.rs" 208 4 210 77] forall v : v . result = Core_Option_Option_Type.C_Some v -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model key /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = v) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option v; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : k; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : Vecmap_VecMap_Type.t_vecmap k v; + var _8 : k; + var _9 : isize; + var index_10 : usize; + var _11 : v; + var _12 : v; + var _13 : (k, v); + var _14 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _15 : usize; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- self_1; + _8 <- key_2; + assume { Resolve0.resolve key_2 }; + _6 <- ([#"../src/lib.rs" 212 14 212 30] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + switch (_6) + | Core_Result_Result_Type.C_Ok _ -> goto BB4 + | Core_Result_Result_Type.C_Err _ -> goto BB2 + end + } + BB2 { + assume { Resolve1.resolve self_1 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB3 { + assume { Resolve1.resolve self_1 }; + absurd + } + BB4 { + index_10 <- Core_Result_Result_Type.ok_0 _6; + _14 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve1.resolve self_1 }; + _15 <- index_10; + _13 <- ([#"../src/lib.rs" 213 31 213 44] Index0.index _14 _15); + goto BB5 + } + BB5 { + _12 <- (let (_, a) = _13 in a); + assume { Resolve2.resolve _13 }; + _11 <- _12; + assume { Resolve3.resolve _12 }; + _0 <- Core_Option_Option_Type.C_Some _11; + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Result_Impl0_IsOk_Interface + type t + type e + use prelude.Borrow + use Core_Result_Result_Type as Core_Result_Result_Type + val is_ok [@cfg:stackify] (self : Core_Result_Result_Type.t_result t e) : bool + ensures { result = (exists t : t . self = Core_Result_Result_Type.C_Ok t) } + +end +module Core_Result_Impl0_IsOk + type t + type e + use prelude.Borrow + use Core_Result_Result_Type as Core_Result_Result_Type + val is_ok [@cfg:stackify] (self : Core_Result_Result_Type.t_result t e) : bool + ensures { result = (exists t : t . self = Core_Result_Result_Type.C_Ok t) } + +end +module Vecmap_Impl1_ContainsKey_Interface + type k + type v + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains_Stub as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val contains_key [@cfg:stackify] [#"../src/lib.rs" 220 4 220 47] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : bool + requires {[#"../src/lib.rs" 218 15 218 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 219 14 219 65] result = Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + +end +module Vecmap_Impl1_ContainsKey + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Result_Result_Type as Core_Result_Result_Type + clone Core_Result_Impl0_IsOk_Interface as IsOk0 with + type t = usize, + type e = usize + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Logic_Seq_Impl0_Contains as Contains0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_FindK_Interface as FindK0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate Contains0.contains = Contains0.contains, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + function DeepModel1.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX' + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + let rec cfg contains_key [@cfg:stackify] [#"../src/lib.rs" 220 4 220 47] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : k) : bool + requires {[#"../src/lib.rs" 218 15 218 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 219 14 219 65] result = Contains0.contains (KeySeq0.key_seq self) (DeepModel0.deep_model key) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : bool; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : k; + var _5 : Core_Result_Result_Type.t_result usize usize; + var _6 : Core_Result_Result_Type.t_result usize usize; + var _7 : Vecmap_VecMap_Type.t_vecmap k v; + var _8 : k; + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _7 <- self_1; + assume { Resolve0.resolve self_1 }; + _8 <- key_2; + assume { Resolve1.resolve key_2 }; + _6 <- ([#"../src/lib.rs" 221 8 221 24] FindK0.find_k _7 _8); + goto BB1 + } + BB1 { + _5 <- _6; + _0 <- ([#"../src/lib.rs" 221 8 221 32] IsOk0.is_ok _5); + goto BB2 + } + BB2 { + return _0 + } + +end +module Core_Cmp_PartialOrd_Gt_Interface + type self + type rhs + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel1 with + type t = rhs, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val gt [@cfg:stackify] (self : self) (other : rhs) : bool + ensures { result = GtLog0.gt_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Core_Cmp_PartialOrd_Gt + type self + type rhs + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = self + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel1 with + type t = rhs, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Interface as DeepModel0 with + type t = self, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + val gt [@cfg:stackify] (self : self) (other : rhs) : bool + ensures { result = GtLog0.gt_log (DeepModel0.deep_model self) (DeepModel1.deep_model other) } + +end +module Vecmap_Impl1_NextMapping_Interface + type k + type v + use mach.int.Int + use seq.Seq + use prelude.Borrow + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val next_mapping [@cfg:stackify] [#"../src/lib.rs" 238 4 238 75] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 226 15 226 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 227 4 229 57] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + ensures { [#"../src/lib.rs" 230 4 237 57] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)) /\ GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)) /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = (let (_, a) = entry in a) /\ (forall j : int . j >= 0 /\ j < i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a))) /\ LeLog0.le_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)))) } + +end +module Vecmap_Impl1_NextMapping + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use prelude.Ghost + use seq.Seq + use prelude.IntSize + use mach.int.UInt64 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Logic_Seq_Impl0_Get as Get0 with + type t = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + clone CreusotContracts_Logic_Int_Impl18_DeepModel as DeepModel4 + use Core_Ops_Range_Range_Type as Core_Ops_Range_Range_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Completed as Completed0 with + type idx = usize, + predicate Resolve0.resolve = Resolve1.resolve, + function DeepModel0.deep_model = DeepModel4.deep_model + clone Core_Iter_Range_Impl3_Item_Type as Item0 with + type a = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_Produces as Produces0 with + type idx = usize, + function DeepModel0.deep_model = DeepModel4.deep_model + clone CreusotContracts_Std1_Ops_Impl3_Invariant as Invariant0 with + type idx = usize + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesTrans as ProducesTrans0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone CreusotContracts_Std1_Iter_Range_Impl0_ProducesRefl as ProducesRefl0 with + type idx = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + predicate Produces0.produces = Produces0.produces, + axiom . + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Type as IntoIter1 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPost as IntoIterPost0 with + type i = Core_Ops_Range_Range_Type.t_range usize + clone CreusotContracts_Std1_Iter_Impl0_IntoIterPre as IntoIterPre0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate Invariant0.invariant' = Invariant0.invariant' + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl0_DeepModelTy_Type as DeepModelTy1 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl10_DeepModel as DeepModel3 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl10_DeepModel as DeepModel2 with + type k = k, + type DeepModelTy0.deepModelTy = DeepModelTy1.deepModelTy, + function DeepModel0.deep_model = DeepModel0.deep_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_IsValidKeyrefLg as IsValidKeyrefLg0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function KeySeq0.key_seq = KeySeq0.key_seq, + function Get0.get = Get0.get, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl13_ToOwned as ToOwned0 with + type k = k, + function DeepModel0.deep_model = DeepModel2.deep_model, + function DeepModel1.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve6 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve5 with + type self = k + clone Core_Cmp_PartialOrd_Gt_Interface as Gt0 with + type self = k, + type rhs = k, + function DeepModel0.deep_model = DeepModel0.deep_model, + function DeepModel1.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = (k, v) + clone Alloc_Vec_Impl16_Index_Interface as Index0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + type Output0.output = Output0.output + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone Core_Iter_Range_Impl3_Next_Interface as Next0 with + type a = usize, + predicate Invariant0.invariant' = Invariant0.invariant', + type Item0.item = Item0.item, + predicate Completed0.completed = Completed0.completed, + predicate Produces0.produces = Produces0.produces + clone Core_Iter_Traits_Collect_Impl0_IntoIter_Interface as IntoIter0 with + type i = Core_Ops_Range_Range_Type.t_range usize, + predicate IntoIterPre0.into_iter_pre = IntoIterPre0.into_iter_pre, + predicate IntoIterPost0.into_iter_post = IntoIterPost0.into_iter_post, + predicate Invariant0.invariant' = Invariant0.invariant' + clone Alloc_Vec_Impl1_Len_Interface as Len0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone Vecmap_Impl1_IsValidKeyref_Interface as IsValidKeyref0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ToOwned0.to_owned = ToOwned0.to_owned, + predicate IsValidKeyrefLg0.is_valid_keyref_lg = IsValidKeyrefLg0.is_valid_keyref_lg, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate LeLog0.le_log = LeLog0.le_log, + function DeepModel1.deep_model = DeepModel2.deep_model, + function DeepModel2.deep_model = DeepModel3.deep_model, + type DeepModelTy1.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + function DeepModel3.deep_model = DeepModel1.deep_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + let rec cfg next_mapping [@cfg:stackify] [#"../src/lib.rs" 238 4 238 75] (self : Vecmap_VecMap_Type.t_vecmap k v) (key : Vecmap_KeyRef_Type.t_keyref k) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 226 15 226 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 227 4 229 57] result = Core_Option_Option_Type.C_None -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key))) } + ensures { [#"../src/lib.rs" 230 4 237 57] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (exists i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> Seq.get (KeySeq0.key_seq self) i = DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)) /\ GtLog0.gt_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)) /\ (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) i in a) = (let (_, a) = entry in a) /\ (forall j : int . j >= 0 /\ j < i -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a))) /\ LeLog0.le_log (Seq.get (KeySeq0.key_seq self) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key)))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v); + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var key_2 : Vecmap_KeyRef_Type.t_keyref k; + var from_6 : usize; + var _7 : bool; + var _8 : Vecmap_VecMap_Type.t_vecmap k v; + var _9 : Vecmap_KeyRef_Type.t_keyref k; + var _10 : Vecmap_KeyRef_Type.t_keyref k; + var _11 : (); + var iter_12 : Core_Ops_Range_Range_Type.t_range usize; + var _13 : Core_Ops_Range_Range_Type.t_range usize; + var _14 : usize; + var _15 : usize; + var _16 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var iter_old_17 : Ghost.ghost_ty (Core_Ops_Range_Range_Type.t_range usize); + var _19 : (); + var produced_20 : Ghost.ghost_ty (Seq.seq usize); + var _23 : (); + var _27 : (); + var _28 : Core_Option_Option_Type.t_option usize; + var _29 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _30 : borrowed (Core_Ops_Range_Range_Type.t_range usize); + var _31 : isize; + var i_32 : usize; + var _33 : Ghost.ghost_ty (Seq.seq usize); + var _35 : (); + var idx_36 : usize; + var _37 : bool; + var _38 : k; + var _39 : (k, v); + var _40 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _41 : usize; + var _42 : k; + var _43 : (); + var key_44 : k; + var value_45 : v; + var _46 : (k, v); + var _47 : (k, v); + var _48 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _49 : usize; + var _50 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _51 : Vecmap_KeyRef_Type.t_keyref k; + var _52 : usize; + var _53 : k; + var _54 : v; + var _55 : (); + { + self_1 <- self; + key_2 <- key; + goto BB0 + } + BB0 { + _8 <- self_1; + _10 <- key_2; + _9 <- _10; + assume { Resolve0.resolve _10 }; + _7 <- ([#"../src/lib.rs" 239 22 239 48] IsValidKeyref0.is_valid_keyref _8 _9); + goto BB1 + } + BB1 { + switch (_7) + | False -> goto BB3 + | True -> goto BB2 + end + } + BB2 { + from_6 <- Vecmap_KeyRef_Type.keyref_min_idx key_2; + goto BB4 + } + BB3 { + from_6 <- ([#"../src/lib.rs" 242 12 242 13] (0 : usize)); + goto BB4 + } + BB4 { + _14 <- from_6; + _16 <- Vecmap_VecMap_Type.vecmap_v self_1; + _15 <- ([#"../src/lib.rs" 248 25 248 37] Len0.len _16); + goto BB5 + } + BB5 { + _13 <- Core_Ops_Range_Range_Type.C_Range _14 _15; + iter_12 <- ([#"../src/lib.rs" 246 8 247 63] IntoIter0.into_iter _13); + goto BB6 + } + BB6 { + _19 <- (); + iter_old_17 <- ([#"../src/lib.rs" 246 8 247 63] Ghost.new iter_12); + goto BB7 + } + BB7 { + _23 <- (); + produced_20 <- ([#"../src/lib.rs" 246 8 247 63] Ghost.new (Seq.empty )); + goto BB8 + } + BB8 { + goto BB9 + } + BB9 { + invariant type_invariant { [#"../src/lib.rs" 246 8 247 63] Invariant0.invariant' iter_12 }; + invariant structural { [#"../src/lib.rs" 246 8 247 63] Produces0.produces (Ghost.inner iter_old_17) (Ghost.inner produced_20) iter_12 }; + invariant prev_leq { [#"../src/lib.rs" 246 8 247 63] forall j : int . j >= 0 /\ j < Seq.length (Ghost.inner produced_20) + UInt64.to_int from_6 -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self_1) j) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key key_2)) }; + _30 <- borrow_mut iter_12; + iter_12 <- ^ _30; + _29 <- borrow_mut ( * _30); + _30 <- { _30 with current = ( ^ _29) }; + _28 <- ([#"../src/lib.rs" 246 8 247 63] Next0.next _29); + goto BB10 + } + BB10 { + assume { Resolve1.resolve _30 }; + switch (_28) + | Core_Option_Option_Type.C_None -> goto BB11 + | Core_Option_Option_Type.C_Some _ -> goto BB13 + end + } + BB11 { + assume { Resolve2.resolve self_1 }; + assume { Resolve3.resolve key_2 }; + _11 <- (); + _0 <- Core_Option_Option_Type.C_None; + goto BB20 + } + BB12 { + assume { Resolve2.resolve self_1 }; + assume { Resolve3.resolve key_2 }; + absurd + } + BB13 { + i_32 <- Core_Option_Option_Type.some_0 _28; + _35 <- (); + _33 <- ([#"../src/lib.rs" 246 8 247 63] Ghost.new (Seq.(++) (Ghost.inner produced_20) (Seq.singleton i_32))); + goto BB14 + } + BB14 { + produced_20 <- _33; + _33 <- any Ghost.ghost_ty (Seq.seq usize); + idx_36 <- i_32; + _40 <- Vecmap_VecMap_Type.vecmap_v self_1; + _41 <- idx_36; + _39 <- ([#"../src/lib.rs" 249 15 249 26] Index0.index _40 _41); + goto BB15 + } + BB15 { + _38 <- (let (a, _) = _39 in a); + assume { Resolve4.resolve _39 }; + _42 <- Vecmap_KeyRef_Type.keyref_key key_2; + _37 <- ([#"../src/lib.rs" 249 15 249 39] Gt0.gt _38 _42); + goto BB16 + } + BB16 { + switch (_37) + | False -> goto BB19 + | True -> goto BB17 + end + } + BB17 { + assume { Resolve3.resolve key_2 }; + _48 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve2.resolve self_1 }; + _49 <- idx_36; + _47 <- ([#"../src/lib.rs" 250 36 250 47] Index0.index _48 _49); + goto BB18 + } + BB18 { + _46 <- _47; + assume { Resolve4.resolve _47 }; + key_44 <- (let (a, _) = _46 in a); + value_45 <- (let (_, a) = _46 in a); + assume { Resolve4.resolve _46 }; + _52 <- idx_36; + _53 <- key_44; + assume { Resolve5.resolve key_44 }; + _51 <- Vecmap_KeyRef_Type.C_KeyRef _53 _52; + _54 <- value_45; + assume { Resolve6.resolve value_45 }; + _50 <- (_51, _54); + _0 <- Core_Option_Option_Type.C_Some _50; + goto BB20 + } + BB19 { + _27 <- (); + goto BB9 + } + BB20 { + return _0 + } + +end +module Core_Slice_Impl0_First_Interface + type t + use seq.Seq + use prelude.Borrow + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val first [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) 0 = x } + +end +module Core_Slice_Impl0_First + type t + use seq.Seq + use prelude.Borrow + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val first [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) 0 = x } + +end +module Vecmap_Impl1_MinEntry_Interface + type k + type v + use seq.Seq + use prelude.Borrow + use mach.int.UInt64 + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Stub as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val min_entry [@cfg:stackify] [#"../src/lib.rs" 294 4 294 55] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 287 15 287 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 288 4 288 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 289 4 289 101] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) 0 = (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a), let (_, a) = entry in a) } + ensures { [#"../src/lib.rs" 290 4 290 80] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = entry in a)) = 0 } + ensures { [#"../src/lib.rs" 291 4 293 6] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)))) } + +end +module Vecmap_Impl1_MinEntry + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.IntSize + use mach.int.UInt64 + use prelude.UIntSize + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = k + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_First_Interface as First0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg min_entry [@cfg:stackify] [#"../src/lib.rs" 294 4 294 55] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v) + requires {[#"../src/lib.rs" 287 15 287 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 288 4 288 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 289 4 289 101] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) 0 = (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a), let (_, a) = entry in a) } + ensures { [#"../src/lib.rs" 290 4 290 80] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> UInt64.to_int (Vecmap_KeyRef_Type.keyref_min_idx (let (a, _) = entry in a)) = 0 } + ensures { [#"../src/lib.rs" 291 4 293 6] forall entry : (Vecmap_KeyRef_Type.t_keyref k, v) . result = Core_Option_Option_Type.C_Some entry -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> GeLog0.ge_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model (Vecmap_KeyRef_Type.keyref_key (let (a, _) = entry in a)))) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option (Vecmap_KeyRef_Type.t_keyref k, v); + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var _7 : Core_Option_Option_Type.t_option (k, v); + var _8 : seq (k, v); + var _9 : seq (k, v); + var _10 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _11 : isize; + var key_12 : k; + var value_13 : v; + var _14 : (Vecmap_KeyRef_Type.t_keyref k, v); + var _15 : Vecmap_KeyRef_Type.t_keyref k; + var _16 : k; + var _17 : v; + { + self_1 <- self; + goto BB0 + } + BB0 { + _10 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _9 <- ([#"../src/lib.rs" 295 14 295 28] Deref0.deref _10); + goto BB1 + } + BB1 { + _8 <- _9; + assume { Resolve1.resolve _9 }; + _7 <- ([#"../src/lib.rs" 295 14 295 28] First0.first _8); + goto BB2 + } + BB2 { + switch (_7) + | Core_Option_Option_Type.C_None -> goto BB3 + | Core_Option_Option_Type.C_Some _ -> goto BB5 + end + } + BB3 { + assume { Resolve2.resolve _7 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB4 { + assume { Resolve2.resolve _7 }; + absurd + } + BB5 { + key_12 <- (let (a, _) = Core_Option_Option_Type.some_0 _7 in a); + value_13 <- (let (_, a) = Core_Option_Option_Type.some_0 _7 in a); + assume { Resolve2.resolve _7 }; + _16 <- key_12; + assume { Resolve3.resolve key_12 }; + _15 <- Vecmap_KeyRef_Type.C_KeyRef _16 ([#"../src/lib.rs" 296 63 296 64] (0 : usize)); + _17 <- value_13; + assume { Resolve4.resolve value_13 }; + _14 <- (_15, _17); + _0 <- Core_Option_Option_Type.C_Some _14; + goto BB6 + } + BB6 { + return _0 + } + +end +module Core_Slice_Impl0_Last_Interface + type t + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Stub as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val last [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) (Seq.length (ShallowModel0.shallow_model self) - 1) = x } + +end +module Core_Slice_Impl0_Last + type t + use seq.Seq + use prelude.Borrow + use mach.int.Int + use prelude.Slice + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = t + clone CreusotContracts_Model_Impl1_ShallowModel_Interface as ShallowModel0 with + type t = seq t, + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy + use Core_Option_Option_Type as Core_Option_Option_Type + val last [@cfg:stackify] (self : seq t) : Core_Option_Option_Type.t_option t + ensures { result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model self) = 0 } + ensures { forall x : t . result = Core_Option_Option_Type.C_Some x -> Seq.get (ShallowModel0.shallow_model self) (Seq.length (ShallowModel0.shallow_model self) - 1) = x } + +end +module Vecmap_Impl1_MaxKey_Interface + type k + type v + use seq.Seq + use prelude.Borrow + use mach.int.Int + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Stub as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_Impl0_DeepModel_Stub as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Core_Option_Option_Type as Core_Option_Option_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + val max_key [@cfg:stackify] [#"../src/lib.rs" 307 4 307 39] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option k + requires {[#"../src/lib.rs" 301 15 301 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 302 4 302 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 303 4 306 6] forall k : k . result = Core_Option_Option_Type.C_Some k -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model k)) } + +end +module Vecmap_Impl1_MaxKey + type k + type v + use prelude.Borrow + use prelude.Slice + use seq.Seq + use mach.int.Int + use prelude.IntSize + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Slice_Impl0_ShallowModel as ShallowModel3 with + type t = (k, v), + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel2 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy1.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_Impl1_ShallowModel as ShallowModel1 with + type t = seq (k, v), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel3.shallow_model + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel1 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve4 with + type self = k + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve3 with + type self = (k, v) + use Core_Option_Option_Type as Core_Option_Option_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve2 with + type self = Core_Option_Option_Type.t_option (k, v) + clone Core_Slice_Impl0_Last_Interface as Last0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel1.shallow_model + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = seq (k, v) + clone Alloc_Vec_Impl10_Deref_Interface as Deref0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + function ShallowModel1.shallow_model = ShallowModel2.shallow_model + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Model_Impl0_DeepModel as DeepModel0 with + type t = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + function DeepModel0.deep_model = DeepModel1.deep_model + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel1.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg max_key [@cfg:stackify] [#"../src/lib.rs" 307 4 307 39] (self : Vecmap_VecMap_Type.t_vecmap k v) : Core_Option_Option_Type.t_option k + requires {[#"../src/lib.rs" 301 15 301 31] IsSorted0.is_sorted self} + ensures { [#"../src/lib.rs" 302 4 302 55] result = Core_Option_Option_Type.C_None -> Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 } + ensures { [#"../src/lib.rs" 303 4 306 6] forall k : k . result = Core_Option_Option_Type.C_Some k -> (forall i : int . i >= 0 /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) -> LeLog0.le_log (Seq.get (KeySeq0.key_seq self) i) (DeepModel0.deep_model k)) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Core_Option_Option_Type.t_option k; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var _5 : Core_Option_Option_Type.t_option (k, v); + var _6 : seq (k, v); + var _7 : seq (k, v); + var _8 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _9 : isize; + var e_10 : (k, v); + var _11 : k; + var _12 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _8 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _7 <- ([#"../src/lib.rs" 308 14 308 27] Deref0.deref _8); + goto BB1 + } + BB1 { + _6 <- _7; + assume { Resolve1.resolve _7 }; + _5 <- ([#"../src/lib.rs" 308 14 308 27] Last0.last _6); + goto BB2 + } + BB2 { + switch (_5) + | Core_Option_Option_Type.C_None -> goto BB3 + | Core_Option_Option_Type.C_Some _ -> goto BB5 + end + } + BB3 { + assume { Resolve2.resolve _5 }; + _0 <- Core_Option_Option_Type.C_None; + goto BB6 + } + BB4 { + assume { Resolve2.resolve _5 }; + absurd + } + BB5 { + assume { Resolve3.resolve e_10 }; + e_10 <- Core_Option_Option_Type.some_0 _5; + assume { Resolve2.resolve _5 }; + _12 <- (let (a, _) = e_10 in a); + assume { Resolve3.resolve e_10 }; + _11 <- _12; + assume { Resolve4.resolve _12 }; + _0 <- Core_Option_Option_Type.C_Some _11; + goto BB6 + } + BB6 { + return _0 + } + +end +module Alloc_Vec_Impl14_Clone_Interface + type t + type a + use prelude.Borrow + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + val clone' [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : Alloc_Vec_Vec_Type.t_vec t a + ensures { result = self } + +end +module Alloc_Vec_Impl14_Clone + type t + type a + use prelude.Borrow + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + val clone' [@cfg:stackify] (self : Alloc_Vec_Vec_Type.t_vec t a) : Alloc_Vec_Vec_Type.t_vec t a + ensures { result = self } + +end +module Vecmap_Impl2_Clone_Interface + type k + type v + use prelude.Borrow + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + val clone' [@cfg:stackify] [#"../src/lib.rs" 390 4 390 27] (self : Vecmap_VecMap_Type.t_vecmap k v) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 389 14 389 29] result = self } + +end +module Vecmap_Impl2_Clone + type k + type v + use prelude.Borrow + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Alloc_Vec_Impl14_Clone_Interface as Clone0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_VecMap_Type.t_vecmap k v + let rec cfg clone' [@cfg:stackify] [#"../src/lib.rs" 390 4 390 27] (self : Vecmap_VecMap_Type.t_vecmap k v) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 389 14 389 29] result = self } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_VecMap_Type.t_vecmap k v; + var self_1 : Vecmap_VecMap_Type.t_vecmap k v; + var _3 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + var _4 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + self_1 <- self; + goto BB0 + } + BB0 { + _4 <- Vecmap_VecMap_Type.vecmap_v self_1; + assume { Resolve0.resolve self_1 }; + _3 <- ([#"../src/lib.rs" 391 20 391 34] Clone0.clone' _4); + goto BB1 + } + BB1 { + _0 <- Vecmap_VecMap_Type.C_VecMap _3; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl4_IsDefault_Stub + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_default [#"../src/lib.rs" 414 4 414 31] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl4_IsDefault_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + predicate is_default [#"../src/lib.rs" 414 4 414 31] (self : Vecmap_VecMap_Type.t_vecmap k v) +end +module Vecmap_Impl4_IsDefault + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + predicate is_default [#"../src/lib.rs" 414 4 414 31] (self : Vecmap_VecMap_Type.t_vecmap k v) = + [#"../src/lib.rs" 415 20 415 40] Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v self)) = 0 + val is_default [#"../src/lib.rs" 414 4 414 31] (self : Vecmap_VecMap_Type.t_vecmap k v) : bool + ensures { result = is_default self } + +end +module Vecmap_Impl3_Default_Interface + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl4_IsDefault_Stub as IsDefault0 with + type k = k, + type v = v + val default [@cfg:stackify] [#"../src/lib.rs" 404 4 404 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 403 14 403 33] IsDefault0.is_default result } + +end +module Vecmap_Impl3_Default + type k + type v + clone Core_Num_Impl12_Max as Max0 + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Alloc_Vec_Impl0_New_Interface as New0 with + type t = (k, v), + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl4_IsDefault as IsDefault0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + let rec cfg default [@cfg:stackify] [#"../src/lib.rs" 404 4 404 24] (_1' : ()) : Vecmap_VecMap_Type.t_vecmap k v + ensures { [#"../src/lib.rs" 403 14 403 33] IsDefault0.is_default result } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_VecMap_Type.t_vecmap k v; + var _2 : Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global); + { + goto BB0 + } + BB0 { + _2 <- ([#"../src/lib.rs" 405 18 405 28] New0.new ()); + goto BB1 + } + BB1 { + _0 <- Vecmap_VecMap_Type.C_VecMap _2; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl5_Keyref_Interface + type k + type v + use prelude.Borrow + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use Vecmap_Entry_Type as Vecmap_Entry_Type + val keyref [@cfg:stackify] [#"../src/lib.rs" 460 4 460 38] (self : Vecmap_Entry_Type.t_entry k v) : Vecmap_KeyRef_Type.t_keyref k + requires {[#"../src/lib.rs" 456 15 459 5] match (self) with + | Vecmap_Entry_Type.C_Vacant (Vecmap_VacantEntry_Type.C_VacantEntry map _ _) -> IsSorted0.is_sorted ( * map) + | Vecmap_Entry_Type.C_Occupied (Vecmap_OccupiedEntry_Type.C_OccupiedEntry map _ _) -> IsSorted0.is_sorted ( * map) + end} + +end +module Vecmap_Impl5_Keyref + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.IntSize + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = k + use Vecmap_Entry_Type as Vecmap_Entry_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_Entry_Type.t_entry k v + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg keyref [@cfg:stackify] [#"../src/lib.rs" 460 4 460 38] (self : Vecmap_Entry_Type.t_entry k v) : Vecmap_KeyRef_Type.t_keyref k + requires {[#"../src/lib.rs" 456 15 459 5] match (self) with + | Vecmap_Entry_Type.C_Vacant (Vecmap_VacantEntry_Type.C_VacantEntry map _ _) -> IsSorted0.is_sorted ( * map) + | Vecmap_Entry_Type.C_Occupied (Vecmap_OccupiedEntry_Type.C_OccupiedEntry map _ _) -> IsSorted0.is_sorted ( * map) + end} + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_Entry_Type.t_entry k v; + var _3 : isize; + var key_4 : k; + var index_5 : usize; + var _6 : usize; + var _7 : k; + var key_8 : k; + var index_9 : usize; + var _10 : usize; + var _11 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + switch (self_1) + | Vecmap_Entry_Type.C_Vacant _ -> goto BB3 + | Vecmap_Entry_Type.C_Occupied _ -> goto BB1 + end + } + BB1 { + key_8 <- Vecmap_OccupiedEntry_Type.occupiedentry_key (Vecmap_Entry_Type.occupied_0 self_1); + index_9 <- Vecmap_OccupiedEntry_Type.occupiedentry_index (Vecmap_Entry_Type.occupied_0 self_1); + assume { Resolve0.resolve self_1 }; + _10 <- index_9; + _11 <- key_8; + assume { Resolve1.resolve key_8 }; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _11 _10; + goto BB4 + } + BB2 { + assume { Resolve0.resolve self_1 }; + absurd + } + BB3 { + key_4 <- Vecmap_VacantEntry_Type.vacantentry_key (Vecmap_Entry_Type.vacant_0 self_1); + index_5 <- Vecmap_VacantEntry_Type.vacantentry_index (Vecmap_Entry_Type.vacant_0 self_1); + assume { Resolve0.resolve self_1 }; + _6 <- index_5; + _7 <- key_4; + assume { Resolve1.resolve key_4 }; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _7 _6; + goto BB4 + } + BB4 { + return _0 + } + +end +module Vecmap_Impl15_Resolve_Stub + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate resolve [#"../src/lib.rs" 480 4 480 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl15_Resolve_Interface + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + predicate resolve [#"../src/lib.rs" 480 4 480 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) +end +module Vecmap_Impl15_Resolve + type k + type v + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Stub as Resolve1 with + type self = k + clone CreusotContracts_Resolve_Impl1_Resolve_Stub as Resolve0 with + type t = Vecmap_VecMap_Type.t_vecmap k v + predicate resolve [#"../src/lib.rs" 480 4 480 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) = + [#"../src/lib.rs" 479 4 479 16] Resolve0.resolve (Vecmap_VacantEntry_Type.vacantentry_map self) /\ Resolve1.resolve (Vecmap_VacantEntry_Type.vacantentry_key self) + val resolve [#"../src/lib.rs" 480 4 480 28] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) : bool + ensures { result = resolve self } + +end +module Vecmap_Impl7_Insert_Interface + type k + type v + use mach.int.Int + use mach.int.UInt64 + use prelude.Borrow + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_IsSorted_Stub as IsSorted0 with + type k = k, + type v = v + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Stub as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Stub as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Model_DeepModel_DeepModel_Stub as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl0_KeySeq_Stub as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl6_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val insert [@cfg:stackify] [#"../src/lib.rs" 510 4 510 33] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) (value : v) : () + requires {[#"../src/lib.rs" 504 15 504 31] Invariant0.invariant' self} + requires {[#"../src/lib.rs" 505 4 506 62] forall i : int . i >= 0 /\ i < UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + requires {[#"../src/lib.rs" 507 4 508 62] forall i : int . i >= UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_VacantEntry_Type.vacantentry_map self))) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + ensures { [#"../src/lib.rs" 509 14 509 37] IsSorted0.is_sorted ( ^ Vecmap_VacantEntry_Type.vacantentry_map self) } + +end +module Vecmap_Impl7_Insert + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve3 with + type t = Vecmap_VecMap_Type.t_vecmap k v + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_VacantEntry_Type as Vecmap_VacantEntry_Type + clone Vecmap_Impl15_Resolve as Resolve2 with + type k = k, + type v = v, + predicate Resolve0.resolve = Resolve3.resolve, + predicate Resolve1.resolve = Resolve0.resolve + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone Vecmap_Impl1_InsertInternal_Interface as InsertInternal0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function DeepModel0.deep_model = DeepModel0.deep_model, + predicate GtLog0.gt_log = GtLog0.gt_log, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve1 with + type self = v + clone Vecmap_Impl6_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + let rec cfg insert [@cfg:stackify] [#"../src/lib.rs" 510 4 510 33] (self : Vecmap_VacantEntry_Type.t_vacantentry k v) (value : v) : () + requires {[#"../src/lib.rs" 504 15 504 31] Invariant0.invariant' self} + requires {[#"../src/lib.rs" 505 4 506 62] forall i : int . i >= 0 /\ i < UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) -> LtLog0.lt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + requires {[#"../src/lib.rs" 507 4 508 62] forall i : int . i >= UInt64.to_int (Vecmap_VacantEntry_Type.vacantentry_index self) /\ i < Seq.length (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_VacantEntry_Type.vacantentry_map self))) -> GtLog0.gt_log (Seq.get (KeySeq0.key_seq ( * Vecmap_VacantEntry_Type.vacantentry_map self)) i) (DeepModel0.deep_model (Vecmap_VacantEntry_Type.vacantentry_key self))} + ensures { [#"../src/lib.rs" 509 14 509 37] IsSorted0.is_sorted ( ^ Vecmap_VacantEntry_Type.vacantentry_map self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : Vecmap_VacantEntry_Type.t_vacantentry k v; + var value_2 : v; + var _7 : borrowed (Vecmap_VecMap_Type.t_vecmap k v); + var _8 : usize; + var _9 : k; + var _10 : v; + { + self_1 <- self; + value_2 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + goto BB3 + } + BB3 { + _7 <- borrow_mut ( * Vecmap_VacantEntry_Type.vacantentry_map self_1); + self_1 <- (let Vecmap_VacantEntry_Type.C_VacantEntry a b c = self_1 in Vecmap_VacantEntry_Type.C_VacantEntry ({ (Vecmap_VacantEntry_Type.vacantentry_map self_1) with current = ( ^ _7) }) b c); + _8 <- Vecmap_VacantEntry_Type.vacantentry_index self_1; + assume { Resolve0.resolve _9 }; + _9 <- Vecmap_VacantEntry_Type.vacantentry_key self_1; + self_1 <- (let Vecmap_VacantEntry_Type.C_VacantEntry a b c = self_1 in Vecmap_VacantEntry_Type.C_VacantEntry a (any k) c); + assume { Resolve1.resolve _10 }; + _10 <- value_2; + value_2 <- any v; + _0 <- ([#"../src/lib.rs" 511 8 511 61] InsertInternal0.insert_internal _7 _8 _9 _10); + goto BB4 + } + BB4 { + goto BB5 + } + BB5 { + goto BB6 + } + BB6 { + assume { Resolve2.resolve self_1 }; + return _0 + } + +end +module Vecmap_Impl9_Replace_Interface + type k + type v + use prelude.Borrow + use mach.int.UInt64 + use seq.Seq + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max_Stub as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel_Stub as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val replace [@cfg:stackify] [#"../src/lib.rs" 537 4 537 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) (value : v) : () + requires {[#"../src/lib.rs" 535 4 535 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 535 4 535 40] Invariant0.invariant' ( ^ self) } + ensures { [#"../src/lib.rs" 536 14 536 54] (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( ^ self)))) (UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self))) in a) = value } + +end +module Vecmap_Impl9_Replace + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + use mach.int.UInt64 + use seq.Seq + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = Vecmap_OccupiedEntry_Type.t_occupiedentry k v + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = v + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg replace [@cfg:stackify] [#"../src/lib.rs" 537 4 537 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) (value : v) : () + requires {[#"../src/lib.rs" 535 4 535 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 535 4 535 40] Invariant0.invariant' ( ^ self) } + ensures { [#"../src/lib.rs" 536 14 536 54] (let (_, a) = Seq.get (ShallowModel0.shallow_model (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( ^ self)))) (UInt64.to_int (Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self))) in a) = value } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : (); + var self_1 : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v); + var value_2 : v; + var _6 : v; + var _7 : borrowed (k, v); + var _8 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _9 : usize; + { + self_1 <- self; + value_2 <- value; + goto BB0 + } + BB0 { + goto BB1 + } + BB1 { + assume { Resolve0.resolve _6 }; + _6 <- value_2; + value_2 <- any v; + _8 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1))); + self_1 <- { self_1 with current = (let Vecmap_OccupiedEntry_Type.C_OccupiedEntry a b c = * self_1 in Vecmap_OccupiedEntry_Type.C_OccupiedEntry ({ (Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1)) with current = (let Vecmap_VecMap_Type.C_VecMap a = * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1) in Vecmap_VecMap_Type.C_VecMap ( ^ _8)) }) b c) }; + _9 <- Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self_1); + assume { Resolve1.resolve self_1 }; + _7 <- ([#"../src/lib.rs" 538 8 538 30] IndexMut0.index_mut _8 _9); + goto BB2 + } + BB2 { + assume { Resolve0.resolve (let (_, a) = * _7 in a) }; + _7 <- { _7 with current = (let (a, b) = * _7 in (a, _6)) }; + goto BB3 + } + BB3 { + assume { Resolve2.resolve _7 }; + goto BB4 + } + BB4 { + _0 <- (); + goto BB5 + } + BB5 { + return _0 + } + +end +module Vecmap_Impl9_GetMut_Interface + type k + type v + use prelude.Borrow + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone Vecmap_Impl8_Invariant_Stub as Invariant0 with + type k = k, + type v = v + val get_mut [@cfg:stackify] [#"../src/lib.rs" 542 4 542 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) : borrowed v + requires {[#"../src/lib.rs" 541 4 541 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 541 4 541 40] Invariant0.invariant' ( ^ self) } + +end +module Vecmap_Impl9_GetMut + type k + type v + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Model_DeepModel_DeepModelTy_Type as DeepModelTy0 with + type self = k + clone CreusotContracts_Logic_Ord_OrdLogic_GtLog_Interface as GtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_GeLog_Interface as GeLog0 with + type self = DeepModelTy0.deepModelTy + use Core_Cmp_Ordering_Type as Core_Cmp_Ordering_Type + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLog_Interface as CmpLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_LeLog_Interface as LeLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_EqCmp_Interface as EqCmp0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym2_Interface as Antisym20 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Antisym1_Interface as Antisym10 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Trans_Interface as Trans0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_Refl_Interface as Refl0 with + type self = DeepModelTy0.deepModelTy, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGtLog_Interface as CmpGtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GtLog0.gt_log = GtLog0.gt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpGeLog_Interface as CmpGeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate GeLog0.ge_log = GeLog0.ge_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_LtLog_Interface as LtLog0 with + type self = DeepModelTy0.deepModelTy + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLtLog_Interface as CmpLtLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LtLog0.lt_log = LtLog0.lt_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Logic_Ord_OrdLogic_CmpLeLog_Interface as CmpLeLog0 with + type self = DeepModelTy0.deepModelTy, + predicate LeLog0.le_log = LeLog0.le_log, + function CmpLog0.cmp_log = CmpLog0.cmp_log, + axiom . + clone CreusotContracts_Std1_Slice_Impl0_ShallowModelTy_Type as ShallowModelTy1 with + type t = (k, v) + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + clone CreusotContracts_Std1_Vec_Impl0_ShallowModelTy_Type as ShallowModelTy0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global + clone Core_Slice_Index_Impl2_Output_Type as Output0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_ResolveElswhere as ResolveElswhere0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_HasValue as HasValue0 with + type t = (k, v) + clone CreusotContracts_Std1_Slice_Impl5_InBounds as InBounds0 with + type t = (k, v) + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + clone CreusotContracts_Model_Impl3_ShallowModel as ShallowModel1 with + type t = Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global), + type ShallowModelTy0.shallowModelTy = ShallowModelTy0.shallowModelTy, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model + clone CreusotContracts_Model_DeepModel_DeepModel_Interface as DeepModel0 with + type self = k, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl0_KeySeq as KeySeq0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy, + val Max0.mAX' = Max0.mAX', + axiom . + clone Vecmap_Impl0_IsSorted as IsSorted0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + predicate LtLog0.lt_log = LtLog0.lt_log, + val Max0.mAX' = Max0.mAX', + function DeepModel0.deep_model = DeepModel0.deep_model, + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve2 with + type t = v + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve1 with + type t = (k, v) + clone Alloc_Vec_Impl17_IndexMut_Interface as IndexMut0 with + type t = (k, v), + type i = usize, + type a = Alloc_Alloc_Global_Type.t_global, + function ShallowModel0.shallow_model = ShallowModel1.shallow_model, + predicate InBounds0.in_bounds = InBounds0.in_bounds, + predicate HasValue0.has_value = HasValue0.has_value, + function ShallowModel1.shallow_model = ShallowModel0.shallow_model, + predicate ResolveElswhere0.resolve_elswhere = ResolveElswhere0.resolve_elswhere, + type Output0.output = Output0.output, + val Max0.mAX' = Max0.mAX' + use Vecmap_OccupiedEntry_Type as Vecmap_OccupiedEntry_Type + clone CreusotContracts_Resolve_Impl1_Resolve as Resolve0 with + type t = Vecmap_OccupiedEntry_Type.t_occupiedentry k v + clone Vecmap_Impl8_Invariant as Invariant0 with + type k = k, + type v = v, + predicate IsSorted0.is_sorted = IsSorted0.is_sorted, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + function KeySeq0.key_seq = KeySeq0.key_seq, + function DeepModel0.deep_model = DeepModel0.deep_model, + val Max0.mAX' = Max0.mAX', + type DeepModelTy0.deepModelTy = DeepModelTy0.deepModelTy + let rec cfg get_mut [@cfg:stackify] [#"../src/lib.rs" 542 4 542 39] (self : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v)) : borrowed v + requires {[#"../src/lib.rs" 541 4 541 40] Invariant0.invariant' ( * self)} + ensures { [#"../src/lib.rs" 541 4 541 40] Invariant0.invariant' ( ^ self) } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : borrowed v; + var self_1 : borrowed (Vecmap_OccupiedEntry_Type.t_occupiedentry k v); + var _2 : borrowed v; + var _5 : borrowed v; + var _6 : borrowed (k, v); + var _7 : borrowed (Alloc_Vec_Vec_Type.t_vec (k, v) (Alloc_Alloc_Global_Type.t_global)); + var _8 : usize; + { + self_1 <- self; + goto BB0 + } + BB0 { + _7 <- borrow_mut (Vecmap_VecMap_Type.vecmap_v ( * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1))); + self_1 <- { self_1 with current = (let Vecmap_OccupiedEntry_Type.C_OccupiedEntry a b c = * self_1 in Vecmap_OccupiedEntry_Type.C_OccupiedEntry ({ (Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1)) with current = (let Vecmap_VecMap_Type.C_VecMap a = * Vecmap_OccupiedEntry_Type.occupiedentry_map ( * self_1) in Vecmap_VecMap_Type.C_VecMap ( ^ _7)) }) b c) }; + _8 <- Vecmap_OccupiedEntry_Type.occupiedentry_index ( * self_1); + assume { Resolve0.resolve self_1 }; + _6 <- ([#"../src/lib.rs" 543 13 543 35] IndexMut0.index_mut _7 _8); + goto BB1 + } + BB1 { + _5 <- borrow_mut (let (_, a) = * _6 in a); + _6 <- { _6 with current = (let (a, b) = * _6 in (a, ^ _5)) }; + assume { Resolve1.resolve _6 }; + _2 <- borrow_mut ( * _5); + _5 <- { _5 with current = ( ^ _2) }; + assume { Resolve2.resolve _5 }; + _0 <- borrow_mut ( * _2); + _2 <- { _2 with current = ( ^ _0) }; + assume { Resolve2.resolve _2 }; + return _0 + } + +end +module Core_Clone_Clone_Clone_Interface + type self + use prelude.Borrow + val clone' [@cfg:stackify] (self : self) : self + ensures { result = self } + +end +module Core_Clone_Clone_Clone + type self + use prelude.Borrow + val clone' [@cfg:stackify] (self : self) : self + ensures { result = self } + +end +module Core_Clone_Impls_Impl5_Clone_Interface + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + val clone' [@cfg:stackify] (self : usize) : usize + ensures { result = self } + +end +module Core_Clone_Impls_Impl5_Clone + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + val clone' [@cfg:stackify] (self : usize) : usize + ensures { result = self } + +end +module Vecmap_Impl17_Clone_Interface + type k + use prelude.Borrow + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + val clone' [@cfg:stackify] [#"../src/lib.rs" 550 15 550 20] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 550 15 550 20] result = self } + +end +module Vecmap_Impl17_Clone + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone Core_Clone_Impls_Impl5_Clone_Interface as Clone1 + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + clone Core_Clone_Clone_Clone_Interface as Clone0 with + type self = k + let rec cfg clone' [@cfg:stackify] [#"../src/lib.rs" 550 15 550 20] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + ensures { [#"../src/lib.rs" 550 15 550 20] result = self } + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_KeyRef_Type.t_keyref k; + var _3 : k; + var _4 : k; + var _5 : usize; + var _6 : usize; + { + self_1 <- self; + goto BB0 + } + BB0 { + _4 <- Vecmap_KeyRef_Type.keyref_key self_1; + _3 <- ([#"../src/lib.rs" 552 4 552 14] Clone0.clone' _4); + goto BB1 + } + BB1 { + _6 <- Vecmap_KeyRef_Type.keyref_min_idx self_1; + assume { Resolve0.resolve self_1 }; + _5 <- ([#"../src/lib.rs" 553 4 555 18] Clone1.clone' _6); + goto BB2 + } + BB2 { + _0 <- Vecmap_KeyRef_Type.C_KeyRef _3 _5; + goto BB3 + } + BB3 { + return _0 + } + +end +module Vecmap_Impl11_Cloned_Interface + type k + use prelude.Borrow + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + val cloned [@cfg:stackify] [#"../src/lib.rs" 569 4 569 36] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + +end +module Vecmap_Impl11_Cloned + type k + use prelude.Borrow + use mach.int.Int + use prelude.UIntSize + clone Core_Clone_Clone_Clone_Interface as Clone0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = Vecmap_KeyRef_Type.t_keyref k + let rec cfg cloned [@cfg:stackify] [#"../src/lib.rs" 569 4 569 36] (self : Vecmap_KeyRef_Type.t_keyref k) : Vecmap_KeyRef_Type.t_keyref k + + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var self_1 : Vecmap_KeyRef_Type.t_keyref k; + var _2 : usize; + var _3 : k; + var _4 : k; + { + self_1 <- self; + goto BB0 + } + BB0 { + _2 <- Vecmap_KeyRef_Type.keyref_min_idx self_1; + _4 <- Vecmap_KeyRef_Type.keyref_key self_1; + assume { Resolve0.resolve self_1 }; + _3 <- ([#"../src/lib.rs" 572 17 572 33] Clone0.clone' _4); + goto BB1 + } + BB1 { + _0 <- Vecmap_KeyRef_Type.C_KeyRef _3 _2; + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl14_From_Interface + type k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + val from [@cfg:stackify] [#"../src/lib.rs" 607 4 607 27] (key : k) : Vecmap_KeyRef_Type.t_keyref k +end +module Vecmap_Impl14_From + type k + use mach.int.Int + use prelude.UIntSize + clone CreusotContracts_Resolve_Resolve_Resolve_Interface as Resolve0 with + type self = k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + let rec cfg from [@cfg:stackify] [#"../src/lib.rs" 607 4 607 27] (key : k) : Vecmap_KeyRef_Type.t_keyref k + = [@vc:do_not_keep_trace] [@vc:sp] + var _0 : Vecmap_KeyRef_Type.t_keyref k; + var key_1 : k; + var _2 : k; + { + key_1 <- key; + goto BB0 + } + BB0 { + assume { Resolve0.resolve _2 }; + _2 <- key_1; + key_1 <- any k; + _0 <- Vecmap_KeyRef_Type.C_KeyRef _2 ([#"../src/lib.rs" 608 29 608 30] (0 : usize)); + goto BB1 + } + BB1 { + goto BB2 + } + BB2 { + return _0 + } + +end +module Vecmap_Impl2 + type k + type v + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl2_Clone_Interface as Clone0 with + type k = k, + type v = v + clone Core_Clone_Clone_Clone_Interface as Clone1 with + type self = Vecmap_VecMap_Type.t_vecmap k v, + val clone' = Clone0.clone' +end +module Vecmap_Impl17 + type k + use Vecmap_KeyRef_Type as Vecmap_KeyRef_Type + clone Vecmap_Impl17_Clone_Interface as Clone0 with + type k = k + clone Core_Clone_Clone_Clone_Interface as Clone1 with + type self = Vecmap_KeyRef_Type.t_keyref k, + val clone' = Clone0.clone' +end +module CreusotContracts_Std1_Default_Default_IsDefault_Stub + type self + predicate is_default (self : self) +end +module CreusotContracts_Std1_Default_Default_IsDefault_Interface + type self + predicate is_default (self : self) +end +module CreusotContracts_Std1_Default_Default_IsDefault + type self + predicate is_default (self : self) + val is_default (self : self) : bool + ensures { result = is_default self } + +end +module Core_Default_Default_Default_Interface + type self + clone CreusotContracts_Std1_Default_Default_IsDefault_Stub as IsDefault0 with + type self = self + val default [@cfg:stackify] (_1' : ()) : self + ensures { IsDefault0.is_default result } + +end +module Core_Default_Default_Default + type self + clone CreusotContracts_Std1_Default_Default_IsDefault_Interface as IsDefault0 with + type self = self + val default [@cfg:stackify] (_1' : ()) : self + ensures { IsDefault0.is_default result } + +end +module Vecmap_Impl3 + type k + type v + use Alloc_Alloc_Global_Type as Alloc_Alloc_Global_Type + use Alloc_Vec_Vec_Type as Alloc_Vec_Vec_Type + clone Core_Num_Impl12_Max as Max0 + clone CreusotContracts_Std1_Vec_Impl0_ShallowModel as ShallowModel0 with + type t = (k, v), + type a = Alloc_Alloc_Global_Type.t_global, + val Max0.mAX' = Max0.mAX', + axiom . + use Vecmap_VecMap_Type as Vecmap_VecMap_Type + clone Vecmap_Impl4_IsDefault as IsDefault0 with + type k = k, + type v = v, + function ShallowModel0.shallow_model = ShallowModel0.shallow_model, + val Max0.mAX' = Max0.mAX' + clone Vecmap_Impl3_Default_Interface as Default0 with + type k = k, + type v = v, + predicate IsDefault0.is_default = IsDefault0.is_default + clone Core_Default_Default_Default_Interface as Default1 with + type self = Vecmap_VecMap_Type.t_vecmap k v, + val default = Default0.default, + predicate IsDefault0.is_default = IsDefault0.is_default +end +module Vecmap_Impl4 + type k + type v +end +module Vecmap_Impl15 + type k + type v +end +module Vecmap_Impl6 + type k + type v +end +module Vecmap_Impl8 + type k + type v +end +module Vecmap_Impl16 + type k +end +module Vecmap_Impl10 + type k +end +module Vecmap_Impl14 + type k +end